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

linkml/utils/sqlutils.py

@@ -11,14 +11,14 @@ import click
 import linkml_runtime.linkml_model.meta as metamodel
 from linkml_runtime import SchemaView
 from linkml_runtime.dumpers import yaml_dumper
-from linkml_runtime.linkml_model import PermissibleValue, SchemaDefinition
+from linkml_runtime.linkml_model import SchemaDefinition
 from linkml_runtime.utils.compile_python import compile_python
 from linkml_runtime.utils.enumerations import EnumDefinitionImpl
 from linkml_runtime.utils.formatutils import underscore
 from linkml_runtime.utils.introspection import package_schemaview
 from linkml_runtime.utils.yamlutils import YAMLRoot
 from pydantic import BaseModel
-from sqlalchemy import create_engine
+from sqlalchemy import StaticPool, create_engine
 from sqlalchemy.engine import Engine
 from sqlalchemy.ext.associationproxy import _AssociationCollection
 from sqlalchemy.orm import sessionmaker
@@ -28,8 +28,16 @@ from linkml.generators.pythongen import PythonGenerator
 from linkml.generators.sqlalchemygen import SQLAlchemyGenerator, TemplateEnum
 from linkml.generators.sqltablegen import SQLTableGenerator
 from linkml.utils import datautils, validation
-from linkml.utils.datautils import (_get_context, _get_format, _is_xsv, dumpers_loaders,
-                                    get_dumper, get_loader, infer_root_class, infer_index_slot)
+from linkml.utils.datautils import (
+    _get_context,
+    _get_format,
+    _is_xsv,
+    dumpers_loaders,
+    get_dumper,
+    get_loader,
+    infer_index_slot,
+    infer_root_class,
+)
 
 
 @dataclass
@@ -53,11 +61,14 @@ class SQLStore:
     schemaview: SchemaView = None
     engine: Engine = None
     database_path: str = None
+    use_memory: bool = False
+    """https://docs.sqlalchemy.org/en/20/dialects/sqlite.html#using-a-memory-database-in-multiple-threads"""
+
     module: ModuleType = None
     native_module: ModuleType = None
     include_schema_in_database: bool = None
 
-    def db_exists(self, create=True, force=False) -> str:
+    def db_exists(self, create=True, force=False) -> Optional[str]:
         """
         check if database exists, optionally create if not present
 
@@ -65,13 +76,21 @@ class SQLStore:
         :param force: recreate database, destroying any content if previously present
         :return: path
         """
-        if not self.database_path:
-            raise ValueError("database_path not set")
-        db_exists = os.path.exists(self.database_path)
+        if self.use_memory:
+            db_exists = False
+        else:
+            if not self.database_path:
+                raise ValueError("database_path not set")
+            db_exists = os.path.exists(self.database_path)
         if force or (create and not db_exists):
-            if force:
-                Path(self.database_path).unlink(missing_ok=True)
-            self.engine = create_engine(f"sqlite:///{self.database_path}")
+            if self.use_memory:
+                self.engine = create_engine(
+                    "sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool
+                )
+            else:
+                if force:
+                    Path(self.database_path).unlink(missing_ok=True)
+                self.engine = create_engine(f"sqlite:///{self.database_path}")
             with self.engine.connect() as con:
                 ddl = SQLTableGenerator(self.schema).generate_ddl()
                 con.connection.executescript(ddl)
@@ -79,6 +98,8 @@ class SQLStore:
                     metamodel_sv = package_schemaview(metamodel.__name__)
                     meta_ddl = SQLTableGenerator(metamodel_sv.schema).generate_ddl()
                     con.connection.executescript(meta_ddl)
+        if self.use_memory:
+            return None
         if not os.path.exists(self.database_path):
             raise ValueError(f"No database: {self.database_path}")
         return self.database_path
