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

linkml/utils/generator.py

@@ -21,34 +21,36 @@ import re
 import sys
 from contextlib import redirect_stdout
 from dataclasses import dataclass, field
+from functools import lru_cache
 from io import StringIO
 from pathlib import Path
-from typing import (Callable, Dict, List, Optional, Set, TextIO, Type, Union,
-                    cast, Mapping, ClassVar)
+from typing import Callable, ClassVar, Dict, List, Mapping, Optional, Set, TextIO, Type, Union, cast
 
 import click
 from click import Argument, Command, Option
 from linkml_runtime import SchemaView
 from linkml_runtime.dumpers import yaml_dumper
-from linkml_runtime.linkml_model.linkml_files import LOCAL_BASE
-from linkml_runtime.linkml_model.meta import (ClassDefinition,
-                                              ClassDefinitionName, Definition,
-                                              Element, ElementName,
-                                              EnumDefinition,
-                                              EnumDefinitionName,
-                                              PrefixPrefixPrefix,
-                                              SchemaDefinition, SlotDefinition,
-                                              SlotDefinitionName,
-                                              SubsetDefinition,
-                                              SubsetDefinitionName,
-                                              TypeDefinition,
-                                              TypeDefinitionName)
-import linkml_runtime.linkml_model.meta as metamodel
+from linkml_runtime.linkml_model.meta import (
+    ClassDefinition,
+    ClassDefinitionName,
+    Definition,
+    Element,
+    ElementName,
+    EnumDefinition,
+    EnumDefinitionName,
+    PrefixPrefixPrefix,
+    SchemaDefinition,
+    SlotDefinition,
+    SlotDefinitionName,
+    SubsetDefinition,
+    SubsetDefinitionName,
+    TypeDefinition,
+    TypeDefinitionName,
+)
 from linkml_runtime.utils.formatutils import camelcase, underscore
-from linkml_runtime.utils.introspection import package_schemaview
 from linkml_runtime.utils.namespaces import Namespaces
 
-from linkml import LOCAL_METAMODEL_YAML_FILE, META_BASE_URI, METAMODEL_YAML_URI
+from linkml import LOCAL_METAMODEL_YAML_FILE
 from linkml.utils.mergeutils import alias_root
 from linkml.utils.schemaloader import SchemaLoader
 from linkml.utils.typereferences import References
@@ -57,6 +59,23 @@ DEFAULT_LOG_LEVEL: str = "WARNING"
 DEFAULT_LOG_LEVEL_INT: int = logging.WARNING
 
 
+@lru_cache
+def _resolved_metamodel(mergeimports):
+    if not os.path.exists(LOCAL_METAMODEL_YAML_FILE):
+        raise AssertionError(f"{LOCAL_METAMODEL_YAML_FILE} not found")
+
+    base_dir = str(Path(str(LOCAL_METAMODEL_YAML_FILE)).parent)
+    logging.debug(f"BASE={base_dir}")
+    metamodel = SchemaLoader(
+        LOCAL_METAMODEL_YAML_FILE,
+        importmap={"linkml": base_dir},
+        base_dir=base_dir,
+        mergeimports=mergeimports,
+    )
+    metamodel.resolve()
+    return metamodel
+
+
 @dataclass
 class Generator(metaclass=abc.ABCMeta):
     """
@@ -79,8 +98,8 @@ class Generator(metaclass=abc.ABCMeta):
     uses_schemaloader: ClassVar[bool] = True
     """Old-style generator that uses the SchemaLoader and visitor pattern"""
 
-    #uses_schemaview: ClassVar[bool] = True
-    #"""New-style generator that uses SchemaView"""
+    # uses_schemaview: ClassVar[bool] = True
+    # """New-style generator that uses SchemaView"""
 
     requires_metamodel: ClassVar[bool] = True
     """Generator queries an instance of the metamodel"""
@@ -104,7 +123,9 @@ class Generator(metaclass=abc.ABCMeta):
     format: Optional[str] = None
     """expected output format"""
 
-    metadata: bool = field(default_factory= lambda: True)
+    file_extension: ClassVar[str] = None
+
+    metadata: bool = field(default_factory=lambda: True)
     """True means include date, generator, etc. information in source header if appropriate"""
 
     useuris: Optional[bool] = None
@@ -113,7 +134,7 @@ class Generator(metaclass=abc.ABCMeta):
     log_level: int = DEFAULT_LOG_LEVEL_INT
     """Logging level, 0 is minimum"""
 
-    mergeimports: Optional[bool] = field(default_factory= lambda: True)
+    mergeimports: Optional[bool] = field(default_factory=lambda: True)
     """True means merge non-linkml sources into importing package.  False means separate packages"""
 
     source_file_date: Optional[str] = None
@@ -129,7 +150,8 @@ class Generator(metaclass=abc.ABCMeta):
     """Verbosity"""
 
     output: Optional[str] = None
-    """Path to output file. Note all generators may not implement this uniformly, see https://github.com/linkml/linkml/issues/923"""
+    """Path to output file. Note all generators may not implement this
+    uniformly, see https://github.com/linkml/linkml/issues/923"""
 
     namespaces: Optional[Namespaces] = None
     """All prefix expansions used"""
