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

linkml/linter/rules.py

@@ -3,17 +3,24 @@ from abc import ABC, abstractmethod
 from functools import lru_cache
 from typing import Callable, Iterable, List
 
-from linkml_runtime.linkml_model import (ClassDefinition, ClassDefinitionName,
-                                         Element, SlotDefinition)
+from linkml_runtime.linkml_model import (
+    ClassDefinition,
+    ClassDefinitionName,
+    Element,
+    SlotDefinition,
+)
 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 (CanonicalPrefixesConfig,
-                                      RecommendedRuleConfig, RuleConfig,
-                                      StandardNamingConfig,
-                                      TreeRootClassRuleConfig)
+from .config.datamodel.config import (
+    CanonicalPrefixesConfig,
+    RecommendedRuleConfig,
+    RuleConfig,
+    StandardNamingConfig,
+    TreeRootClassRuleConfig,
+)
 from .linter import LinterProblem
 
 
@@ -53,18 +60,14 @@ class LinterRule(ABC):
 class NoEmptyTitleRule(LinterRule):
     id = "no_empty_title"
 
-    def check(
-        self, schema_view: SchemaView, fix: bool = False
-    ) -> Iterable[LinterProblem]:
+    def check(self, schema_view: SchemaView, fix: bool = False) -> Iterable[LinterProblem]:
         for e in schema_view.all_elements(imports=False).values():
             if fix and e.title is None:
                 title = e.name.replace("_", " ")
                 title = self.uncamel(title).lower()
                 e.title = title
             if e.title is None:
-                problem = LinterProblem(
-                    message=f"{self.format_element(e)} has no title"
-                )
+                problem = LinterProblem(message=f"{self.format_element(e)} has no title")
                 yield problem
 
 
@@ -77,17 +80,13 @@ class NoXsdIntTypeRule(LinterRule):
                 if fix:
                     type_definition.uri = "xsd:integer"
                 else:
-                    yield LinterProblem(
-                        f"{self.format_element(type_definition)} has uri xsd:int"
-                    )
+                    yield LinterProblem(f"{self.format_element(type_definition)} has uri xsd:int")
 
 
 class PermissibleValuesFormatRule(LinterRule):
     id = "permissible_values_format"
 
-    def check(
-        self, schema_view: SchemaView, fix: bool = False
-    ) -> Iterable[LinterProblem]:
+    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():
@@ -117,9 +116,7 @@ class RecommendedRule(LinterRule):
 
     def check(self, schema_view: SchemaView, fix: bool = False):
         recommended_meta_slots = _get_recommended_metamodel_slots()
-        for element_name, element_definition in schema_view.all_elements(
-            imports=False
-        ).items():
+        for element_name, element_definition in schema_view.all_elements(imports=False).items():
             if self.config.include and element_name not in self.config.include:
                 continue
             if element_name in self.config.exclude:
@@ -138,19 +135,13 @@ class TreeRootClassRule(LinterRule):
     def __init__(self, config: TreeRootClassRuleConfig) -> None:
         super().__init__(config)
 
-    def check(
-        self, schema_view: SchemaView, fix: bool = False
-    ) -> Iterable[LinterProblem]:
-        tree_roots = [
-            c for c in schema_view.all_classes(imports=False).values() if c.tree_root
-        ]
+    def check(self, schema_view: SchemaView, fix: bool = False) -> Iterable[LinterProblem]:
+        tree_roots = [c for c in schema_view.all_classes(imports=False).values() if c.tree_root]
         if len(tree_roots) > 0:
             if self.config.validate_existing_class_name:
                 for tree_root in tree_roots:
                     if str(tree_root.name) != self.config.root_class_name:
-                        yield LinterProblem(
-                            message=f"Tree root class has name '{tree_root.name}'"
-                        )
+                        yield LinterProblem(message=f"Tree root class has name '{tree_root.name}'")
         else:
             if fix:
                 container = ClassDefinition(self.config.root_class_name, tree_root=True)
@@ -190,9 +181,7 @@ class TreeRootClassRule(LinterRule):
         ]
         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
