linkml 1.5.5__py3-none-any.whl → 1.5.7__py3-none-any.whl

linkml/utils/schema_fixer.py

@@ -1,15 +1,21 @@
 import logging
 import re
-from copy import deepcopy, copy
+from copy import copy
 from dataclasses import dataclass
-from typing import Callable, List, Dict, Any, Union
+from typing import Any, Callable, Dict, List, Union
 
 import click
 import yaml
 from linkml_runtime import SchemaView
-from linkml_runtime.dumpers import json_dumper, yaml_dumper
-from linkml_runtime.linkml_model import (ClassDefinition, ClassDefinitionName,
-                                         SchemaDefinition, SlotDefinition, EnumDefinition, TypeDefinition)
+from linkml_runtime.dumpers import json_dumper
+from linkml_runtime.linkml_model import (
+    ClassDefinition,
+    ClassDefinitionName,
+    EnumDefinition,
+    SchemaDefinition,
+    SlotDefinition,
+    TypeDefinition,
+)
 from linkml_runtime.utils.formatutils import camelcase, underscore
 from linkml_runtime.utils.yamlutils import YAMLRoot
 
@@ -87,7 +93,7 @@ class SchemaFixer:
         tree_roots = [c for c in sv.all_classes().values() if c.tree_root]
         if len(tree_roots) > 0:
             if force:
-                logging.info(f"Forcing addition of containers")
+                logging.info("Forcing addition of containers")
             else:
                 raise ValueError(f"Schema already has containers: {tree_roots}")
         container = ClassDefinition(class_name, tree_root=True)
@@ -122,15 +128,11 @@ class SchemaFixer:
             for s in sv.class_induced_slots(cn):
                 ranges.add(s.range)
         top_level_classes = [
-            c
-            for c in sv.all_classes().values()
-            if not c.tree_root and c.name not in ranges
+            c for c in sv.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 sv.get_identifier_slot(c.name) is not None
+                c for c in top_level_classes if sv.get_identifier_slot(c.name) is not None
             ]
         index_slots = []
         for c in top_level_classes:
@@ -290,7 +292,13 @@ class SchemaFixer:
             self.history = []
         self.history.append(txt)
 
-    def fix_element_names(self, schema: SchemaDefinition, schema_dict: Dict[str, Any] = None, rules: Dict[str, Callable] = None, imports=False) -> Union[YAMLRoot, Dict]:
+    def fix_element_names(
+        self,
+        schema: SchemaDefinition,
+        schema_dict: Dict[str, Any] = None,
+        rules: Dict[str, Callable] = None,
+        imports=False,
+    ) -> Union[YAMLRoot, Dict]:
         """
         Changes element names to conform to naming conventions.
 
@@ -341,10 +349,12 @@ def main(verbose: int, quiet: bool):
 
 @main.command()
 @click.argument("input_schema")
-@click.option("--imports/--no-imports",
-              default=False,
-              show_default=True,
-              help="Apply fix to referenced elements from modules")
+@click.option(
+    "--imports/--no-imports",
+    default=False,
+    show_default=True,
+    help="Apply fix to referenced elements from modules",
+)
 def fix_name(input_schema, **kwargs):
     """Fix element names to conform to naming conventions"""
     with open(input_schema) as f:
@@ -356,4 +366,4 @@ def fix_name(input_schema, **kwargs):
 
 
 if __name__ == "__main__":
-    main()
+    main()

linkml/utils/schemaloader.py

@@ -2,29 +2,29 @@ import logging
 import os
 from collections import OrderedDict
 from copy import deepcopy
-from typing import (Dict, Iterator, List, Mapping, Optional, Set, TextIO,
-                    Tuple, Union, cast)
+from typing import Dict, Iterator, List, Mapping, Optional, Set, TextIO, Tuple, Union, cast
 from urllib.parse import urlparse
 
 from jsonasobj2 import values
-from linkml_runtime.linkml_model.meta import (ClassDefinition,
-                                              ClassDefinitionName, ElementName,
-                                              EnumDefinition,
-                                              EnumDefinitionName,
-                                              SchemaDefinition, SlotDefinition,
-                                              SlotDefinitionName,
-                                              TypeDefinition,
-                                              TypeDefinitionName)
+from linkml_runtime.linkml_model.meta import (
+    ClassDefinition,
+    ClassDefinitionName,
+    ElementName,
+    EnumDefinition,
+    EnumDefinitionName,
+    SchemaDefinition,
+    SlotDefinition,
+    SlotDefinitionName,
+    TypeDefinition,
+    TypeDefinitionName,
+)
 from linkml_runtime.utils.context_utils import parse_import_map
-from linkml_runtime.utils.formatutils import (camelcase,
-                                              mangled_attribute_name, sfx,
-                                              underscore)
+from linkml_runtime.utils.formatutils import camelcase, mangled_attribute_name, sfx, underscore
 from linkml_runtime.utils.metamodelcore import Bool
 from linkml_runtime.utils.namespaces import Namespaces
 from linkml_runtime.utils.yamlutils import TypedNode
 
-from linkml.utils.mergeutils import (merge_classes, merge_schemas, merge_slots,
-                                     slot_usage_name)
+from linkml.utils.mergeutils import merge_classes, merge_schemas, merge_slots, slot_usage_name
 from linkml.utils.rawloader import load_raw_schema
 from linkml.utils.schemasynopsis import SchemaSynopsis
 
@@ -56,9 +56,7 @@ class SchemaLoader:
         :param source_file_date: modification of source file
         :param source_file_size: size of source file
         """