@@ -140,9 +162,7 @@ class Generator(metaclass=abc.ABCMeta):
     base_dir: str = None  # Base directory of schema
     """Working directory or base URL of sources"""
 
-    metamodel_name_map: Dict[
-        str, str
-    ] = None
+    metamodel_name_map: Dict[str, str] = None
     """Allows mapping of names of metamodel elements such as slot, etc"""
 
     importmap: Optional[Union[str, Optional[Mapping[str, str]]]] = None
@@ -170,29 +190,21 @@ class Generator(metaclass=abc.ABCMeta):
             self.source_file_date = None
             self.source_file_size = None
         if self.requires_metamodel:
-            if os.path.exists(LOCAL_METAMODEL_YAML_FILE):
-                base_dir = str(Path(str(LOCAL_METAMODEL_YAML_FILE)).parent)
-                logging.debug(f"BASE={base_dir}")
-                self.metamodel = SchemaLoader(
-                        LOCAL_METAMODEL_YAML_FILE,
-                        importmap={"linkml": base_dir},
-                        base_dir=base_dir,
-                        mergeimports=self.mergeimports,
-                    )
-            else:
-                raise AssertionError(f"{LOCAL_METAMODEL_YAML_FILE} not found")
-            self.metamodel.resolve()
+            self.metamodel = _resolved_metamodel(self.mergeimports)
         schema = self.schema
         # TODO: remove aliasing
         self.emit_metadata = self.metadata
         if self.uses_schemaloader:
             self._initialize_using_schemaloader(schema)
         else:
-            self.schemaview = SchemaView(schema)
+            logging.info(f"Using SchemaView with im={self.importmap}")
+            self.schemaview = SchemaView(schema, importmap=self.importmap)
             self.schema = self.schemaview.schema
         self._init_namespaces()
 
-    def _initialize_using_schemaloader(self, schema: Union[str, TextIO, SchemaDefinition, "Generator"]):
+    def _initialize_using_schemaloader(
+        self, schema: Union[str, TextIO, SchemaDefinition, "Generator"]
+    ):
         # currently generators are very liberal in what they accept, including
         # other generators.
         # See https://github.com/linkml/linkml/issues/923 for discussion on how
@@ -251,7 +263,7 @@ class Generator(metaclass=abc.ABCMeta):
         """
         Generate output in the required format
 
-        :param kwargs: Generater specific parameters
+        :param kwargs: Generator specific parameters
         :return: Generated output
         """
         output = StringIO()
@@ -294,9 +306,7 @@ class Generator(metaclass=abc.ABCMeta):
             ):
                 if self.visit_class(cls):
                     for slot in (
-                        self.all_slots(cls)
-                        if self.visit_all_class_slots
-                        else self.own_slots(cls)
+                        self.all_slots(cls) if self.visit_all_class_slots else self.own_slots(cls)
                     ):
                         self.visit_class_slot(cls, self.aliased_slot_name(slot), slot)
                     self.end_class(cls)
@@ -376,9 +386,7 @@ class Generator(metaclass=abc.ABCMeta):
     # =============================
     # Helper methods
     # =============================
