linkml 1.9.2rc1__py3-none-any.whl → 1.9.3__py3-none-any.whl

linkml/linter/config/datamodel/config.yaml

@@ -20,7 +20,7 @@ classes:
   Config:
     tree_root: true
     description: >-
-      This is the top-level representation of a LinkML linter configuration file. It allows 
+      This is the top-level representation of a LinkML linter configuration file. It allows
       defining a set of rules while also optionally extending a predefined set of rules.
     attributes:
       extends:
@@ -31,11 +31,11 @@ classes:
         range: Rules
         description: >-
           This is where a configuration defines its rules and the configuration of those rules.
-  
+
   Rules:
     description: >-
-      Each attribute of this class represents a rule that can be enabled and possibly 
-      configured by a configuration file. 
+      Each attribute of this class represents a rule that can be enabled and possibly
+      configured by a configuration file.
     attributes:
       no_empty_title:
         range: NoEmptyTitleConfig
@@ -50,7 +50,7 @@ classes:
       tree_root_class:
         range: TreeRootClassRuleConfig
         description: >-
-          Require a single class with `tree_root: true` and optionally verify that class's 
+          Require a single class with `tree_root: true` and optionally verify that class's
           name. Autofix will create a new class with `tree_root: true`, a name based on
           the rule configuration, and slots for existing classes.
       recommended:
@@ -61,18 +61,33 @@ classes:
       no_xsd_int_type:
         range: RuleConfig
         description: >-
-          Disallow use of `uri: xsd:int` in type definitions. Autofix will change the 
+          Disallow use of `uri: xsd:int` in type definitions. Autofix will change the
           uri to xsd:integer.
       no_invalid_slot_usage:
         range: RuleConfig
         description: >-
           Disallow slot_usage definitions where the name of the slot does not refer
           to an existing slot. Not auto-fixable.
+      no_undeclared_slots:
+        range: RuleConfig
+        description: >-
+          Disallow the use of slots in class specifications if the name of the slot
+          does not refer to an existing slot. Not auto-fixable.
+      no_undeclared_ranges:
+        range: RuleConfig
+        description: >-
+          Disallow the use of ranges in slot specifications if any of the ranges used
+          do not refer to an existing type, class, or enum. Not auto-fixable.
+      root_type_checks:
+        range: RuleConfig
+        description: >-
+          Ensure that root types, types with no `typeof` attributes, have the required slots, and
+          that values used in the `typeof` slot refer to valid types. Not auto-fixable.
       standard_naming:
         range: StandardNamingConfig
         description: >-
           Enforce standard naming conventions: CamelCase for classes, snake_case for slots,
-          CamelCase for enums, snake_case (default) or UPPER_SNAKE for permissible_values 
+          CamelCase for enums, snake_case (default) or UPPER_SNAKE for permissible_values
           (see permissible_values_upper_case option). This rule may conflict with the
           permissible_values_format rule. Not auto-fixable.
       canonical_prefixes:
@@ -84,7 +99,7 @@ classes:
 
   RuleConfig:
     description: >-
-      This is the base class for linter rules. It contains configuration options that are 
+      This is the base class for linter rules. It contains configuration options that are
       common to all rules.
     attributes:
       level:
@@ -188,8 +203,8 @@ classes:
         multivalued: true
         description: >-
           Default: [merged]
-          The list of context names which will be loaded by the `prefixmaps` library to do the 
-          validation. The order of names is meaningful and will be preserved. See:  
+          The list of context names which will be loaded by the `prefixmaps` library to do the
+          validation. The order of names is meaningful and will be preserved. See:
           https://github.com/linkml/prefixmaps#usage
 
   NoEmptyTitleConfig:
@@ -202,7 +217,7 @@ classes:
         multivalued: true
         description: >-
           Default: []
-          Elements of all types (ClassDefinition, SlotDefinition, EnumDefinition, PermissibleValue, etc.) except the types specified in this list will be checked 
+          Elements of all types (ClassDefinition, SlotDefinition, EnumDefinition, PermissibleValue, etc.) except the types specified in this list will be checked
 
 enums:
   ExtendableConfigs:

linkml/linter/config/default.yaml

@@ -18,6 +18,12 @@ rules:
     level: disabled
   no_invalid_slot_usage:
     level: disabled
+  no_undeclared_slots:
+    level: disabled
+  no_undeclared_ranges:
+    level: disabled
+  root_type_checks:
+    level: disabled
   standard_naming:
     level: disabled
     permissible_values_upper_case: false

linkml/linter/config/recommended.yaml

@@ -5,6 +5,12 @@ rules:
     level: error
   no_invalid_slot_usage:
     level: error
+  no_undeclared_slots:
+    level: error
+  no_undeclared_ranges:
+    level: error
+  root_type_checks:
+    level: error
   standard_naming:
     level: warning
   canonical_prefixes:

linkml/linter/linter.py

@@ -1,10 +1,14 @@
+"""Linkml linter."""
+
+from __future__ import annotations
+
 import inspect
 from collections.abc import Iterable
 from copy import deepcopy
 from dataclasses import dataclass
 from functools import lru_cache
 from pathlib import Path
-from typing import Any, Union
+from typing import Any
 
 import jsonschema
 import yaml
@@ -23,10 +27,10 @@ from .config.datamodel.config import Config, ExtendableConfigs, RuleLevel
 @dataclass
 class LinterProblem:
     message: str
-    level: Union[RuleLevel, None] = None
-    schema_name: Union[str, None] = None
-    schema_source: Union[str, None] = None
-    rule_name: Union[str, None] = None
+    level: RuleLevel | None = None
+    schema_name: str | None = None
+    schema_source: str | None = None
+    rule_name: str | None = None
 
 
 @lru_cache