@@ -118,9 +139,7 @@ class SQLStore:
         """
         return self.load_all(target_class=target_class)[0]
 
-    def load_all(
-        self, target_class: Union[str, Type[YAMLRoot]] = None
-    ) -> List[YAMLRoot]:
+    def load_all(self, target_class: Union[str, Type[YAMLRoot]] = None) -> List[YAMLRoot]:
         if target_class is None:
             target_class_name = infer_root_class(self.schemaview)
             target_class = self.native_module.__dict__[target_class_name]
@@ -132,7 +151,7 @@ class SQLStore:
             q = session.query(typ)
             all_objs = q.all()
             tmp = self.from_sqla(all_objs)
-        return tmp  
+        return tmp
 
     def dump(self, element: YAMLRoot, append=True) -> None:
         """
@@ -225,10 +244,6 @@ class SQLStore:
             cls = nm[typ.__name__]
         else:
             cls = None
-        try:
-            kvs = vars(obj).items()
-        except TypeError:
-            kvs = None
         if isinstance(obj, list) or isinstance(obj, _AssociationCollection):
             nu_obj = [self.from_sqla(x) for x in obj]
             if nu_obj:
@@ -236,7 +251,6 @@ class SQLStore:
             else:
                 return None
         elif cls:
-            nu_cls = self.from_sqla_type(typ)
             inst_args = {}
             for sn in self.schemaview.class_slots(cls.name):
                 sn = underscore(sn)
@@ -295,9 +309,7 @@ def main(verbose: int, quiet: bool, csv_field_size_limit: int):
     "-C",
     help="name of class in datamodel that the root node instantiates",
 )