-    def own_slots(
-        self, cls: Union[ClassDefinitionName, ClassDefinition]
-    ) -> List[SlotDefinition]:
+    def own_slots(self, cls: Union[ClassDefinitionName, ClassDefinition]) -> List[SlotDefinition]:
         """Return the list of slots owned the class definition.  An "own slot" is any ``cls`` slot that does not appear
         in the class is_a parent.  Own_slots include:
 
@@ -440,9 +448,7 @@ class Generator(metaclass=abc.ABCMeta):
                     rval.append(slot)
                     seen.add(sname_base)
             return rval + (
-                self.all_slots(parent, cls_slots_first=cls_slots_first, seen=seen)
-                if parent
-                else []
+                self.all_slots(parent, cls_slots_first=cls_slots_first, seen=seen) if parent else []
             )
         else:
             for sname in cls.slots:
@@ -465,9 +471,7 @@ class Generator(metaclass=abc.ABCMeta):
             else self.schema.slots[element.is_a]
         )
 
-    def ancestors(
-        self, element: Union[ClassDefinition, SlotDefinition]
-    ) -> List[ElementName]:
+    def ancestors(self, element: Union[ClassDefinition, SlotDefinition]) -> List[ElementName]:
         """Return an ordered list of ancestor names for the supplied slot or class
 
         @param element: Slot or class name or definition
@@ -477,9 +481,7 @@ class Generator(metaclass=abc.ABCMeta):
             [] if element.is_a is None else self.ancestors(self.parent(element))
         )
 
-    def neighborhood(
-        self, elements: Union[str, ElementName, List[ElementName]]
-    ) -> References:
+    def neighborhood(self, elements: Union[str, ElementName, List[ElementName]]) -> References:
         """Return a list of all slots, classes and types that touch any element in elements, including the element
         itself
 
@@ -549,9 +551,7 @@ class Generator(metaclass=abc.ABCMeta):
             if element in self.schema.subsets:
                 touches.subsetrefs.add(cast(SubsetDefinitionName, element))
                 if element in self.synopsis.subsetrefs:
-                    touches.update(
-                        self.synopsis.subsetrefs[cast(SubsetDefinitionName, element)]
-                    )
+                    touches.update(self.synopsis.subsetrefs[cast(SubsetDefinitionName, element)])
             if not bool(touches):
                 self.logger.warning(f"neighborhood({element}) - {element} is undefined")
 
@@ -566,9 +566,9 @@ class Generator(metaclass=abc.ABCMeta):
         """
         formatted_typ_name = self.class_or_type_name(typ.name)
         if typ.typeof:
-            return self.range_type_path(
-                self.schema.types[cast(TypeDefinitionName, typ.typeof)]
-            ) + [formatted_typ_name]
+            return self.range_type_path(self.schema.types[cast(TypeDefinitionName, typ.typeof)]) + [
+                formatted_typ_name
+            ]
         elif typ.repr:
             return [typ.repr, formatted_typ_name]
         else:
@@ -595,9 +595,7 @@ class Generator(metaclass=abc.ABCMeta):
                 return slotname
         return None
 
-    def enum_identifier_path(
-        self, enum_or_enumname: Union[str, EnumDefinition]
-    ) -> List[str]:
+    def enum_identifier_path(self, enum_or_enumname: Union[str, EnumDefinition]) -> List[str]:
         """Return an enum_identifier path"""
         return [
             "str",
@@ -656,9 +654,7 @@ class Generator(metaclass=abc.ABCMeta):
         )
         if slot.range in self.schema.types:
             # Type
-            return self.range_type_path(
-                self.schema.types[cast(TypeDefinitionName, slot.range)]
-            )
+            return self.range_type_path(self.schema.types[cast(TypeDefinitionName, slot.range)])
         elif slot.range in self.schema.enums:
             return self.enum_identifier_path(slot.range)
         else:
@@ -758,9 +754,7 @@ class Generator(metaclass=abc.ABCMeta):
         else:
             return None
 