@@ -107,7 +111,7 @@ class Linter:
 
     def lint(
         self,
-        schema: Union[str, SchemaDefinition],
+        schema: str | SchemaDefinition,
         fix: bool = False,
         validate_schema: bool = False,
         validate_only: bool = False,

linkml/linter/rules.py

@@ -1,23 +1,35 @@
+"""Rule implementation for the linkml linter."""
+
+from __future__ import annotations
+
 import re
 from abc import ABC, abstractmethod
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from functools import cache
-from typing import Callable
 
-from linkml_runtime.linkml_model import ClassDefinition, ClassDefinitionName, Element, SlotDefinition
+from linkml_runtime.linkml_model import (
+    ClassDefinition,
+    ClassDefinitionName,
+    Element,
+    ElementName,
+    EnumDefinition,
+    EnumDefinitionName,
+    SlotDefinition,
+    TypeDefinition,
+    TypeDefinitionName,
+)
 from linkml_runtime.utils.schemaview import SchemaView
 from prefixmaps.io.parser import load_multi_context
 
 from linkml import LOCAL_METAMODEL_YAML_FILE
-
-from .config.datamodel.config import (
+from linkml.linter.config.datamodel.config import (
     CanonicalPrefixesConfig,
     RecommendedRuleConfig,
     RuleConfig,
     StandardNamingConfig,
     TreeRootClassRuleConfig,
 )
-from .linter import LinterProblem
+from linkml.linter.linter import LinterProblem
 
 
 class LinterRule(ABC):
@@ -91,7 +103,7 @@ class PermissibleValuesFormatRule(LinterRule):
     def check(self, schema_view: SchemaView, fix: bool = False) -> Iterable[LinterProblem]:
         pattern = self.PATTERNS.get(self.config.format, re.compile(self.config.format))
         for enum_def in schema_view.all_enums(imports=False).values():
-            for value in enum_def.permissible_values.keys():
+            for value in enum_def.permissible_values:
                 if pattern.fullmatch(value) is None:
                     yield LinterProblem(f"{self.format_element(enum_def)} has permissible value '{value}'")
 
@@ -150,25 +162,23 @@ class TreeRootClassRule(LinterRule):
                         yield LinterProblem(message=f"Tree root class has an invalid name '{tree_root.name}'")
             if len(tree_roots) > 1:
                 yield LinterProblem("Schema has more than one class with `tree_root: true`")
+        elif fix:
+            container = ClassDefinition(self.config.root_class_name, tree_root=True)
+            schema_view.add_class(container)
+            self.add_index_slots(schema_view, container.name)
         else:
-            if fix:
-                container = ClassDefinition(self.config.root_class_name, tree_root=True)
-                schema_view.add_class(container)
-                self.add_index_slots(schema_view, container.name)
-            else:
-                yield LinterProblem("Schema does not have class with `tree_root: true`")
+            yield LinterProblem("Schema does not have class with `tree_root: true`")
 
     def add_index_slots(
         self,
         schema_view: SchemaView,
         container_name: ClassDefinitionName,
-        inlined_as_list=False,
-        must_have_identifier=False,
-        slot_name_func: Callable = None,
-        convert_camel_case=False,
+        inlined_as_list: bool = False,
+        must_have_identifier: bool = False,
+        slot_name_func: Callable | None = None,
+        convert_camel_case: bool = False,
     ) -> list[SlotDefinition]:
-        """
-        Adds index slots to a container pointing at all top-level classes
+        """Add index slots to a container pointing at all top-level classes.
 
         :param schema: input schema, will be modified in place
         :param container_name:
@@ -178,14 +188,11 @@ class TreeRootClassRule(LinterRule):
         :return: new slots
         """
         container = schema_view.get_class(container_name)
-        ranges = set()
-        for cn in schema_view.all_classes():
-            for s in schema_view.class_induced_slots(cn):
-                ranges.add(s.range)
+        ranges = {s.range for cn in schema_view.all_classes() for s in schema_view.class_induced_slots(cn)}
         top_level_classes = [c for c in schema_view.all_classes().values() if not c.tree_root and c.name not in ranges]
         if must_have_identifier:
             top_level_classes = [c for c in top_level_classes if schema_view.get_identifier_slot(c.name) is not None]
-        index_slots = []
+        index_slots: list[SlotDefinition] = []
         for c in top_level_classes:
             has_identifier = schema_view.get_identifier_slot(c.name)
             if slot_name_func:
@@ -208,6 +215,30 @@ class TreeRootClassRule(LinterRule):
         return index_slots
 
 
+class NoUndeclaredSlotsRule(LinterRule):
+    """Linter rule to check that all slots from a class have been declared in the `slots` section."""
+
+    id = "no_undeclared_slots"
+
+    def check(self, schema_view: SchemaView, fix: bool = False) -> Iterable[LinterProblem]:
+        """Perform the check for undeclared slots.
+
+        :param schema_view: schema to be checked in a SchemaView object.
+        :type schema_view: SchemaView
+        :param fix: whether or not to fix, defaults to False
+        :type fix: bool, optional
+        :yield: iterable of error messages about non-compliant slots.
+        :rtype: Iterator[Iterable[LinterProblem]]
+        """
+        all_slots = schema_view.all_slots()
+        for class_name in schema_view.all_classes():
+            for slot_name in schema_view.class_slots(class_name):
+                if slot_name not in all_slots:
+                    yield LinterProblem(
+                        f"Slot '{slot_name}' from class '{class_name}' not found in schema 'slots' declaration."
+                    )
+
+
 class NoInvalidSlotUsageRule(LinterRule):
     id = "no_invalid_slot_usage"
 
@@ -217,11 +248,76 @@ class NoInvalidSlotUsageRule(LinterRule):
             if not slot_usage:
                 continue
             class_slots = schema_view.class_slots(class_name)
-            for slot_usage_name in slot_usage.keys():
+            for slot_usage_name in slot_usage:
                 if slot_usage_name not in class_slots:
                     yield LinterProblem(f"Slot '{slot_usage_name}' not found on class '{class_name}'")
 
 
+class NoUndeclaredRangesRule(LinterRule):
+    id = "no_undeclared_ranges"
+
+    def check(self, schema_view: SchemaView, fix: bool = False) -> Iterable[LinterProblem]:
+        all_types: dict[TypeDefinitionName, TypeDefinition] = schema_view.all_types()
+        all_enums: dict[EnumDefinitionName, EnumDefinition] = schema_view.all_enums()
+        all_classes: dict[ClassDefinitionName, ClassDefinition] = schema_view.all_classes()
+        all_possible_ranges: set[TypeDefinitionName | EnumDefinitionName | ClassDefinitionName] = (
+            set(all_types) | set(all_enums) | set(all_classes)
+        )
+
+        # check that the default_range has a valid value
+        default_range = schema_view.schema.default_range
+        if default_range and default_range not in all_possible_ranges:
+            yield LinterProblem(f"Schema default_range '{default_range}' is not defined.")
+
+        for class_name in schema_view.all_classes():
+            for slot in schema_view.class_induced_slots(class_name):
+                slot_range: set[ElementName] = set(schema_view.slot_range_as_union(slot))
+
+                # check slot range is valid
+                for range_name in slot_range:
+                    if range_name not in all_possible_ranges:
+                        yield LinterProblem(
+                            f"Class '{class_name}' slot '{slot.name}' range '{range_name}' is not defined."
+                        )
+
+
+class RootTypeChecks(LinterRule):
+    """Performs basic checks on types.
+
+    Types can be defined as subtypes of existing types using the `typeof` attribute.
+    Root types are those types that do not inherit from other types using `typeof`.
+
+    - types used in 'typeof' statements must be defined in the types section
+    - types cannot be their own 'typeof' parent
+    - every root type must have a 'base'
+    - every root type must have a 'uri'
+
+    :param LinterRule: linter rule class
+    :type LinterRule: LinterRule
+    """
+
+    id = "root_type_checks"
+
+    def check(self, schema_view: SchemaView, fix: bool = False) -> Iterable[LinterProblem]:
+        type_ix = schema_view.all_types()
+        for t, type_def in type_ix.items():
+            if type_def.typeof:
+                # This is a child type. Ensure that the parent exists.
+                if type_def.typeof not in schema_view.all_types():
+                    yield LinterProblem(f"'{t}' has invalid typeof parent '{type_def.typeof}'")
+                # Ensure that a type is not its own parent.
+                # N.b. at some point, this can/should be extended to checking the full 'typeof' ancestor chain
+                # for circular inheritance.
+                if type_def.typeof == type_def.name:
+                    yield LinterProblem(f"'{t}' has invalid circular typeof parent '{type_def.typeof}'")
+                continue
+            if not type_def.base:
+                yield LinterProblem(f"Root type '{t}' is missing the required 'base' attribute")
+
+            if not type_def.uri:
+                yield LinterProblem(f"Root type '{t}' is missing the required 'uri' attribute")
+
+
 class StandardNamingRule(LinterRule):
     id = "standard_naming"
 
@@ -247,23 +343,21 @@ class StandardNamingRule(LinterRule):
         )
 
         if "class_definition" not in excluded_types:
-            for class_name in schema_view.all_classes(imports=False).keys():
+            for class_name in schema_view.all_classes(imports=False):
                 if class_pattern.fullmatch(class_name) is None:
                     yield LinterProblem(f"Class has name '{class_name}'")
 
         if "slot_definition" not in excluded_types:
-            for slot_name in schema_view.all_slots(imports=False).keys():
+            for slot_name in schema_view.all_slots(imports=False):
                 if slot_pattern.fullmatch(slot_name) is None:
                     yield LinterProblem(f"Slot has name '{slot_name}'")
 
         for enum_name, enum_definition in schema_view.all_enums(imports=False).items():
-
-            if "enum_definition" not in excluded_types:
-                if enum_pattern.fullmatch(enum_name) is None:
-                    yield LinterProblem(f"Enum has name '{enum_name}'")
+            if "enum_definition" not in excluded_types and enum_pattern.fullmatch(enum_name) is None:
+                yield LinterProblem(f"Enum has name '{enum_name}'")
 
             if "permissible_value" not in excluded_types:
-                for permissible_value_name in enum_definition.permissible_values.keys():
+                for permissible_value_name in enum_definition.permissible_values:
                     if permissible_value_pattern.fullmatch(permissible_value_name) is None:
                         yield LinterProblem(
                             f"Permissible value of {self.format_element(enum_definition)} "
@@ -282,17 +376,21 @@ class CanonicalPrefixesRule(LinterRule):
         prefix_to_namespace = context.as_dict()
         namespace_to_prefix = context.as_inverted_dict()
         for prefix in schema_view.schema.prefixes.values():
-            if prefix.prefix_prefix in prefix_to_namespace:
-                if prefix.prefix_reference != prefix_to_namespace[prefix.prefix_prefix]:
-                    yield LinterProblem(
-                        f"Schema maps prefix '{prefix.prefix_prefix}' to namespace "
-                        f"'{prefix.prefix_reference}' instead of namespace "
-                        f"'{prefix_to_namespace[prefix.prefix_prefix]}'"
-                    )
-            if prefix.prefix_reference in namespace_to_prefix:
-                if prefix.prefix_prefix != namespace_to_prefix[prefix.prefix_reference]:
-                    yield LinterProblem(
-                        f"Schema maps prefix '{prefix.prefix_prefix}' to namespace "
-                        f"'{prefix.prefix_reference}' instead of using prefix "
-                        f"'{namespace_to_prefix[prefix.prefix_reference]}'"
-                    )
+            if (
+                prefix.prefix_prefix in prefix_to_namespace
+                and prefix.prefix_reference != prefix_to_namespace[prefix.prefix_prefix]
+            ):
+                yield LinterProblem(
+                    f"Schema maps prefix '{prefix.prefix_prefix}' to namespace "
+                    f"'{prefix.prefix_reference}' instead of namespace "
+                    f"'{prefix_to_namespace[prefix.prefix_prefix]}'"
+                )
+            if (
+                prefix.prefix_reference in namespace_to_prefix
+                and prefix.prefix_prefix != namespace_to_prefix[prefix.prefix_reference]
+            ):
+                yield LinterProblem(
+                    f"Schema maps prefix '{prefix.prefix_prefix}' to namespace "
+                    f"'{prefix.prefix_reference}' instead of using prefix "
+                    f"'{namespace_to_prefix[prefix.prefix_reference]}'"
+                )

linkml/transformers/relmodel_transformer.py

@@ -181,6 +181,7 @@ class RelationalModelTransformer:
             types=source.types,
             subsets=source.subsets,
             enums=source.enums,
+            annotations=source.annotations,
         )
         target.prefixes["rr"] = Prefix("rr", "http://www.w3.org/ns/r2rml#")
 
@@ -196,6 +197,7 @@ class RelationalModelTransformer:
                 abstract=c.abstract,
                 description=c.description,
                 unique_keys=c.unique_keys,
+                annotations=c.annotations,
             )
             for slot in source_sv.class_induced_slots(cn):
                 tgt_slot = copy(slot)
@@ -209,7 +211,6 @@ class RelationalModelTransformer:
             # this is required in case an attribute inherits from a slot
             for sn in source_sv.all_slots(attributes=False):
                 slot = source_sv.get_slot(sn)
-                # target.slots[slot.name] = copy(slot)
             target.classes[c.name] = c
 
         target_sv = SchemaView(target)

linkml/utils/generator.py

@@ -344,6 +344,9 @@ class Generator(metaclass=abc.ABCMeta):
         sub_out = self.end_schema(**kwargs)
         if sub_out is not None:
             out += sub_out
+        out = out.rstrip()
+        if not (out.count("\n") == 0 and out.startswith("http")):
+            out += "\n"
         return out
 
     def visit_schema(self, **kwargs) -> Optional[str]:

linkml/utils/logictools.py

@@ -125,11 +125,11 @@ class And(Expression):
         self.operands: list[Expression] = list(operands)
 
     def __str__(self):
-        return f'({" & ".join(str(operand) for operand in self.operands)})'
+        return f"({' & '.join(str(operand) for operand in self.operands)})"
 
     def _ordered_str(self, **kwargs):
         sorted_operands = sorted([op._ordered_str(**kwargs) for op in self.operands], key=str)
-        return f'({" & ".join(sorted_operands)})'
+        return f"({' & '.join(sorted_operands)})"
 
 
 class Or(Expression):
@@ -137,13 +137,13 @@ class Or(Expression):
         self.operands = list(operands)
 
     def __str__(self):
-        return f'({" | ".join(str(operand) for operand in self.operands)})'
+        return f"({' | '.join(str(operand) for operand in self.operands)})"
 
     def _ordered_str(self, pairwise=False):
         if pairwise and len(self.operands) > 2:
             return Or(Or(*self.operands[0:2]), Or(*self.operands[2:]))._ordered_str(pairwise=True)
         sorted_operands = sorted([op._ordered_str(pairwise=True) for op in self.operands], key=str)
-        return f'({" | ".join(sorted_operands)})'
+        return f"({' | '.join(sorted_operands)})"
 
 
 class Eq(Expression):
@@ -167,7 +167,7 @@ class Term(Expression):
         if self.predicate in OPS:
             return f"{str(self.operands[0])} {OPS[self.predicate]} {str(self.operands[1])}"
         else:
-            return f'{self.predicate}({", ".join(str(operand) for operand in self.operands)})'
+            return f"{self.predicate}({', '.join(str(operand) for operand in self.operands)})"
 
     def _ordered_str(self, **kwargs):
         return str(self)

linkml/utils/schemaloader.py

@@ -737,7 +737,7 @@ class SchemaLoader:
                 for slot_usage in values(cls.slot_usage):
                     if slot_usage.alias:
                         self.raise_value_error(
-                            f'Class: "{cls.name}" - alias not permitted in slot_usage slot:' f" {slot_usage.alias}"
+                            f'Class: "{cls.name}" - alias not permitted in slot_usage slot: {slot_usage.alias}'
                         )
                     if not located_aliased_parent_slot(cls, slot_usage):
                         if slot_usage.name not in self.schema.slots:
@@ -765,7 +765,7 @@ class SchemaLoader:
         for slotname, slot_usage in cls.slot_usage.items():
             if slot_usage.alias:
                 self.raise_value_error(
-                    f'Class: "{cls.name}" - alias not permitted in slot_usage slot:' f" {slot_usage.alias}"
+                    f'Class: "{cls.name}" - alias not permitted in slot_usage slot: {slot_usage.alias}'
                 )
             # Construct a new slot
             # If we've already assigned a parent, use it
@@ -947,7 +947,7 @@ class SchemaLoader:
             locs = "\n".join(TypedNode.yaml_loc(e, suffix="") for e in loc_str)
             raise ValueError(f"{locs} {error}")
         else:
-            raise ValueError(f'{TypedNode.yaml_loc(loc_str, suffix="")} {error}')
+            raise ValueError(f"{TypedNode.yaml_loc(loc_str, suffix='')} {error}")
 
     def logger_warning(
         self,
@@ -958,7 +958,7 @@ class SchemaLoader:
             locs = "\n\t".join(TypedNode.yaml_loc(e, suffix="") for e in loc_str)
             self.logger.warning(f"{warning}\n\t{locs}")
         else:
-            self.logger.warning(f'{warning}\n\t{TypedNode.yaml_loc(loc_str, suffix="")}')
+            self.logger.warning(f"{warning}\n\t{TypedNode.yaml_loc(loc_str, suffix='')}")
 
     def _get_base_dir(self, stated_base: str) -> Optional[str]:
         if stated_base:

linkml/utils/schemasynopsis.py

@@ -115,7 +115,11 @@ class SchemaSynopsis:
             (
                 ClassType
                 if v.range in self.schema.classes
-                else EnumType if v.range in self.schema.enums else TypeType if v.range in self.schema.types else None
+                else EnumType
+                if v.range in self.schema.enums
+                else TypeType
+                if v.range in self.schema.types
+                else None
             ),
             v.range,
         )
@@ -244,19 +248,19 @@ class SchemaSynopsis:
         rval = []
         undefined_classes = set(self.classrefs.keys()) - set(self.schema.classes.keys())
         if undefined_classes:
-            rval += [f"\tUndefined class references: " f"{', '.join(format_undefineds(undefined_classes))}"]
+            rval += [f"\tUndefined class references: {', '.join(format_undefineds(undefined_classes))}"]
         undefined_slots = set(self.slotrefs.keys()) - set(self.schema.slots.keys())
         if undefined_slots:
-            rval += [f"\tUndefined slot references: " f"{', '.join(format_undefineds(undefined_slots))}"]
+            rval += [f"\tUndefined slot references: {', '.join(format_undefineds(undefined_slots))}"]
         undefined_types = set(self.typerefs.keys()) - set(self.schema.types.keys())
         if undefined_types:
-            rval += [f"\tUndefined type references: " f"{', '.join(format_undefineds(undefined_types))}"]
+            rval += [f"\tUndefined type references: {', '.join(format_undefineds(undefined_types))}"]
         undefined_subsets = set(self.subsetrefs.keys()) - set(self.schema.subsets.keys())
         if undefined_subsets:
-            rval += [f"\tUndefined subset references: " f"{', '.join(format_undefineds(undefined_subsets))}"]
+            rval += [f"\tUndefined subset references: {', '.join(format_undefineds(undefined_subsets))}"]
         undefined_enums = set(self.enumrefs.keys()) - set(self.schema.enums.keys())
         if undefined_enums:
-            rval += [f"\tUndefined enun references: " f"{', '.join(format_undefineds(undefined_enums))}"]
+            rval += [f"\tUndefined enun references: {', '.join(format_undefineds(undefined_enums))}"]
 
         # Inlined slots must be multivalued (not a inviolable rule, but we make assumptions about this elsewhere in
         # the python generator
@@ -373,7 +377,7 @@ class SchemaSynopsis:
             for slotname in sorted(domain_mismatches):
                 rval.append(
                     f'\t\t\tSlot: "{slotname}" declared domain: "{self.schema.slots[slotname].domain}" '
-                    f'actual domain(s): {", ".join(self.slotclasses[slotname])}'
+                    f"actual domain(s): {', '.join(self.slotclasses[slotname])}"
                 )
         if unkdomains:
             rval += [f"\t* Unknown domain: {', '.join(sorted(unkdomains))}"]

linkml/workspaces/datamodel/workspaces.yaml

@@ -148,8 +148,3 @@ classes:
         description: >-
           If true, the workspace manager should immediately sync any changes made
         range: boolean
-
-
-
-
-

{linkml-1.9.2rc1.dist-info → linkml-1.9.3.dist-info}/LICENSE

@@ -10,4 +10,4 @@ Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
-limitations under the License.
+limitations under the License.

{linkml-1.9.2rc1.dist-info → linkml-1.9.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: linkml
-Version: 1.9.2rc1
+Version: 1.9.3
 Summary: Linked Open Data Modeling Language
 License: Apache-2.0
 Keywords: schema,linked data,data modeling,rdf,owl,biolink
@@ -34,7 +34,7 @@ Requires-Dist: isodate (>=0.6.0)
 Requires-Dist: jinja2 (>=3.1.0)
 Requires-Dist: jsonasobj2 (>=1.0.3,<2.0.0)
 Requires-Dist: jsonschema[format] (>=4.0.0)
-Requires-Dist: linkml-runtime (>=1.9.2,<2.0.0)
+Requires-Dist: linkml-runtime (>=1.9.4,<2.0.0)
 Requires-Dist: numpydantic (>=1.6.1) ; extra == "numpydantic"
 Requires-Dist: numpydantic (>=1.6.1) ; extra == "tests"
 Requires-Dist: openpyxl