-        self.logger = (
-            logger if logger is not None else logging.getLogger(self.__class__.__name__)
-        )
+        self.logger = logger if logger is not None else logging.getLogger(self.__class__.__name__)
         if isinstance(data, SchemaDefinition):
             self.schema = data
         else:
@@ -77,17 +75,13 @@ class SchemaLoader:
         self.namespaces = namespaces if namespaces else Namespaces()
         self.useuris = useuris if useuris is not None else True
         self.importmap = (
-            parse_import_map(importmap, self.base_dir)
-            if importmap is not None
-            else dict()
+            parse_import_map(importmap, self.base_dir) if importmap is not None else dict()
         )
         self.source_file_date = source_file_date
         self.source_file_size = source_file_size
         self.synopsis: Optional[SchemaSynopsis] = None
         self.schema_location: Optional[str] = None
-        self.schema_defaults: Dict[
-            str, str
-        ] = {}  # Map from schema URI to default namespace
+        self.schema_defaults: Dict[str, str] = {}  # Map from schema URI to default namespace
         self.merge_modules = mergeimports
         self.emit_metadata = emit_metadata
 
@@ -135,9 +129,7 @@ class SchemaLoader:
                         sname = os.path.join(self.importmap[pfx], ":".join(toks[1:]))
                     else:
                         sname = self.namespaces.uri_for(sname)
-            sname = self.importmap.get(
-                str(sname), sname
-            )  # It may also use URI or other forms
+            sname = self.importmap.get(str(sname), sname)  # It may also use URI or other forms
             import_schemadefinition = load_raw_schema(
                 sname + ".yaml",
                 base_dir=os.path.dirname(self.schema.source_file)
@@ -154,10 +146,12 @@ class SchemaLoader:
                         f"Schema {import_schemadefinition.name} - version mismatch",
                         import_schemadefinition.name,
                     )
-                # Note: for debugging purposes we also check whether the version came from the same spot.  This should
-                #       be loosened to version only once we're sure that everything is working
-                # TODO: The test below needs review -- there are cases where it fails because self.loaded[...][0] has the
-                #       full path name and loaded_schema[0] is just the local name
+                # Note: for debugging purposes we also check whether the version
+                #       came from the same spot.  This should be loosened to
+                #       version only once we're sure that everything is working
+                # TODO: The test below needs review -- there are cases where it
+                #       fails because self.loaded[...][0] has the full path name
+                #       and loaded_schema[0] is just the local name
                 # if self.loaded[import_schemadefinition.id] != loaded_schema:
                 #     self.raise_value_error(f"Schema imported from different files: "
                 #                            f"{self.loaded[import_schemadefinition.id][0]} : {loaded_schema[0]}")
@@ -270,7 +264,7 @@ class SchemaLoader:
                 from_schema = cls.from_schema
                 if from_schema is None:
                     from_schema = self.schema.id