-    def obj_for(
-        self, el_or_elname: str, is_range_name: bool = False
-    ) -> Optional[Element]:
+    def obj_for(self, el_or_elname: str, is_range_name: bool = False) -> Optional[Element]:
         if is_range_name:
             return (
                 self.class_or_type_for(el_or_elname)
@@ -794,8 +788,7 @@ class Generator(metaclass=abc.ABCMeta):
         return [
             slot
             for slot in [self.schema.slots[sn] for sn in cls.slots]
-            if cls.name in slot.domain_of
-            or (set(cls.mixins).intersection(slot.domain_of))
+            if cls.name in slot.domain_of or (set(cls.mixins).intersection(slot.domain_of))
         ]
 
     def add_mappings(self, defn: Definition) -> None:
@@ -826,9 +819,7 @@ class Generator(metaclass=abc.ABCMeta):
                 else:
                     mapping = mcurie
             if ":" not in mapping or len(mapping.split(":")) != 2:
-                raise ValueError(
-                    f"Definition {defn.name} - unrecognized mapping: {mapping}"
-                )
+                raise ValueError(f"Definition {defn.name} - unrecognized mapping: {mapping}")
             ns = mapping.split(":")[0]
             logging.debug(f"Adding {ns} from {mapping} // {defn}")
             if ns:
@@ -873,18 +864,13 @@ class Generator(metaclass=abc.ABCMeta):
         slot_name_normalized_singular = re.sub(r"s$", "", slot_name_normalized)
         if slot_name_normalized == "classes":
             slot_name_normalized_singular = "class"
-        if (
-            self.metamodel_name_map is not None
-            and slot_name_normalized in self.metamodel_name_map
-        ):
+        if self.metamodel_name_map is not None and slot_name_normalized in self.metamodel_name_map:
             return capitalize(self.metamodel_name_map[slot_name_normalized])
         elif (
             self.metamodel_name_map is not None
             and slot_name_normalized_singular in self.metamodel_name_map
         ):
-            return capitalize(
-                f"{self.metamodel_name_map[slot_name_normalized_singular]}s"
-            )
+            return capitalize(f"{self.metamodel_name_map[slot_name_normalized_singular]}s")
         else:
             return slot_name
 
@@ -926,16 +912,14 @@ def shared_arguments(g: Type[Generator]) -> Callable[[Command], Command]:
         logging.basicConfig(level=_log_level_string_to_int(value))
 
     def decorator(f: Command) -> Command:
-        f.params.append(
-            Argument(("yamlfile",), type=click.Path(exists=True, dir_okay=False))
-        )
+        f.params.append(Argument(("yamlfile",), type=click.Path(exists=True, dir_okay=False)))
         f.params.append(
             Option(
                 ("--format", "-f"),
                 type=click.Choice(g.valid_formats),
                 default=g.valid_formats[0],
                 show_default=True,
-                help=f"Output format",
+                help="Output format",
             )
         )
         f.params.append(
@@ -955,15 +939,13 @@ def shared_arguments(g: Type[Generator]) -> Callable[[Command], Command]:
             )
         )
         f.params.append(
-            Option(
-                ("--importmap", "-im"), type=click.File(), help="Import mapping file"
-            )
+            Option(("--importmap", "-im"), type=click.File(), help="Import mapping file")
         )
         f.params.append(
             Option(
                 ("--log_level",),
                 type=click.Choice(_LOG_LEVEL_STRINGS),
-                help=f"Logging level",
+                help="Logging level",
                 default=DEFAULT_LOG_LEVEL,
                 show_default=True,
                 callback=log_level_callback,
@@ -973,7 +955,7 @@ def shared_arguments(g: Type[Generator]) -> Callable[[Command], Command]:
             Option(
                 ("--verbose", "-v"),
                 count=True,
-                help=f"verbosity",
+                help="verbosity",
                 callback=verbosity_callback,
             )
         )

linkml/utils/helpers.py

@@ -1,5 +1,6 @@
 import re
 
+
 def remove_duplicates(lst):
     """Remove duplicate tuples from a list of tuples."""
     return [t for t in (set(tuple(i) for i in lst))]
@@ -9,6 +10,7 @@ def write_to_file(file_path, data, mode="w", encoding="utf-8"):
     with open(file_path, mode, encoding=encoding) as f:
         f.write(data)
 
+
 def convert_to_snake_case(str):
-    str = re.sub(r"(?<=[a-z])(?=[A-Z])|[^a-zA-Z]", " ", str).strip().replace(' ', '_')
-    return ''.join(str.lower())
+    str = re.sub(r"(?<=[a-z])(?=[A-Z])|[^a-zA-Z]", " ", str).strip().replace(" ", "_")
+    return "".join(str.lower())

linkml/utils/ifabsent_functions.py

@@ -13,20 +13,12 @@ def strval(txt: str) -> str:
 
 
 def default_uri_for(loader: SchemaLoader) -> str:
-    dflt = (
-        loader.schema.default_prefix
-        if loader.schema.default_prefix
-        else sfx(loader.schema.id)
-    )
+    dflt = loader.schema.default_prefix if loader.schema.default_prefix else sfx(loader.schema.id)
     return sfx(loader.namespaces.uri_for(dflt))
 
 
 def default_curie_or_uri(loader: SchemaLoader) -> str:
-    dflt = (
-        loader.schema.default_prefix
-        if loader.schema.default_prefix
-        else sfx(loader.schema.id)
-    )
+    dflt = loader.schema.default_prefix if loader.schema.default_prefix else sfx(loader.schema.id)
     if ":/" in dflt:
         prefix = loader.namespaces.prefix_for(loader.schema.default_prefix)
         if prefix:
@@ -65,6 +57,7 @@ def default_ns_for(loader: SchemaLoader, cls: ClassDefinition) -> str:
     #         cls_id = slotname
     # return f"sfx(str(self.{cls_id}))" if cls_id else "None"
 
+
 # Library of named default values -- this is here to prevent code injection
 # Contents: Match text (as re),
 #           flag that indicates whether we're generating a default value expression or postinig code
@@ -80,12 +73,27 @@ default_library: List[
     (r"[Tt]rue", False, lambda _, __, ___, ____: "True"),
     (r"[Ff]alse", False, lambda _, __, ___, ____: "False"),
     (r"int\(([-+]?[0-9]+)\)", False, lambda m, __, ___, ____: int(m[1])),
-    (r"float\(([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)\)", False, lambda m, __, ___, ____: float(m[1])),
-    (r"date\((\d{4})-(\d{2})-(\d{2})\)", False, lambda m, __, ___, ____: f"datetime.date({m[1]}, {m[2]}, {m[3]})"),
-    (r"datetime\((\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})Z\)", False, lambda m, __, ___, ____: f"datetime.datetime({m[1]}, {m[2]}, {m[3]}, {m[4]}, {m[5]}, {m[6]})"),
+    (
+        r"float\(([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)\)",
+        False,
+        lambda m, __, ___, ____: float(m[1]),
+    ),
+    (
+        r"date\((\d{4})-(\d{2})-(\d{2})\)",
+        False,
+        lambda m, __, ___, ____: f"datetime.date({m[1]}, {m[2]}, {m[3]})",
+    ),
+    (
+        r"datetime\((\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})Z\)",
+        False,
+        lambda m, __, ___, ____: f"datetime.datetime({m[1]}, {m[2]}, {m[3]}, {m[4]}, {m[5]}, {m[6]})",
+    ),
     # TODO: We have to make the real URI available before any of these can work
-    # ("class_uri", True, lambda _, loader, ___, ____: f'"{default_uri_for(loader)}" + camelcase(self.name)'),
-    # ("slot_uri", True, lambda _, loader, ___, ____: f'"{default_uri_for(loader)}" + underscore(self.alias if self.alias else self.name)'),
+    # ("class_uri", True,
+    #     lambda _, loader, ___, ____: f'"{default_uri_for(loader)}" + camelcase(self.name)'),
+    # ("slot_uri", True,
+    #     lambda _, loader, ___, ____: f'"{default_uri_for(loader)}" +
+    #     underscore(self.alias if self.alias else self.name)'),
     # ("class_curie", True, lambda _, loader, ___, ____: curie_for(loader, True)),
     # ("slot_curie", True, lambda _, loader, ___, ____: curie_for(loader, False)),
     ("class_uri", True, lambda _, loader, ___, ____: "None"),

linkml/utils/mergeutils.py

@@ -3,12 +3,16 @@ import logging
 from copy import deepcopy
 from typing import Dict, List, Optional, Union, cast
 
-from linkml_runtime.linkml_model.meta import (ClassDefinition, Element,
-                                              EnumDefinition, SchemaDefinition,
-                                              SlotDefinition,
-                                              SlotDefinitionName,
-                                              TypeDefinition,
-                                              TypeDefinitionName)
+from linkml_runtime.linkml_model.meta import (
+    ClassDefinition,
+    Element,
+    EnumDefinition,
+    SchemaDefinition,
+    SlotDefinition,
+    SlotDefinitionName,
+    TypeDefinition,
+    TypeDefinitionName,
+)
 from linkml_runtime.utils.formatutils import camelcase, underscore
 from linkml_runtime.utils.namespaces import Namespaces
 from linkml_runtime.utils.yamlutils import extended_str
@@ -45,26 +49,14 @@ def merge_schemas(
             imported_from_uri = imported_from
         else:
             imported_from_uri = namespaces.uri_for(imported_from)
-    merge_dicts(
-        target.classes, mergee.classes, imported_from, imported_from_uri, merge_imports
-    )
-    merge_dicts(
-        target.slots, mergee.slots, imported_from, imported_from_uri, merge_imports
-    )
-    merge_dicts(
-        target.types, mergee.types, imported_from, imported_from_uri, merge_imports
-    )
-    merge_dicts(
-        target.subsets, mergee.subsets, imported_from, imported_from_uri, merge_imports
-    )
-    merge_dicts(
-        target.enums, mergee.enums, imported_from, imported_from_uri, merge_imports
-    )
+    merge_dicts(target.classes, mergee.classes, imported_from, imported_from_uri, merge_imports)
+    merge_dicts(target.slots, mergee.slots, imported_from, imported_from_uri, merge_imports)
+    merge_dicts(target.types, mergee.types, imported_from, imported_from_uri, merge_imports)
+    merge_dicts(target.subsets, mergee.subsets, imported_from, imported_from_uri, merge_imports)
+    merge_dicts(target.enums, mergee.enums, imported_from, imported_from_uri, merge_imports)
 
 
-def merge_namespaces(
-    target: SchemaDefinition, mergee: SchemaDefinition, namespaces
-) -> None:
+def merge_namespaces(target: SchemaDefinition, mergee: SchemaDefinition, namespaces) -> None:
     """
     Add the mergee namespace definitions to target
 
@@ -74,7 +66,6 @@ def merge_namespaces(
     :return:
     """
     for prefix in mergee.prefixes.values():
-
         # Handle local prefixes special: we assume that these happen because we are in different (levels of) folders,
         # and we assume that they reference the same linkml file
         if "://" not in prefix.prefix_reference:
@@ -110,8 +101,7 @@ def merge_namespaces(
         #     target.prefixes[prefix.prefix_prefix] = prefix
         if (
             prefix.prefix_prefix in target.prefixes
-            and target.prefixes[prefix.prefix_prefix].prefix_reference
-            != prefix.prefix_reference
+            and target.prefixes[prefix.prefix_prefix].prefix_reference != prefix.prefix_reference
         ):
             raise ValueError(
                 f"Prefix: {prefix.prefix_prefix} mismatch between {target.name} and {mergee.name}"
@@ -177,11 +167,7 @@ def merge_slots(
     if skip is None:
         skip = []
     for k, v in dataclasses.asdict(source).items():
-        if (
-            k not in skip
-            and v is not None
-            and (not inheriting or getattr(target, k, None) is None)
-        ):
+        if k not in skip and v is not None and (not inheriting or getattr(target, k, None) is None):
             if k in source._inherited_slots or not inheriting:
                 setattr(target, k, deepcopy(v))
             else:
@@ -234,9 +220,7 @@ def merge_classes(
         if slotbase in target.slot_usage:
             slotname = slot_usage_name(slotbase, target)
         if slotbase not in target_base_slots:
-            target.slots.append(slotname) if at_end else target.slots.insert(
-                0, slotname
-            )
+            target.slots.append(slotname) if at_end else target.slots.insert(0, slotname)
             target_base_slots.add(slotbase)
 
 

linkml/utils/rawloader.py

@@ -6,9 +6,7 @@ from urllib.parse import urlparse
 import yaml
 from dateutil.parser import ParserError, parse
 from hbreader import FileInfo, HBType, detect_type
-from linkml_runtime.linkml_model.meta import (ClassDefinition,
-                                              SchemaDefinition, SlotDefinition,
-                                              metamodel_version)
+from linkml_runtime.linkml_model.meta import SchemaDefinition, metamodel_version
 from linkml_runtime.loaders import yaml_loader
 from linkml_runtime.utils.yamlutils import YAMLMark, YAMLRoot
 
@@ -56,9 +54,7 @@ def load_raw_schema(
 
     # Passing a URL or file name
     if detect_type(data, base_dir) not in (HBType.STRING, HBType.STRINGABLE):
-        assert (
-            source_file is None
-        ), "source_file parameter not allowed if data is a file or URL"
+        assert source_file is None, "source_file parameter not allowed if data is a file or URL"
         assert (
             source_file_date is None
         ), "source_file_date parameter not allowed if data is a file or URL"

linkml/utils/schema_builder.py

@@ -1,11 +1,16 @@
-from dataclasses import dataclass, field
-from typing import Dict, List, Union, Optional
-
-from linkml_runtime.linkml_model import (ClassDefinition, EnumDefinition,
-                                         PermissibleValue, Prefix,
-                                         SchemaDefinition, SlotDefinition,
-                                         TypeDefinition)
-from linkml_runtime.utils.formatutils import camelcase, underscore
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Union
+
+from linkml_runtime.linkml_model import (
+    ClassDefinition,
+    EnumDefinition,
+    PermissibleValue,
+    Prefix,
+    SchemaDefinition,
+    SlotDefinition,
+    TypeDefinition,
+)
+from linkml_runtime.utils.formatutils import underscore
 from linkml_runtime.utils.schema_as_dict import schema_as_dict
 
 
@@ -69,6 +74,7 @@ class SchemaBuilder:
         :param slot_usage: slots keyed by slot name
         :param replace_if_present: if True, replace existing class if present
         :param kwargs: additional ClassDefinition properties
+        :param use_attributes: if True, add slots as attributes
         :return: builder
         :raises ValueError: if class already exists and replace_if_present=False
         """
@@ -83,10 +89,12 @@ class SchemaBuilder:
             for s in slots:
                 if isinstance(s, SlotDefinition):
                     cls.attributes[s.name] = s
+                elif isinstance(s, dict):
+                    cls.attributes[s["name"]] = s
+                elif isinstance(s, str):
+                    cls.attributes[s] = SlotDefinition(s)
                 else:
-                    raise ValueError(
-                        f"If use_attributes=True then slots must be SlotDefinitions"
-                    )
+                    raise ValueError("If use_attributes=True then slots must be SlotDefinitions")
         else:
             if slots is not None:
                 for s in slots:
@@ -103,7 +111,11 @@ class SchemaBuilder:
         return self
 
     def add_slot(
-        self, slot: Union[SlotDefinition, Dict, str], class_name: str = None, replace_if_present=False, **kwargs
+        self,
+        slot: Union[SlotDefinition, Dict, str],
+        class_name: str = None,
+        replace_if_present=False,
+        **kwargs,
     ) -> "SchemaBuilder":
         """
         Adds the slot to the schema.
@@ -170,7 +182,7 @@ class SchemaBuilder:
                     enum_def.permissible_values[pv.text] = pv
         return self
 
-    def add_prefix(self, prefix: str, url: str, replace_if_present = False) -> "SchemaBuilder":
+    def add_prefix(self, prefix: str, url: str, replace_if_present=False) -> "SchemaBuilder":
         """
         Adds a prefix for use with CURIEs
 
@@ -205,12 +217,12 @@ class SchemaBuilder:
         return self
 
     def add_type(
-            self,
-            type: Union[TypeDefinition, Dict, str],
-            typeof: str = None,
-            uri: str = None,
-            replace_if_present=False,
-            **kwargs
+        self,
+        type: Union[TypeDefinition, Dict, str],
+        typeof: str = None,
+        uri: str = None,
+        replace_if_present=False,
+        **kwargs,
     ) -> "SchemaBuilder":
         """
         Adds the type to the schema