+                c for c in top_level_classes if schema_view.get_identifier_slot(c.name) is not None
             ]
         index_slots = []
         for c in top_level_classes:
@@ -220,12 +209,8 @@ class TreeRootClassRule(LinterRule):
 class NoInvalidSlotUsageRule(LinterRule):
     id = "no_invalid_slot_usage"
 
-    def check(
-        self, schema_view: SchemaView, fix: bool = False
-    ) -> Iterable[LinterProblem]:
-        for class_name, class_definition in schema_view.all_classes(
-            imports=False
-        ).items():
+    def check(self, schema_view: SchemaView, fix: bool = False) -> Iterable[LinterProblem]:
+        for class_name, class_definition in schema_view.all_classes(imports=False).items():
             slot_usage = class_definition.slot_usage
             if not slot_usage:
                 continue
@@ -243,9 +228,7 @@ class StandardNamingRule(LinterRule):
     def __init__(self, config: StandardNamingConfig) -> None:
         self.config = config
 
-    def check(
-        self, schema_view: SchemaView, fix: bool = False
-    ) -> Iterable[LinterProblem]:
+    def check(self, schema_view: SchemaView, fix: bool = False) -> Iterable[LinterProblem]:
         class_pattern = self.PATTERNS["uppercamel"]
         slot_pattern = self.PATTERNS["snake"]
         enum_pattern = self.PATTERNS["uppercamel"]
@@ -270,7 +253,8 @@ class StandardNamingRule(LinterRule):
             for permissible_value_name in enum_definition.permissible_values.keys():
                 if permissible_value_pattern.fullmatch(permissible_value_name) is None:
                     yield LinterProblem(
-                        f"Permissible value of {self.format_element(enum_definition)} has name '{permissible_value_name}'"
+                        f"Permissible value of {self.format_element(enum_definition)} "
+                        f"has name '{permissible_value_name}'"
                     )
 
 
@@ -280,9 +264,7 @@ class CanonicalPrefixesRule(LinterRule):
     def __init__(self, config: CanonicalPrefixesConfig) -> None:
         self.config = config
 
-    def check(
-        self, schema_view: SchemaView, fix: bool = False
-    ) -> Iterable[LinterProblem]:
+    def check(self, schema_view: SchemaView, fix: bool = False) -> Iterable[LinterProblem]:
         context = load_multi_context(self.config.prefixmaps_contexts)
         prefix_to_namespace = context.as_dict()
         namespace_to_prefix = context.as_inverted_dict()
@@ -290,10 +272,14 @@ class CanonicalPrefixesRule(LinterRule):
             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 '{prefix.prefix_reference}' instead of namespace '{prefix_to_namespace[prefix.prefix_prefix]}'"
+                        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 '{prefix.prefix_reference}' instead of using prefix '{namespace_to_prefix[prefix.prefix_reference]}'"
+                        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/reporting/__init__.py

@@ -1 +1,3 @@
 from linkml.reporting.model import CheckResult, Report
+
+__all__ = ["CheckResult", "Report"]

linkml/reporting/model.py

@@ -7,27 +7,18 @@
 # license: https://creativecommons.org/publicdomain/zero/1.0/
 
 import dataclasses
-import re
-import sys
 from dataclasses import dataclass
 from typing import Any, ClassVar, Dict, List, Optional, Union
 
-from jsonasobj2 import JsonObj, as_dict
-from linkml_runtime.linkml_model.meta import (EnumDefinition, PermissibleValue,
-                                              PvFormulaOptions)
-from linkml_runtime.linkml_model.types import (Nodeidentifier, String,
-                                               Uriorcurie)
+from jsonasobj2 import as_dict
+from linkml_runtime.linkml_model.meta import EnumDefinition, PermissibleValue
 from linkml_runtime.utils.curienamespace import CurieNamespace
-from linkml_runtime.utils.dataclass_extensions_376 import \
-    dataclasses_init_fn_with_kwargs
+from linkml_runtime.utils.dataclass_extensions_376 import dataclasses_init_fn_with_kwargs
 from linkml_runtime.utils.enumerations import EnumDefinitionImpl