-                #if cls.from_schema is None:
+                # if cls.from_schema is None:
                 #    raise Exception(f"Class has no from_schema: {cls}")
                 suffixed_cls_schema = sfx(from_schema)
                 cls.class_uri = self.namespaces.uri_or_curie_for(
@@ -308,7 +302,6 @@ class SchemaLoader:
                     slot.range = self.schema.default_range
 
         # Update enums
-        merged_enums: List[EnumDefinitionName] = []
         for enum in self.schema.enums.values():
             if not enum.from_schema:
                 enum.from_schema = self.schema.id
@@ -335,9 +328,7 @@ class SchemaLoader:
                     typ.name,
                 )
             if not typ.typeof and not typ.uri:
-                self.raise_value_error(
-                    f'type "{typ.name}" does not declare a URI', typ.name
-                )
+                self.raise_value_error(f'type "{typ.name}" does not declare a URI', typ.name)
             self.merge_type(typ, merged_types)
             if not typ.from_schema:
                 typ.from_schema = self.schema.id
@@ -366,10 +357,7 @@ class SchemaLoader:
 
             # Propagate domain to containing class
             if slot.domain and slot.domain in self.schema.classes:
-                if (
-                    slot.name not in self.schema.classes[slot.domain].slots
-                    and not slot.owner
-                ):
+                if slot.name not in self.schema.classes[slot.domain].slots and not slot.owner:
                     slot.owner = slot.name
                     # Slot domains to not appear
                     # self.schema.classes[slot.domain].slots.append(slot.name)
@@ -459,9 +447,7 @@ class SchemaLoader:
                 )
 
         # Evaluate any slot inverses
-        def domain_range_alignment(
-            fwd_slot: SlotDefinition, inverse_slot: SlotDefinition
-        ) -> bool:
+        def domain_range_alignment(fwd_slot: SlotDefinition, inverse_slot: SlotDefinition) -> bool:
             """Determine whether the range of fwd_slot is compatible with the domain of inverse_slot"""
             # TODO: Determine what to do about class and slot hierarchy
             if fwd_slot.range and fwd_slot.range not in self.schema.classes:
@@ -507,9 +493,7 @@ class SchemaLoader:
                     )
 
         # Check for duplicate class and type names
-        def check_dups(
-            s1: Set[ElementName], s2: Set[ElementName]
-        ) -> Tuple[List[ElementName], str]:
+        def check_dups(s1: Set[ElementName], s2: Set[ElementName]) -> Tuple[List[ElementName], str]:
             if s1.isdisjoint(s2):
                 return [], ""
 
@@ -536,8 +520,7 @@ class SchemaLoader:
 
         # Check that the default range is valid
         default_range_needed = any(
-            slot.range == self.schema.default_range
-            for slot in self.schema.slots.values()
+            slot.range == self.schema.default_range for slot in self.schema.slots.values()
         )
         if (
             default_range_needed
@@ -648,9 +631,7 @@ class SchemaLoader:
         for cls in self.schema.classes.values():
             if cls.tree_root:
                 if tree_root is not None:
-                    self.logger.warning(
-                        f"Duplicate tree_root: {cls.name} with {tree_root}"
-                    )
+                    self.logger.warning(f"Duplicate tree_root: {cls.name} with {tree_root}")
                 else:
                     tree_root = cls.name
 
@@ -674,9 +655,7 @@ class SchemaLoader:
                     f'{typ}: "{name}" - ":" not allowed in identifier', name
                 )
 
-    def merge_enum(
-        self, enum: EnumDefinition, merged_enums: List[EnumDefinitionName]
-    ) -> None:
+    def merge_enum(self, enum: EnumDefinition, merged_enums: List[EnumDefinitionName]) -> None:
         """
         Merge parent enumeration information into target enum
 
@@ -695,9 +674,7 @@ class SchemaLoader:
                         enum.is_a,
                     )
 
-    def merge_slot(
-        self, slot: SlotDefinition, merged_slots: List[SlotDefinitionName]
-    ) -> None:
+    def merge_slot(self, slot: SlotDefinition, merged_slots: List[SlotDefinitionName]) -> None:
         """
         Merge parent slot information into target slot
 
@@ -731,9 +708,7 @@ class SchemaLoader:
                     )
             merged_slots.append(slot.name)
 