-@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(
     "--validate/--no-validate",
@@ -341,10 +353,10 @@ def dump(
         sv = SchemaView(schema)
     if target_class is None:
         if sv is None:
-            raise ValueError(f"Must specify schema if not target class is specified")
+            raise ValueError("Must specify schema if not target class is specified")
         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)
@@ -352,7 +364,7 @@ def dump(
     inargs = {}
     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):
@@ -393,9 +405,7 @@ def dump(
     "-C",
     help="name of class in datamodel that the root node instantiates",
 )
-@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(
     "--validate/--no-validate",
@@ -458,7 +468,7 @@ def load(
         outargs["fmt"] = "json-ld"
     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/typereferences.py

@@ -1,11 +1,14 @@
 from dataclasses import dataclass
-from typing import Set, cast
+from typing import Set
 
-from linkml_runtime.linkml_model.meta import (ClassDefinitionName, ElementName,
-                                              EnumDefinitionName,
-                                              SlotDefinitionName,
-                                              SubsetDefinitionName,
-                                              TypeDefinitionName)
+from linkml_runtime.linkml_model.meta import (
+    ClassDefinitionName,
+    ElementName,
+    EnumDefinitionName,
+    SlotDefinitionName,
+    SubsetDefinitionName,
+    TypeDefinitionName,
+)
 from linkml_runtime.utils.metamodelcore import empty_set
 
 

linkml/utils/validation.py

@@ -1,13 +1,10 @@
 import json
-import logging
-import sys
 from typing import TextIO, Type, Union
 
 import jsonschema
 from linkml_runtime.dumpers import json_dumper
 from linkml_runtime.linkml_model import SchemaDefinition
-from linkml_runtime.utils.schemaview import SchemaView
-from linkml_runtime.utils.yamlutils import YAMLRoot, as_dict
+from linkml_runtime.utils.yamlutils import YAMLRoot
 
 from linkml.generators.jsonschemagen import JsonSchemaGenerator
 
@@ -46,4 +43,6 @@ def validate_object(
         not_closed=not_closed,
     ).serialize(not_closed=not_closed)
     jsonschema_obj = json.loads(jsonschemastr)
-    return jsonschema.validate(inst_dict, schema=jsonschema_obj, format_checker=jsonschema.Draft7Validator.FORMAT_CHECKER)
+    return jsonschema.validate(
+        inst_dict, schema=jsonschema_obj, format_checker=jsonschema.Draft7Validator.FORMAT_CHECKER
+    )

linkml/validators/__init__.py

@@ -1,2 +1,4 @@
 from linkml.validators.jsonschemavalidator import JsonSchemaDataValidator
 from linkml.validators.sparqlvalidator import SparqlDataValidator
+
+__all__ = ["JsonSchemaDataValidator", "SparqlDataValidator"]

linkml/validators/jsonschemavalidator.py

@@ -1,13 +1,13 @@
-import json
 import logging
 import sys
-from dataclasses import dataclass
-from typing import TextIO, Type, Union, Dict, Optional
+from dataclasses import asdict, dataclass, field
+from functools import lru_cache
+from typing import Any, Iterable, List, Type, Union
 
 import click
 import jsonschema
-from linkml_runtime.dumpers import json_dumper
-from linkml_runtime.linkml_model import SchemaDefinition, ClassDefinitionName
+from jsonschema.exceptions import best_match
+from linkml_runtime.linkml_model import ClassDefinitionName, SchemaDefinition
 from linkml_runtime.utils.compile_python import compile_python
 from linkml_runtime.utils.dictutils import as_simple_dict
 from linkml_runtime.utils.schemaview import SchemaView
@@ -20,17 +20,50 @@ from linkml.utils import datautils
 from linkml.utils.datavalidator import DataValidator
 
 
+class HashableSchemaDefinition(SchemaDefinition):
+    def __hash__(self) -> int:
+        return hash(self.id)
+
+
+@lru_cache(maxsize=None)
+def _generate_jsonschema(schema, top_class, closed, include_range_class_descendants):
+    logging.debug("Generating JSON Schema")
+    not_closed = not closed
+    return JsonSchemaGenerator(
+        schema=schema,
+        mergeimports=True,
+        top_class=top_class,
+        not_closed=not_closed,
+        include_range_class_descendants=include_range_class_descendants,
+    ).generate()
+
+
+class JsonSchemaDataValidatorError(Exception):
+    def __init__(self, validation_messages: List[str]) -> None:
+        super().__init__("\n".join(validation_messages))
+        self.validation_messages = validation_messages
+
+
 @dataclass
 class JsonSchemaDataValidator(DataValidator):
     """
     Implementation of DataValidator that wraps jsonschema validation
     """
 
-    jsonschema_objs: Optional[Dict[str, Dict]] = None
-    """Cached outputs of jsonschema generation"""
+    include_range_class_descendants: bool = False
+    _hashable_schema: Union[str, HashableSchemaDefinition] = field(init=False, repr=False)
+
+    def __setattr__(self, __name: str, __value: Any) -> None:
+        if __name == "schema":
+            if isinstance(__value, SchemaDefinition):
+                self._hashable_schema = HashableSchemaDefinition(**asdict(__value))
+            else:
+                self._hashable_schema = __value
+        return super().__setattr__(__name, __value)
 
     def validate_file(self, input: str, format: str = "json", **kwargs):
-        return self.validate_object(obj)
+        # return self.validate_object(obj)
+        pass
 
     def validate_object(
         self, data: YAMLRoot, target_class: Type[YAMLRoot] = None, closed: bool = True
@@ -46,26 +79,7 @@ class JsonSchemaDataValidator(DataValidator):
         if target_class is None:
             target_class = type(data)
         inst_dict = as_simple_dict(data)
-        not_closed = not closed
-        if self.schema is None:
-            raise ValueError(f"schema object must be set")
-        if self.jsonschema_objs is None:
-            self.jsonschema_objs = {}
-        schema_id = self.schema.id if isinstance(self.schema, SchemaDefinition) else self.schema
-        cache_params = frozenset([schema_id, target_class.class_name])
-        if cache_params not in self.jsonschema_objs:
-            jsonschemastr = JsonSchemaGenerator(
-                self.schema,
-                mergeimports=True,
-                top_class=target_class.class_name,
-                not_closed=not_closed,
-            ).serialize(not_closed=not_closed)
-            jsonschema_obj = json.loads(jsonschemastr)
-            self.jsonschema_objs[cache_params] = jsonschema_obj
-        else:
-            logging.info(f"Using cached jsonschema for {schema_id}")
-            jsonschema_obj = self.jsonschema_objs[cache_params]
-        return jsonschema.validate(inst_dict, schema=jsonschema_obj, format_checker=jsonschema.Draft7Validator.FORMAT_CHECKER)
+        self.validate_dict(inst_dict, target_class.class_name, closed)
 
     def validate_dict(
         self, data: dict, target_class: ClassDefinitionName = None, closed: bool = True
@@ -78,27 +92,35 @@ class JsonSchemaDataValidator(DataValidator):
         :param closed:
         :return:
         """
-        not_closed = not closed
+        results = list(self.iter_validate_dict(data, target_class, closed))
+        if results:
+            raise JsonSchemaDataValidatorError(results)
+
+    def iter_validate_dict(
+        self, data: dict, target_class_name: ClassDefinitionName = None, closed: bool = True
+    ) -> Iterable[str]:
         if self.schema is None:
-            raise ValueError(f"schema object must be set")
-        if target_class is None:
+            raise ValueError("schema object must be set")
+        if target_class_name is None:
             roots = [c.name for c in self.schema.classes.values() if c.tree_root]
             if len(roots) != 1:
                 raise ValueError(f"Cannot determine tree root: {roots}")
-            target_class = roots[0]
-        jsonschemastr = JsonSchemaGenerator(
-            self.schema,
-            mergeimports=True,
-            top_class=target_class,
-            not_closed=not_closed,
-        ).serialize(not_closed=not_closed)
-        jsonschema_obj = json.loads(jsonschemastr)
-        return jsonschema.validate(data, schema=jsonschema_obj, format_checker=jsonschema.Draft7Validator.FORMAT_CHECKER)
+            target_class_name = roots[0]
+        jsonschema_obj = _generate_jsonschema(
+            self._hashable_schema, target_class_name, closed, self.include_range_class_descendants
+        )
+        validator = jsonschema.Draft7Validator(
+            jsonschema_obj, format_checker=jsonschema.Draft7Validator.FORMAT_CHECKER
+        )
+        for error in validator.iter_errors(data):
+            best_error = best_match([error])
+            # TODO: This should return some kind of standard validation result
+            # object, but until that is defined just yield string messages
+            yield f"{best_error.message} in {best_error.json_path}"
 
 
 @click.command()
 @click.option("--module", "-m", help="Path to python datamodel module")
-@click.option("--output", "-o", help="Path to output file")
 @click.option(
     "--input-format",
     "-f",
@@ -110,20 +132,32 @@ class JsonSchemaDataValidator(DataValidator):
     "-C",
     help="name of class in datamodel that the root node instantiates",
 )
+@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(
-    "--index-slot", "-S", help="top level slot. Required for CSV dumping/loading"
+    "--exit-on-first-failure/--no-exit-on-first-failure",
+    default=False,
+    help="Exit after the first validation failure is found. If not specified all validation failures are reported.",
+)
+@click.option(
+    "--include-range-class-descendants/--no-range-class-descendants",
+    default=False,
+    show_default=False,
+    help="""
+When handling range constraints, include all descendants of the range class instead of just the range class
+""",
 )
-@click.option("--schema", "-s", help="Path to schema specified as LinkML yaml")
 @click.argument("input")
 @click.version_option(__version__, "-V", "--version")
 def cli(
     input,
     module,
     target_class,
-    output=None,
     input_format=None,
     schema=None,
     index_slot=None,
+    exit_on_first_failure=False,
+    include_range_class_descendants=False,
 ) -> None:
     """
     Validates instance data
@@ -140,13 +174,12 @@ def cli(
     if target_class is None:
         target_class = datautils.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 = datautils._get_format(input, input_format)
     loader = datautils.get_loader(input_format)
 
     inargs = {}
-    outargs = {}
     if datautils._is_xsv(input_format):
         if index_slot is None:
             index_slot = datautils.infer_index_slot(sv, target_class)
@@ -157,15 +190,33 @@ def cli(
     if datautils._is_rdf_format(input_format):
         inargs["schemaview"] = sv
         inargs["fmt"] = input_format
-    obj = loader.load(source=input, target_class=py_target_class, **inargs)
+
+    try:
+        data_as_dict = loader.load_as_dict(source=input, **inargs)
+    except NotImplementedError:
+        obj = loader.load(source=input, target_class=py_target_class, **inargs)
+        data_as_dict = as_simple_dict(obj)
+
     # Validation
     if schema is None:
-        raise Exception(
-            "--schema must be passed in order to validate. Suppress with --no-validate"
-        )
-    validator = JsonSchemaDataValidator(schema)
-    results = validator.validate_object(obj, target_class=py_target_class)
-    print(results)
+        raise Exception("--schema must be passed in order to validate. Suppress with --no-validate")
+
+    validator = JsonSchemaDataValidator(
+        schema, include_range_class_descendants=include_range_class_descendants
+    )
+    error_count = 0
+    for error in validator.iter_validate_dict(
+        data_as_dict, target_class_name=py_target_class.class_name
+    ):
+        error_count += 1
+        click.echo(click.style("\u2717 ", fg="red") + error)
+        if exit_on_first_failure:
+            sys.exit(1)
+
+    if not error_count:
+        click.echo(click.style("\u2713 ", fg="green") + "No problems found")
+
+    sys.exit(0 if error_count == 0 else 1)
 
 
 if __name__ == "__main__":

linkml/validators/sparqlvalidator.py

@@ -7,15 +7,12 @@ import click
 from linkml_runtime.linkml_model import SchemaDefinition
 from linkml_runtime.utils.schemaview import SchemaView
 from rdflib import Graph
-from SPARQLWrapper import (JSON, N3, RDF, RDFXML, TURTLE, SPARQLWrapper,
-                           SPARQLWrapper2)
+from SPARQLWrapper import JSON, SPARQLWrapper
 
 from linkml._version import __version__
 from linkml.generators.sparqlgen import SparqlGenerator
-from linkml.generators.yamlgen import YAMLGenerator
 from linkml.reporting import CheckResult, Report
-from linkml.utils.datautils import (_get_format, dumpers_loaders, get_dumper,
-                                    get_loader)
+from linkml.utils.datautils import _get_format, dumpers_loaders, get_dumper
 from linkml.utils.datavalidator import DataValidator
 
 
@@ -34,7 +31,6 @@ def _make_result(row):
 
 @dataclass
 class SparqlDataValidator(DataValidator):
-
     schema: SchemaDefinition = None
     queries: dict = None
 
@@ -90,9 +86,7 @@ class SparqlDataValidator(DataValidator):
 
 
 @click.command()
-@click.option(
-    "--named-graph", "-G", multiple=True, help="Constrain query to a named graph"
-)
+@click.option("--named-graph", "-G", multiple=True, help="Constrain query to a named graph")
 @click.option("--input", "-i", help="Input file to validate")
 @click.option("--endpoint-url", "-U", help="URL of sparql endpoint")
 @click.option("--limit", "-L", help="Max results per query")
@@ -128,16 +122,12 @@ def cli(
 
         linkml-sparql-validate -U http://sparql.hegroup.org/sparql -s tests/test_validation/input/omo.yaml
     """
-    if schema is not None:
-        sv = SchemaView(schema)
     validator = SparqlDataValidator(schema)
     if endpoint_url is not None:
-        results = validator.validate_endpoint(
-            endpoint_url, limit=limit, named_graphs=named_graph
-        )
+        results = validator.validate_endpoint(endpoint_url, limit=limit, named_graphs=named_graph)
     else:
         if input is None:
-            raise Exception(f"Must pass one of --endpoint-url OR --input")
+            raise Exception("Must pass one of --endpoint-url OR --input")
         input_format = _get_format(input, input_format)
         results = validator.validate_file(input, format=input_format)
     output_format = _get_format(output, output_format, default="json")

linkml/workspaces/datamodel/workspaces.py

@@ -8,26 +8,17 @@
 # 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 Boolean, Datetime, String
+from jsonasobj2 import as_dict
+from linkml_runtime.linkml_model.types import String
 from linkml_runtime.utils.curienamespace import CurieNamespace
-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 (Bool, XSDDateTime, bnode,
-                                                empty_dict, empty_list)
+from linkml_runtime.utils.dataclass_extensions_376 import dataclasses_init_fn_with_kwargs
+from linkml_runtime.utils.metamodelcore import Bool, XSDDateTime, empty_dict, 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, extended_str
+from rdflib import URIRef
 
 metamodel_version = "1.7.0"
 version = None
@@ -41,9 +32,7 @@ DCAT = CurieNamespace("dcat", "http://www.w3.org/ns/dcat#")
 FORMATS = CurieNamespace("formats", "http://www.w3.org/ns/formats/")
 FRICTIONLESS = CurieNamespace("frictionless", "https://specs.frictionlessdata.io/")
 LINKML = CurieNamespace("linkml", "https://w3id.org/linkml/")
-MEDIATYPES = CurieNamespace(
-    "mediatypes", "https://www.iana.org/assignments/media-types/"
-)
+MEDIATYPES = CurieNamespace("mediatypes", "https://www.iana.org/assignments/media-types/")
 OWL = CurieNamespace("owl", "http://www.w3.org/2002/07/owl#")
 PAV = CurieNamespace("pav", "http://purl.org/pav/")
 RDF = CurieNamespace("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#")
@@ -68,7 +57,8 @@ class FileSystemPath(String):
 
 
 class ProjectName(String):
-    """A project name MUST contain no whitespace and SHOULD only contains alphanumeric characters and hyphens (no underscores)"""
+    """A project name MUST contain no whitespace and SHOULD only contains
+    alphanumeric characters and hyphens (no underscores)"""
 
     type_class_uri = XSD.string
     type_class_curie = "xsd:string"
@@ -133,13 +123,9 @@ class Project(YAMLRoot):
         if self.github_organization is not None and not isinstance(
             self.github_organization, GitHubAccount
         ):
-            self.github_organization = GitHubAccount(
-                **as_dict(self.github_organization)
-            )
+            self.github_organization = GitHubAccount(**as_dict(self.github_organization))
 
-        if self.creation_date is not None and not isinstance(
-            self.creation_date, XSDDateTime
-        ):
+        if self.creation_date is not None and not isinstance(self.creation_date, XSDDateTime):
             self.creation_date = XSDDateTime(self.creation_date)
 
         if self.description is not None and not isinstance(self.description, str):
@@ -153,8 +139,7 @@ class Project(YAMLRoot):
         if not isinstance(self.data_files, list):
             self.data_files = [self.data_files] if self.data_files is not None else []
         self.data_files = [
-            v if isinstance(v, FileSystemPath) else FileSystemPath(v)
-            for v in self.data_files
+            v if isinstance(v, FileSystemPath) else FileSystemPath(v) for v in self.data_files
         ]
 
         self._normalize_inlined_as_dict(
@@ -259,9 +244,7 @@ class Workspace(YAMLRoot):
             slot_name="projects", slot_type=Project, key_name="name", keyed=True
         )
 
-        if self.github_account is not None and not isinstance(
-            self.github_account, GitHubAccount
-        ):
+        if self.github_account is not None and not isinstance(self.github_account, GitHubAccount):
             self.github_account = GitHubAccount(**as_dict(self.github_account))
 
         if self.projects_directory is not None and not isinstance(