-from linkml_runtime.utils.formatutils import camelcase, sfx, underscore
-from linkml_runtime.utils.metamodelcore import (NodeIdentifier, URIorCURIE,
-                                                bnode, empty_dict, empty_list)
+from linkml_runtime.utils.metamodelcore import NodeIdentifier, URIorCURIE, empty_list
 from linkml_runtime.utils.slot import Slot
-from linkml_runtime.utils.yamlutils import (YAMLRoot, extended_float,
-                                            extended_int, extended_str)
-from rdflib import Namespace, URIRef
+from linkml_runtime.utils.yamlutils import YAMLRoot
+from rdflib import URIRef
 
 metamodel_version = "1.7.0"
 
@@ -73,8 +64,7 @@ class Report(YAMLRoot):
         if not isinstance(self.results, list):
             self.results = [self.results] if self.results is not None else []
         self.results = [
-            v if isinstance(v, CheckResult) else CheckResult(**as_dict(v))
-            for v in self.results
+            v if isinstance(v, CheckResult) else CheckResult(**as_dict(v)) for v in self.results
         ]
 
         super().__post_init__(**kwargs)
@@ -109,14 +99,10 @@ class CheckResult(YAMLRoot):
         if self.subject is not None and not isinstance(self.subject, NodeIdentifier):
             self.subject = NodeIdentifier(self.subject)
 
-        if self.instantiates is not None and not isinstance(
-            self.instantiates, NodeIdentifier
-        ):
+        if self.instantiates is not None and not isinstance(self.instantiates, NodeIdentifier):
             self.instantiates = NodeIdentifier(self.instantiates)
 
-        if self.predicate is not None and not isinstance(
-            self.predicate, NodeIdentifier
-        ):
+        if self.predicate is not None and not isinstance(self.predicate, NodeIdentifier):
             self.predicate = NodeIdentifier(self.predicate)
 
         if self.object is not None and not isinstance(self.object, NodeIdentifier):
@@ -184,7 +170,6 @@ class ProblemSlotMissing(Problem):
 
 # Enumerations
 class SeverityOptions(EnumDefinitionImpl):
-
     FATAL = PermissibleValue(text="FATAL")
     ERROR = PermissibleValue(text="ERROR")
     WARNING = PermissibleValue(text="WARNING")

linkml/transformers/relmodel_transformer.py

@@ -1,16 +1,19 @@
 import logging
 from copy import copy
 from dataclasses import dataclass, field
-from enum import unique
 from typing import Dict, List, Optional
 
-from linkml_runtime.linkml_model import (Annotation, ClassDefinition,
-                                         ClassDefinitionName, Definition,
-                                         Prefix, SchemaDefinition,
-                                         SlotDefinition)
-from linkml_runtime.utils.formatutils import camelcase, underscore
+from linkml_runtime.linkml_model import (
+    Annotation,
+    ClassDefinition,
+    ClassDefinitionName,
+    Definition,
+    Prefix,
+    SchemaDefinition,
+    SlotDefinition,
+)
 from linkml_runtime.utils.schemaview import SchemaView, SlotDefinitionName
-from sqlalchemy import *
+from sqlalchemy import Enum
 
 
 class RelationalAnnotations(Enum):
@@ -99,9 +102,7 @@ class MultivaluedScalar(RelationalMapping):
     mapping_type: str = "MultivaluedScalar"
 
 
-def add_attribute(
-    attributes: Dict[str, SlotDefinition], tgt_slot: SlotDefinition
-) -> None:
+def add_attribute(attributes: Dict[str, SlotDefinition], tgt_slot: SlotDefinition) -> None:
     attributes[tgt_slot.name] = tgt_slot
 
 
@@ -199,6 +200,7 @@ class RelationalModelTransformer:
                 tree_root=c.tree_root,
                 abstract=c.abstract,
                 description=c.description,
+                unique_keys=c.unique_keys,
             )
             for slot in source_sv.class_induced_slots(cn):
                 tgt_slot = copy(slot)