-    def merge_class(
-        self, cls: ClassDefinition, merged_classes: List[ClassDefinitionName]
-    ) -> None:
+    def merge_class(self, cls: ClassDefinition, merged_classes: List[ClassDefinitionName]) -> None:
         """
         Merge parent class information into target class
 
@@ -745,9 +720,7 @@ class SchemaLoader:
             if cls.is_a:
                 if cls.is_a in self.schema.classes:
                     self.merge_class(self.schema.classes[cls.is_a], merged_classes)
-                    merge_classes(
-                        self.schema, cls, self.schema.classes[cls.is_a], False
-                    )
+                    merge_classes(self.schema, cls, self.schema.classes[cls.is_a], False)
                 else:
                     self.raise_value_error(
                         f'Class: "{cls.name}" - unknown is_a reference: {cls.is_a}',
@@ -769,9 +742,7 @@ class SchemaLoader:
         definitions that are introduced strictly as usages and add them to the slots component
         """
         visited: Set[ClassDefinitionName] = set()
-        visited_usages: Set[
-            SlotDefinitionName
-        ] = set()  # Slots that are or will be mangled
+        visited_usages: Set[SlotDefinitionName] = set()  # Slots that are or will be mangled
 
         def located_aliased_parent_slot(
             owning_class: ClassDefinition, usage_slot: SlotDefinition
@@ -779,26 +750,16 @@ class SchemaLoader:
             """Determine whether we are overriding an attributes style slot in the parent class
             Preconditions: usage_slot is NOT in schema.slots
             """
-            usage_attribute_name = mangled_attribute_name(
-                owning_class.name, usage_slot.name
-            )
+            usage_attribute_name = mangled_attribute_name(owning_class.name, usage_slot.name)
             if owning_class.is_a:
-                parent_slot_name = mangled_attribute_name(
-                    owning_class.is_a, usage_slot.name
-                )
-                if (
-                    parent_slot_name in self.schema.slots
-                    or parent_slot_name in visited_usages
-                ):
+                parent_slot_name = mangled_attribute_name(owning_class.is_a, usage_slot.name)
+                if parent_slot_name in self.schema.slots or parent_slot_name in visited_usages:
                     usage_slot.is_a = parent_slot_name
                     visited_usages.add(usage_attribute_name)
                     return True
             for mixin in owning_class.mixins:
                 mixin_slot_name = mangled_attribute_name(mixin, usage_slot.name)
-                if (
-                    mixin_slot_name in self.schema.slots
-                    or mixin_slot_name in visited_usages
-                ):
+                if mixin_slot_name in self.schema.slots or mixin_slot_name in visited_usages:
                     usage_slot.is_a = mixin_slot_name
                     visited_usages.add(usage_attribute_name)
                     return True
@@ -921,9 +882,7 @@ class SchemaLoader:
                         if new_val:
                             setattr(new_slot, metaslot_name, new_val)
 
-    def merge_type(
-        self, typ: TypeDefinition, merged_types: List[TypeDefinitionName]
-    ) -> None:
+    def merge_type(self, typ: TypeDefinition, merged_types: List[TypeDefinitionName]) -> None:
         """
         Merge parent type information into target type
         :param typ: target type
@@ -1031,9 +990,7 @@ class SchemaLoader:
         return underscore(slot.alias if slot.alias else slot.name)
 
     @staticmethod
-    def raise_value_error(
-        error: str, loc_str: Optional[Union[TypedNode, str]] = None
-    ) -> None:
+    def raise_value_error(error: str, loc_str: Optional[Union[TypedNode, str]] = None) -> None:
         SchemaLoader.raise_value_errors(error, loc_str)
 
     @staticmethod
@@ -1055,9 +1012,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

@@ -1,24 +1,35 @@
-import logging
 from dataclasses import dataclass, field
-from typing import Dict, List, Set, Union, cast
-
-from linkml_runtime.linkml_model.meta import (ClassDefinition,
-                                              ClassDefinitionName, Definition,
-                                              DefinitionName, Element,
-                                              ElementName, EnumDefinition,
-                                              EnumDefinitionName,
-                                              SchemaDefinition, SlotDefinition,
-                                              SlotDefinitionName,
-                                              SubsetDefinitionName,
-                                              TypeDefinition,
-                                              TypeDefinitionName)
+from typing import Dict, List, Set, Union
+
+from linkml_runtime.linkml_model.meta import (
+    ClassDefinition,
+    ClassDefinitionName,
+    Definition,
+    DefinitionName,
+    Element,
+    ElementName,
+    EnumDefinition,
+    EnumDefinitionName,
+    SchemaDefinition,
+    SlotDefinition,
+    SlotDefinitionName,
+    SubsetDefinitionName,
+    TypeDefinition,
+    TypeDefinitionName,
+)
 from linkml_runtime.utils.metamodelcore import empty_dict
 from linkml_runtime.utils.yamlutils import TypedNode
 from rdflib import URIRef
 
-from linkml.utils.typereferences import (ClassType, EnumType, References,
-                                         RefType, SlotType, SubsetType,
-                                         TypeType)
+from linkml.utils.typereferences import (
+    ClassType,
+    EnumType,
+    References,
+    RefType,
+    SlotType,
+    SubsetType,
+    TypeType,
+)
 
 
 def empty_references() -> field:
@@ -33,29 +44,17 @@ class SchemaSynopsis:
     schema: SchemaDefinition = field(repr=False, compare=False)
 
     # References by type -- set by add_ref
-    typerefs: Dict[
-        TypeDefinitionName, References
-    ] = empty_dict()  # Type name to all references
-    slotrefs: Dict[
-        SlotDefinitionName, References
-    ] = empty_dict()  # Slot name to all references
-    classrefs: Dict[
-        ClassDefinitionName, References
-    ] = empty_dict()  # Class name to all references
-    subsetrefs: Dict[
-        SubsetDefinitionName, References
-    ] = empty_dict()  # Subset name to references
-    enumrefs: Dict[
-        EnumDefinitionName, References
-    ] = empty_dict()  # Enum name to references
+    typerefs: Dict[TypeDefinitionName, References] = empty_dict()  # Type name to all references
+    slotrefs: Dict[SlotDefinitionName, References] = empty_dict()  # Slot name to all references
+    classrefs: Dict[ClassDefinitionName, References] = empty_dict()  # Class name to all references
+    subsetrefs: Dict[SubsetDefinitionName, References] = empty_dict()  # Subset name to references
+    enumrefs: Dict[EnumDefinitionName, References] = empty_dict()  # Enum name to references
 
     # Type specific
     typebases: Dict[
         str, Set[TypeDefinitionName]
     ] = empty_dict()  # Base referencing types (direct and indirect)
-    typeofs: Dict[
-        TypeDefinitionName, TypeDefinitionName
-    ] = empty_dict()  # Type to specializations
+    typeofs: Dict[TypeDefinitionName, TypeDefinitionName] = empty_dict()  # Type to specializations
 
     # Slot specific
     slotclasses: Dict[
@@ -70,9 +69,7 @@ class SchemaSynopsis:
     owners: Dict[
         SlotDefinitionName, Set[ClassDefinitionName]
     ] = empty_dict()  # Slot to owning classes (sb. 1)
-    inverses: Dict[
-        str, Set[str]
-    ] = empty_dict()  # Slots declared as inverses of other slots
+    inverses: Dict[str, Set[str]] = empty_dict()  # Slots declared as inverses of other slots
 
     # Class specific
     ownslots: Dict[
@@ -88,18 +85,14 @@ class SchemaSynopsis:
 
     # Slot or Class (Definition) specific
     roots: References = empty_references()  # Definitions with no parents
-    isarefs: Dict[
-        DefinitionName, References
-    ] = empty_dict()  # Definition to isa references
+    isarefs: Dict[DefinitionName, References] = empty_dict()  # Definition to isa references
     mixinrefs: Dict[
         DefinitionName, References
     ] = empty_dict()  # Mixin to referencing classes or slots
     mixins: References = empty_references()  # Definitions declared as mixin
     abstracts: References = empty_references()  # Definitions declared as abstract
     applytos: References = empty_references()  # Definitions that include applytos
-    applytorefs: Dict[
-        DefinitionName, References
-    ] = empty_dict()  # Definition to applyier
+    applytorefs: Dict[DefinitionName, References] = empty_dict()  # Definition to applyier
 
     # Slot or Type specific
     rangerefs: Dict[
@@ -131,9 +124,7 @@ class SchemaSynopsis:
             for slotname in owned_slots:
                 self.owners.setdefault(slotname, set()).add(cls.name)
 
-    def summarize_slot_definition(
-        self, k: SlotDefinitionName, v: SlotDefinition
-    ) -> None:
+    def summarize_slot_definition(self, k: SlotDefinitionName, v: SlotDefinition) -> None:
         """
         Summarize a slot definition
         :param k: slot name
@@ -172,9 +163,7 @@ class SchemaSynopsis:
         if v.base:
             self.typebases.setdefault(v.base, set()).add(k)
 
-    def summarize_class_definition(
-        self, k: ClassDefinitionName, v: ClassDefinition
-    ) -> None:
+    def summarize_class_definition(self, k: ClassDefinitionName, v: ClassDefinition) -> None:
         """
         Summarize class definition element
 
@@ -203,9 +192,7 @@ class SchemaSynopsis:
         """
         self.summarize_element(EnumType, k, v)
 
-    def summarize_definition(
-        self, typ: RefType, k: DefinitionName, v: Definition
-    ) -> None:
+    def summarize_definition(self, typ: RefType, k: DefinitionName, v: Definition) -> None:
         """
         Summarize slot and class definitions
 
@@ -239,13 +226,11 @@ class SchemaSynopsis:
 
         :param typ: element type
         :param k: element name
-        :param v: element deffinition
+        :param v: element definition
         :return:
         """
         if k != v.name:
-            raise ValueError(
-                "{typ} name mismatch: {k} != {v.name}"
-            )  # should never happen
+            raise ValueError("{typ} name mismatch: {k} != {v.name}")  # should never happen
         for subset in v.in_subset:
             self.add_ref(typ, k, SubsetType, subset)
 
@@ -277,9 +262,9 @@ class SchemaSynopsis:
                 fromtype, fromname
             )
         elif totype is SubsetType:
-            self.subsetrefs.setdefault(
-                SubsetDefinitionName(toname), References()
-            ).addref(fromtype, fromname)
+            self.subsetrefs.setdefault(SubsetDefinitionName(toname), References()).addref(
+                fromtype, fromname
+            )
         elif totype is EnumType:
             self.enumrefs.setdefault(SlotDefinitionName(toname), References()).addref(
                 fromtype, fromname
@@ -289,8 +274,7 @@ class SchemaSynopsis:
 
     def _ancestor_is_owned(self, slot: SlotDefinition) -> bool:
         return bool(slot.is_a) and (
-            slot.is_a in self.owners
-            or self._ancestor_is_owned(self.schema.slots[slot.is_a])
+            slot.is_a in self.owners or self._ancestor_is_owned(self.schema.slots[slot.is_a])
         )
 
     def errors(self) -> List[str]:
@@ -307,18 +291,14 @@ class SchemaSynopsis:
         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))}"
+                f"\tUndefined slot references: " f"{', '.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))}"
+                f"\tUndefined type references: " f"{', '.join(format_undefineds(undefined_types))}"
             ]
-        undefined_subsets = set(self.subsetrefs.keys()) - set(
-            self.schema.subsets.keys()
-        )
+        undefined_subsets = set(self.subsetrefs.keys()) - set(self.schema.subsets.keys())
         if undefined_subsets:
             rval += [
                 f"\tUndefined subset references: "
@@ -327,8 +307,7 @@ class SchemaSynopsis:
         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))}"
+                f"\tUndefined enun references: " f"{', '.join(format_undefineds(undefined_enums))}"
             ]
 
         # Inlined slots must be multivalued (not a inviolable rule, but we make assumptions about this elsewhere in
@@ -416,9 +395,7 @@ class SchemaSynopsis:
                     else:
                         unowned_slots.add(slotname)
         if n_unreferenced_descendants:
-            rval += [
-                f"\tUnreferenced descendants of owned slots: {n_unreferenced_descendants}"
-            ]
+            rval += [f"\tUnreferenced descendants of owned slots: {n_unreferenced_descendants}"]
         if unowned_slots:
             rval += [f"\t* Unowned slots: {', '.join(sorted(unowned_slots))}"]