@@ -221,9 +223,7 @@ class RelationalModelTransformer:
         for cn in target_sv.all_classes():
             pk = self.get_direct_identifier_attribute(target_sv, cn)
             if self.foreign_key_policy == ForeignKeyPolicy.NO_FOREIGN_KEYS:
-                logging.info(
-                    f"Will not inject any PKs, and policy == {self.foreign_key_policy}"
-                )
+                logging.info(f"Will not inject any PKs, and policy == {self.foreign_key_policy}")
             else:
                 if pk is None:
                     pk = self.add_primary_key(cn, target_sv)
@@ -238,7 +238,6 @@ class RelationalModelTransformer:
         for cn, c in target_sv.all_classes().items():
             if self.foreign_key_policy == ForeignKeyPolicy.NO_FOREIGN_KEYS:
                 continue
-            incoming_links = [link for link in links if link.target_class == cn]
             pk_slot = self.get_direct_identifier_attribute(target_sv, cn)
             # if self.is_skip(c) and len(incoming_links) == 0:
             #    logging.info(f'Skipping class: {c.name}')
@@ -248,24 +247,18 @@ class RelationalModelTransformer:
                 slot = copy(src_slot)
                 slot_range = slot.range
                 slot_range_is_class = slot_range in target_sv.all_classes()
-                links_to_range = [
-                    link for link in links if link.target_class == slot_range
-                ]
-                is_only_ref_to_range = len(links_to_range) == 1
                 is_shared = slot_range_is_class and (
                     slot.inlined or slot.inlined_as_list or "shared" in slot.annotations
                 )
                 if slot.multivalued:
                     slot.multivalued = False
                     slot_name = slot.name
-                    sn_singular = (
-                        slot.singular_name if slot.singular_name else slot.name
-                    )
+                    sn_singular = slot.singular_name if slot.singular_name else slot.name
                     if pk_slot is None:
                         pk_slot = self.add_primary_key(c.name, target_sv)
                     backref_slot = SlotDefinition(
                         name=f"{c.name}_{pk_slot.name}",
-                        description=f"Autocreated FK slot",
+                        description="Autocreated FK slot",
                         range=c.name,
                         slot_uri="rdf:subject",
                         # close_mappings=[pk_slot.slot_uri],
@@ -361,13 +354,9 @@ class RelationalModelTransformer:
                 if a.range in target.classes:
                     tc = target.classes[a.range]
                     # tc_pk_slot = target_sv.get_identifier_slot(tc.name)
-                    tc_pk_slot = self.get_direct_identifier_attribute(
-                        target_sv, tc.name
-                    )
+                    tc_pk_slot = self.get_direct_identifier_attribute(target_sv, tc.name)
                     if tc_pk_slot is None:
-                        raise ValueError(
-                            f"No PK for attribute {a.name} range {a.range}"
-                        )
+                        raise ValueError(f"No PK for attribute {a.name} range {a.range}")
                     is_inlined = a.inlined or not source_sv.get_identifier_slot(tc.name)
                     if (
                         fk_policy == ForeignKeyPolicy.INJECT_FK_FOR_NESTED
@@ -449,9 +438,7 @@ class RelationalModelTransformer:
         candidate_names = ["id", "uid", "identifier", "pk"]
         valid_candidate_names = [n for n in candidate_names if n not in c.attributes]
         if not valid_candidate_names:
-            raise ValueError(
-                f"Cannot add primary key to class {cn}: no valid candidate names"
-            )
+            raise ValueError(f"Cannot add primary key to class {cn}: no valid candidate names")
         pk = SlotDefinition(name=valid_candidate_names[0], identifier=True, range="integer")
         add_annotation(pk, "dcterms:conformsTo", "rr:BlankNode")
         add_annotation(pk, "autoincrement", "true")
@@ -461,8 +448,8 @@ class RelationalModelTransformer:
             )
         # add PK to start of attributes
         atts = copy(c.attributes)
-        c.attributes.clear()  ## See https://github.com/linkml/linkml/issues/370
-        add_attribute(c.attributes, pk)  ## add to start
+        c.attributes.clear()  # See https://github.com/linkml/linkml/issues/370
+        add_attribute(c.attributes, pk)  # add to start
         c.attributes.update(atts)
         sv.set_modified()
         return pk

linkml/transformers/schema_renamer.py

@@ -1,4 +1,3 @@
-import inspect
 from copy import deepcopy
 from dataclasses import dataclass, field
 from typing import Any, Callable, Dict, Type
@@ -6,11 +5,18 @@ from typing import Any, Callable, Dict, Type
 import click
 from jsonasobj2 import as_dict
 from linkml_runtime import SchemaView
-from linkml_runtime.linkml_model import (ClassDefinition, ClassDefinitionName,
-                                         Element, ElementName, EnumDefinition,
-                                         EnumDefinitionName, SchemaDefinition,
-                                         SlotDefinition, SlotDefinitionName,
-                                         TypeDefinition, TypeDefinitionName)
+from linkml_runtime.linkml_model import (
+    ClassDefinition,
+    ClassDefinitionName,
+    ElementName,
+    EnumDefinition,
+    EnumDefinitionName,
+    SchemaDefinition,
+    SlotDefinition,
+    SlotDefinitionName,
+    TypeDefinition,
+    TypeDefinitionName,
+)
 from linkml_runtime.utils.formatutils import camelcase, lcamelcase, underscore
 from linkml_runtime.utils.schema_as_dict import schema_as_yaml_dump
 from linkml_runtime.utils.yamlutils import YAMLRoot
@@ -92,9 +98,7 @@ class SchemaRenamer:
             return new_element
         else:
             try:
-                element_vars = {
-                    k: v for k, v in vars(element).items() if not k.startswith("_")
-                }
+                element_vars = {k: v for k, v in vars(element).items() if not k.startswith("_")}
                 if len(element_vars) == 0:
                     return element
                 else:
@@ -134,7 +138,7 @@ def main(schema, output, class_names, slot_names):
     if slot_names:
         rename_map[SlotDefinition] = n2f(slot_names)
     if not rename_map.keys():
-        raise ValueError(f"No transformations specified")
+        raise ValueError("No transformations specified")
     renamer = SchemaRenamer(rename_function_map=rename_map)
     rschema = renamer.rename_elements(sv.schema)
     ystr = schema_as_yaml_dump(rschema)

linkml/utils/converter.py

@@ -1,7 +1,6 @@
 import logging
 import os
 import sys
-from pathlib import Path
 from typing import List
 
 import click
@@ -14,9 +13,16 @@ from linkml_runtime.utils.schemaview import SchemaView
 from linkml._version import __version__
 from linkml.generators.pythongen import PythonGenerator
 from linkml.utils import datautils, validation
-from linkml.utils.datautils import (_get_context, _get_format, _is_xsv,
-                                    dumpers_loaders, get_dumper, get_loader,
-                                    infer_index_slot, infer_root_class)
+from linkml.utils.datautils import (
+    _get_context,
+    _get_format,
+    _is_xsv,
+    dumpers_loaders,
+    get_dumper,
+    get_loader,
+    infer_index_slot,
+    infer_root_class,
+)
 
 
 @click.command()
@@ -45,9 +51,7 @@ from linkml.utils.datautils import (_get_context, _get_format, _is_xsv,
     show_default=True,
     help="Infer the target class from the filename, should be ClassName-<other-chars>.{yaml,json,...}",
 )
-@click.option(
-    "--index-slot", "-S", help="top level slot. Required for CSV dumping/loading"
-)
+@click.option("--index-slot", "-S", help="top level slot. Required for CSV dumping/loading")
 @click.option("--schema", "-s", help="Path to schema specified as LinkML yaml")
 @click.option("--prefix", "-P", multiple=True, help="Prefixmap base=URI pairs")
 @click.option(
@@ -118,7 +122,7 @@ def cli(
     if target_class is None:
         target_class = infer_root_class(sv)
     if target_class is None:
-        raise Exception(f"target class not specified and could not be inferred")
+        raise Exception("target class not specified and could not be inferred")
     py_target_class = python_module.__dict__[target_class]
     input_format = _get_format(input, input_format)
     loader = get_loader(input_format)
@@ -127,7 +131,7 @@ def cli(
     outargs = {}
     if datautils._is_rdf_format(input_format):
         if sv is None:
-            raise Exception(f"Must pass schema arg")
+            raise Exception("Must pass schema arg")
         inargs["schemaview"] = sv
         inargs["fmt"] = input_format
     if _is_xsv(input_format):
@@ -139,9 +143,7 @@ def cli(
         inargs["schema"] = schema
     obj = loader.load(source=input, target_class=py_target_class, **inargs)
     if infer:
-        infer_config = inference_utils.Config(
-            use_expressions=True, use_string_serialization=True
-        )
+        infer_config = inference_utils.Config(use_expressions=True, use_string_serialization=True)
         infer_all_slot_values(obj, schemaview=sv, config=infer_config)
     if validate:
         if schema is None:
@@ -159,11 +161,9 @@ def cli(
             else:
                 raise Exception("Must pass in context OR schema for RDF output")
         outargs["contexts"] = list(context)
-        outargs["fmt"] = "json-ld"
-        outargs["schemaview"] = sv
     if output_format == "rdf" or output_format == "ttl":
         if sv is None:
-            raise Exception(f"Must pass schema arg")
+            raise Exception("Must pass schema arg")
         outargs["schemaview"] = sv
     if _is_xsv(output_format):
         if index_slot is None:

linkml/utils/datautils.py

@@ -1,23 +1,12 @@
 import os
 from collections import defaultdict
-from typing import Optional, Union
-
-from linkml_runtime.dumpers.csv_dumper import CSVDumper
-from linkml_runtime.dumpers.json_dumper import JSONDumper
-from linkml_runtime.dumpers.rdf_dumper import RDFDumper
-from linkml_runtime.dumpers.rdflib_dumper import RDFLibDumper
-from linkml_runtime.dumpers.yaml_dumper import YAMLDumper
-from linkml_runtime.linkml_model.meta import (ClassDefinitionName,
-                                              SchemaDefinition,
-                                              SlotDefinitionName)
-from linkml_runtime.loaders.csv_loader import CSVLoader
-from linkml_runtime.loaders.json_loader import JSONLoader
+from typing import Optional
+
+from linkml_runtime.dumpers import CSVDumper, JSONDumper, RDFLibDumper, TSVDumper, YAMLDumper
+from linkml_runtime.linkml_model.meta import ClassDefinitionName, SlotDefinitionName
+from linkml_runtime.loaders import CSVLoader, JSONLoader, RDFLibLoader, TSVLoader, YAMLLoader
 from linkml_runtime.loaders.loader_root import Loader
-from linkml_runtime.loaders.rdf_loader import RDFLoader
-from linkml_runtime.loaders.rdflib_loader import RDFLibLoader
-from linkml_runtime.loaders.yaml_loader import YAMLLoader
 from linkml_runtime.utils.schemaview import SchemaView
-from linkml_runtime.utils.yamlutils import YAMLRoot
 
 from linkml.generators.jsonldcontextgen import ContextGenerator
 
@@ -27,9 +16,9 @@ dumpers_loaders = {
     "json": (JSONDumper, JSONLoader),
     "rdf": (RDFLibDumper, RDFLibLoader),
     "ttl": (RDFLibDumper, RDFLibLoader),
-    "json-ld": (RDFLibDumper, RDFLibLoader),
+    "json-ld": (JSONDumper, JSONLoader),
     "csv": (CSVDumper, CSVLoader),
-    "tsv": (CSVDumper, CSVLoader),
+    "tsv": (TSVDumper, TSVLoader),
 }
 
 aliases = {
@@ -42,9 +31,7 @@ def _get_format(path: str, specified_format: str = None, default=None):
     if specified_format is None:
         if path is None:
             if default is None:
-                raise Exception(
-                    f"Must pass format option OR pass a filename with known file suffix"
-                )
+                raise Exception("Must pass format option OR pass a filename with known file suffix")
             else:
                 specified_format = default
         else:
@@ -52,9 +39,7 @@ def _get_format(path: str, specified_format: str = None, default=None):
             if ext is not None:
                 specified_format = ext.replace(".", "")
             else:
-                raise Exception(
-                    f"Must pass format option OR use known file suffix: {path}"
-                )
+                raise Exception(f"Must pass format option OR use known file suffix: {path}")
     specified_format = specified_format.lower()
     if specified_format in aliases:
         specified_format = aliases[specified_format]

linkml/utils/datavalidator.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 from typing import Union
 
-from linkml_runtime.linkml_model import SchemaDefinition, ClassDefinitionName
+from linkml_runtime.linkml_model import ClassDefinitionName, SchemaDefinition
 
 
 @dataclass
@@ -16,6 +16,6 @@ class DataValidator:
     """
 
     def validate_dict(
-            self, data: dict, target_class: ClassDefinitionName = None, closed: bool = True
+        self, data: dict, target_class: ClassDefinitionName = None, closed: bool = True
     ) -> None:
         raise NotImplementedError

linkml/utils/execute_tutorial.py

@@ -10,15 +10,15 @@ import click
 
 from linkml._version import __version__
 
-re_decl = re.compile("^(\\S+):$")
-re_start_yaml = re.compile("^```(\w+)$")
-re_end_yaml = re.compile("^```$")
-re_html_comment = re.compile("^<!-- (.+) -->")
+re_decl = re.compile(r"^(\S+):$")
+re_start_yaml = re.compile(r"^```(\w+)$")
+re_end_yaml = re.compile(r"^```$")
+re_html_comment = re.compile(r"^<!-- (.+) -->")
 
 
 @dataclass
 class Block:
-    category: str = None  ## yaml, bash, python, ...
+    category: str = None  # yaml, bash, python, ...
     title: str = None
     content: str = None
     output: str = None
@@ -71,9 +71,7 @@ def execute_blocks(directory: str, blocks: List[Block]) -> List[str]:
                 outpath = cmd[pos + 1 :]
                 cmd = cmd[0:pos]
                 if len(outpath) > 1:
-                    raise Exception(
-                        f"Maximim 1 token after > in {block.content}. Got: {outpath}"
-                    )
+                    raise Exception(f"Maximum 1 token after > in {block.content}. Got: {outpath}")
                 outpath = str(Path(directory, *outpath))
                 logging.info(f"OUTPATH = {outpath}")
             else:
@@ -91,7 +89,7 @@ def execute_blocks(directory: str, blocks: List[Block]) -> List[str]:
                 if r.returncode == 0:
                     err(f"Command unexpectedly succeeded: {cmd}")
                 else:
-                    logging.info(f"Failed as expected")
+                    logging.info("Failed as expected")
                 if block.error:
                     logging.info(f"ERR [sample] = ...{block.error[-200:]}")
             else:
@@ -100,7 +98,7 @@ def execute_blocks(directory: str, blocks: List[Block]) -> List[str]:
                 if r.returncode != 0:
                     err(f"Command failed: {cmd}")
                 else:
-                    logging.info(f"Success!")
+                    logging.info("Success!")
         elif block.is_stdout():
             if "compare_rdf" in block.annotations:
                 logging.warning(
@@ -110,7 +108,7 @@ def execute_blocks(directory: str, blocks: List[Block]) -> List[str]:
                 if last_block.output.strip() != block.content.strip():
                     err(f"Mismatch: {str(last_block.output)} != {block.content}")
                 else:
-                    logging.info(f"Hurray! Contents match!")
+                    logging.info("Hurray! Contents match!")
             else:
                 logging.info("No comparison performed")
         else:
@@ -197,7 +195,7 @@ def cli(inputs, directory):
     Example:
 
         export PYTHONPATH=`pwd`
-        python -m linkml.utils.execute_tutorial -d /tmp/tutorial/ sphinx/intro/tutorial01.md
+        python -m linkml.utils.execute_tutorial -d /tmp/tutorial/ docs/intro/tutorial01.md
 
     """
     logging.basicConfig(level=logging.INFO)