linkml 1.8.3__py3-none-any.whl → 1.8.5__py3-none-any.whl

linkml/generators/shaclgen.py

@@ -5,19 +5,21 @@ from typing import Callable, List
 
 import click
 from jsonasobj2 import JsonObj, as_dict
-from linkml_runtime.linkml_model.meta import ElementName
+from linkml_runtime.linkml_model.meta import ClassDefinition, ElementName
 from linkml_runtime.utils.formatutils import underscore
 from linkml_runtime.utils.schemaview import SchemaView
 from linkml_runtime.utils.yamlutils import TypedNode, extended_float, extended_int, extended_str
 from rdflib import BNode, Graph, Literal, URIRef
 from rdflib.collection import Collection
-from rdflib.namespace import RDF, RDFS, SH, XSD
+from rdflib.namespace import RDF, SH, XSD
 
 from linkml._version import __version__
 from linkml.generators.shacl.shacl_data_type import ShaclDataType
 from linkml.generators.shacl.shacl_ifabsent_processor import ShaclIfAbsentProcessor
 from linkml.utils.generator import Generator, shared_arguments
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class ShaclGenerator(Generator):
@@ -74,9 +76,6 @@ class ShaclGenerator(Generator):
             shape_pv(RDF.type, SH.NodeShape)
             shape_pv(SH.targetClass, class_uri)  # TODO
 
-            if c.is_a:
-                shape_pv(RDFS.subClassOf, URIRef(sv.get_uri(c.is_a, expand=True)))
-
             if self.closed:
                 if c.mixin or c.abstract:
                     shape_pv(SH.closed, Literal(False))
@@ -88,9 +87,9 @@ class ShaclGenerator(Generator):
                 shape_pv(SH.name, Literal(c.title))
             if c.description is not None:
                 shape_pv(SH.description, Literal(c.description))
-            list_node = BNode()
-            Collection(g, list_node, [RDF.type])
-            shape_pv(SH.ignoredProperties, list_node)
+
+            shape_pv(SH.ignoredProperties, self._build_ignored_properties(g, c))
+
             if c.annotations and self.include_annotations:
                 self._add_annotations(shape_pv, c)
             order = 0
@@ -130,7 +129,7 @@ class ShaclGenerator(Generator):
                     # slot definition, as both are mapped to sh:in in SHACL
                     if s.equals_string or s.equals_string_in:
                         error = "'equals_string'/'equals_string_in' and 'any_of' are mutually exclusive"
-                        raise ValueError(f'{TypedNode.yaml_loc(s, suffix="")} {error}')
+                        raise ValueError(f'{TypedNode.yaml_loc(str(s), suffix="")} {error}')
 
                     or_node = BNode()
                     prop_pv(SH["or"], or_node)
@@ -244,7 +243,7 @@ class ShaclGenerator(Generator):
             if rt.annotations and self.include_annotations:
                 self._add_annotations(func, rt)
         else:
-            logging.error(f"No URI for type {rt.name}")
+            logger.error(f"No URI for type {rt.name}")
 
     def _and_equals_string(self, g: Graph, func: Callable, values: List) -> None:
         pv_node = BNode()
@@ -301,6 +300,31 @@ class ShaclGenerator(Generator):
         )
         func(SH["in"], pv_node)
 
+    def _build_ignored_properties(self, g: Graph, c: ClassDefinition) -> BNode:
+        def collect_child_properties(class_name: str, output: set) -> None:
+            for childName in self.schemaview.class_children(class_name, imports=True, mixins=False, is_a=True):
+                output.update(
+                    {
+                        URIRef(self.schemaview.get_uri(prop, expand=True))
+                        for prop in self.schemaview.class_slots(childName)
+                    }
+                )
+                collect_child_properties(childName, output)
+
+        child_properties = set()
+        collect_child_properties(c.name, child_properties)
+
+        class_slot_uris = {
+            URIRef(self.schemaview.get_uri(prop, expand=True)) for prop in self.schemaview.class_slots(c.name)
+        }
+        ignored_properties = child_properties.difference(class_slot_uris)
+
+        list_node = BNode()
+        ignored_properties.add(RDF.type)
+        Collection(g, list_node, list(ignored_properties))
+
+        return list_node
+
 
 def add_simple_data_type(func: Callable, r: ElementName) -> None:
     for datatype in list(ShaclDataType):

linkml/generators/sparqlgen.py

@@ -14,6 +14,8 @@ from linkml_runtime.utils.schemaview import SchemaView
 from linkml._version import __version__
 from linkml.utils.generator import Generator, shared_arguments
 
+logger = logging.getLogger(__name__)
+
 template = """
 {% for pfxn, pfx in schema.prefixes.items() -%}
 PREFIX {{pfxn}}: <{{pfx.prefix_reference}}>
@@ -150,7 +152,7 @@ class SparqlGenerator(Generator):
         extra = ""
         if named_graphs is not None:
             extra += f'FILTER( ?graph in ( {",".join(named_graphs)} ))'
-        logging.info(f"Named Graphs = {named_graphs} // extra={extra}")
+        logger.info(f"Named Graphs = {named_graphs} // extra={extra}")
         if limit is not None and isinstance(limit, int):
             limit = f"LIMIT {limit}"
         else:

linkml/generators/sqlalchemygen.py

@@ -21,6 +21,8 @@ from linkml.generators.sqltablegen import SQLTableGenerator
 from linkml.transformers.relmodel_transformer import ForeignKeyPolicy, RelationalModelTransformer
 from linkml.utils.generator import Generator, shared_arguments
 
+logger = logging.getLogger(__name__)
+
 
 class TemplateEnum(Enum):
     DECLARATIVE = "declarative"
@@ -84,7 +86,7 @@ class SQLAlchemyGenerator(Generator):
         template_obj = Template(template_str)
         if model_path is None:
             model_path = self.schema.name
-        logging.info(f"Package for dataclasses ==  {model_path}")
+        logger.info(f"Package for dataclasses ==  {model_path}")
         backrefs = defaultdict(list)
         for m in tr_result.mappings:
             backrefs[m.source_class].append(m)
@@ -113,7 +115,7 @@ class SQLAlchemyGenerator(Generator):
             is_join_table=lambda c: any(tag for tag in c.annotations.keys() if tag == "linkml:derived_from"),
             classes=rel_schema_classes_ordered,
         )
-        logging.debug(f"# Generated code:\n{code}")
+        logger.debug(f"# Generated code:\n{code}")
         return code
 
     def serialize(self, **kwargs) -> str:
@@ -173,7 +175,7 @@ class SQLAlchemyGenerator(Generator):
     def skip(cls: ClassDefinition) -> bool:
         is_skip = len(cls.attributes) == 0
         if is_skip:
-            logging.error(f"SKIPPING: {cls.name}")
+            logger.error(f"SKIPPING: {cls.name}")
         return is_skip
 
     # TODO: move this

linkml/generators/sqltablegen.py

@@ -16,6 +16,8 @@ from linkml.transformers.relmodel_transformer import ForeignKeyPolicy, Relationa
 from linkml.utils.generator import Generator, shared_arguments
 from linkml.utils.schemaloader import SchemaLoader
 
+logger = logging.getLogger(__name__)
+
 
 class SqlNamingPolicy(Enum):
     preserve = "preserve"
@@ -262,12 +264,12 @@ class SQLTableGenerator(Generator):
         elif range is None:
             return Text()
         else:
-            logging.error(f"Unknown range: {range} for {slot.name} = {slot.range}")
+            logger.error(f"Unknown range: {range} for {slot.name} = {slot.range}")
             return Text()
         if range_base in RANGEMAP:
             return RANGEMAP[range_base]
         else:
-            logging.error(f"UNKNOWN range base: {range_base} for {slot.name} = {slot.range}")
+            logger.error(f"UNKNOWN range base: {range_base} for {slot.name} = {slot.range}")
             return Text()
 
     @staticmethod

linkml/generators/typescriptgen.py

@@ -19,6 +19,9 @@ from linkml._version import __version__
 from linkml.generators.oocodegen import OOCodeGenerator
 from linkml.utils.generator import shared_arguments
 
+logger = logging.getLogger(__name__)
+
+
 type_map = {
     "str": "string",
     "int": "number",
@@ -120,7 +123,7 @@ class TypescriptGenerator(OOCodeGenerator):
     gen_type_utils: bool = False
     include_induced_slots: bool = False
 
-    def serialize(self) -> str:
+    def serialize(self, output=None) -> str:
         """Serialize a schema to typescript string"""
 
         sv: SchemaView = self.schemaview
@@ -132,6 +135,9 @@ class TypescriptGenerator(OOCodeGenerator):
             view=self.schemaview,
             enums=enums,
         )
+        if output is not None:
+            with open(output, "w") as out:
+                out.write(out_str)
         return out_str
 
     @staticmethod
@@ -207,7 +213,7 @@ class TypescriptGenerator(OOCodeGenerator):
                 elif t.typeof and t.typeof in type_map:
                     tsrange = type_map[t.typeof]
                 else:
-                    logging.warning(f"Unknown type.base: {t.name}")
+                    logger.warning(f"Unknown type.base: {t.name}")
                 if slot.multivalued:
                     tsrange = f"{tsrange}[]"
                 return tsrange
@@ -241,7 +247,7 @@ class TypescriptGenerator(OOCodeGenerator):
                 elif t.typeof and t.typeof in type_map:
                     return type_init_map[t.typeof]
                 else:
-                    logging.warning(f"Unknown type.base: {t.name}")
+                    logger.warning(f"Unknown type.base: {t.name}")
                 return "null"
             return "null"
 
@@ -264,8 +270,9 @@ class TypescriptGenerator(OOCodeGenerator):
 @click.version_option(__version__, "-V", "--version")
 @click.option("--gen-type-utils/", "-u", help="Generate Type checking utils", is_flag=True)
 @click.option("--include-induced-slots/", help="Generate slots induced through inheritance", is_flag=True)
-@click.command(name="typescript")
-def cli(yamlfile, gen_type_utils=False, include_induced_slots=False, **args):
+@click.option("--output", type=click.Path(dir_okay=False))
+@click.command()
+def cli(yamlfile, gen_type_utils=False, include_induced_slots=False, output=None, **args):
     """Generate typescript interfaces and types
 
     See https://github.com/linkml/linkml-runtime.js
@@ -273,7 +280,7 @@ def cli(yamlfile, gen_type_utils=False, include_induced_slots=False, **args):
     gen = TypescriptGenerator(
         yamlfile, gen_type_utils=gen_type_utils, include_induced_slots=include_induced_slots, **args
     )
-    print(gen.serialize())
+    gen.serialize(output=output)
 
 
 if __name__ == "__main__":

linkml/linter/linter.py

@@ -8,6 +8,7 @@ from typing import Any, Dict, Iterable, Union
 import jsonschema
 import yaml
 from jsonschema.exceptions import best_match
+from jsonschema.protocols import Validator
 from linkml_runtime import SchemaView
 from linkml_runtime.dumpers import yaml_dumper
 from linkml_runtime.linkml_model import SchemaDefinition
@@ -35,7 +36,7 @@ def get_named_config(name: str) -> Dict[str, Any]:
 
 
 @lru_cache
-def get_metamodel_validator() -> jsonschema.Validator:
+def get_metamodel_validator() -> Validator:
     meta_json_gen = JsonSchemaGenerator(LOCAL_METAMODEL_YAML_FILE, not_closed=False)
     meta_json_schema = meta_json_gen.generate()
     validator_cls = jsonschema.validators.validator_for(meta_json_schema, default=jsonschema.Draft7Validator)

linkml/transformers/logical_model_transformer.py

@@ -360,13 +360,13 @@ class LogicalModelTransformer(ModelTransformer):
         target_schema = target_schemaview.schema
         for tn, typ in target_schema.types.items():
             ancs = sv.type_ancestors(tn, reflexive=False)
-            logging.debug(f"Unrolling type {tn}, merging {len(ancs)}")
+            logger.debug(f"Unrolling type {tn}, merging {len(ancs)}")
             if ancs:
                 for type_anc in ancs:
                     self._merge_type_ancestors(target=typ, source=sv.get_type(type_anc))
         for sn, slot in target_schema.slots.items():
             ancs = sv.slot_ancestors(sn, reflexive=False)
-            logging.debug(f"Unrolling slot {sn}, merging {len(ancs)}")
+            logger.debug(f"Unrolling slot {sn}, merging {len(ancs)}")
             if ancs:
                 for slot_anc in ancs:
                     self._merge_slot_ancestors(target=slot, source=target_schema.slots[slot_anc])
@@ -379,7 +379,7 @@ class LogicalModelTransformer(ModelTransformer):
                 depth_first=False,
             )
             ancs = list(reversed(ancs))
-            logging.debug(f"Unrolling class {cn}, merging {len(ancs)}")
+            logger.debug(f"Unrolling class {cn}, merging {len(ancs)}")
             self._roll_down(target_schema, cn, ancs)
         self.apply_defaults(target_schema)
         if simplify:

linkml/transformers/relmodel_transformer.py

@@ -12,9 +12,12 @@ from linkml_runtime.linkml_model import (
     SchemaDefinition,
     SlotDefinition,
 )
+from linkml_runtime.linkml_model.meta import UniqueKey
 from linkml_runtime.utils.schemaview import SchemaView, SlotDefinitionName
 from sqlalchemy import Enum
 
+logger = logging.getLogger(__name__)
+
 
 class RelationalAnnotations(Enum):
     PRIMARY_KEY = "primary_key"
@@ -215,11 +218,11 @@ 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}")
+                logger.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)
-                    logging.info(f"Added primary key {cn}.{pk.name}")
+                    logger.info(f"Added primary key {cn}.{pk.name}")
                 for link in links:
                     if link.target_class == cn:
                         link.target_slot = pk.name
@@ -233,7 +236,7 @@ class RelationalModelTransformer:
                 continue
             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}')
+            #    logger.info(f'Skipping class: {c.name}')
             #    del target.classes[cn]
             #    continue
             for src_slot in list(c.attributes.values()):
@@ -278,6 +281,17 @@ class RelationalModelTransformer:
                                 target_slot=backref_slot.name,
                             )
                         )
+                        backref_key_slots = [s for s in backref_class.attributes.values() if s.key]
+                        if backref_key_slots:
+                            if len(backref_key_slots) > 1:
+                                raise ValueError(f"Multiple keys for {c.name}: {backref_key_slots}")
+                            backref_key_slot = backref_key_slots[0]
+                            unique_key_name = f"{c.name}_{backref_key_slot.name}"
+                            backref_class.unique_keys[unique_key_name] = UniqueKey(
+                                unique_key_name=unique_key_name,
+                                unique_key_slots=[backref_slot.name, backref_key_slot.name],
+                            )
+
                     else:
                         # MANY-TO-MANY
                         # create new linking table
@@ -375,7 +389,7 @@ class RelationalModelTransformer:
             removed_ucs = []
             for uc_name, uc in c.unique_keys.items():
                 if any(sn in multivalued_slots_original for sn in uc.unique_key_slots):
-                    logging.warning(
+                    logger.warning(
                         f"Cannot represent uniqueness constraint {uc_name}. "
                         f"one of the slots {uc.unique_key_slots} is multivalued"
                     )

linkml/utils/converter.py

@@ -23,6 +23,8 @@ from linkml.utils.datautils import (
     infer_root_class,
 )
 
+logger = logging.getLogger(__name__)
+
 
 @click.command(name="convert")
 @click.option("--module", "-m", help="Path to python datamodel module")
@@ -119,7 +121,7 @@ def cli(
                 sv.set_modified()
     if target_class is None and target_class_from_path:
         target_class = os.path.basename(input).split("-")[0]
-        logging.info(f"inferred target class = {target_class} from {input}")
+        logger.info(f"inferred target class = {target_class} from {input}")
     if target_class is None:
         target_class = infer_root_class(sv)
     if target_class is None:

linkml/utils/exceptions.py

@@ -0,0 +1,11 @@
+"""
+Custom exceptions
+"""
+
+
+class SchemaError(ValueError):
+    """Base class for errors relating to schema specification, parsing, structure, etc."""
+
+
+class ValidationError(SchemaError):
+    """Schema is invalid!"""

linkml/utils/execute_tutorial.py

@@ -10,6 +10,8 @@ import click
 
 from linkml._version import __version__
 
+logger = logging.getLogger(__name__)
+
 re_decl = re.compile(r"^(\S+):$")
 re_start_yaml = re.compile(r"^```(\w+)$")
 re_end_yaml = re.compile(r"^```$")
@@ -46,17 +48,17 @@ def execute_blocks(directory: str, blocks: List[Block]) -> List[str]:
     :return: errors
     """
     Path(directory).mkdir(parents=True, exist_ok=True)
-    logging.info(f"Executing in: {directory}")
+    logger.info(f"Executing in: {directory}")
     last_block = None
     errs = []
 
     def err(e):
         errs.append(e)
-        logging.error(e)
+        logger.error(e)
 
     for block in blocks:
         write_lines(block.prior_lines)
-        logging.info(f"# Block: {block.category} {block.title}")
+        logger.info(f"# Block: {block.category} {block.title}")
         if block.is_file_block():
             path = PurePath(directory, block.title)
             with open(path, "w", encoding="UTF-8") as stream:
@@ -73,44 +75,44 @@ def execute_blocks(directory: str, blocks: List[Block]) -> List[str]:
                 if len(outpath) > 1:
                     raise Exception(f"Maximum 1 token after > in {block.content}. Got: {outpath}")
                 outpath = str(Path(directory, *outpath))
-                logging.info(f"OUTPATH = {outpath}")
+                logger.info(f"OUTPATH = {outpath}")
             else:
                 outpath = None
-            logging.info(f"Executing: {cmd}")
+            logger.info(f"Executing: {cmd}")
             r = subprocess.run(cmd, cwd=directory, capture_output=True)
             block.output = r.stdout.decode("utf-8")
             if outpath:
                 with open(outpath, "w", encoding="UTF-8") as stream:
-                    logging.info(f"WRITING {len(block.output)} TO = {outpath}")
+                    logger.info(f"WRITING {len(block.output)} TO = {outpath}")
                     stream.write(block.output)
             block.error = r.stderr.decode("utf-8")
-            logging.info(f"OUT [sample] = {block.output[0:30]}")
+            logger.info(f"OUT [sample] = {block.output[0:30]}")
             if block.expected_fail:
                 if r.returncode == 0:
                     err(f"Command unexpectedly succeeded: {cmd}")
                 else:
-                    logging.info("Failed as expected")
+                    logger.info("Failed as expected")
                 if block.error:
-                    logging.info(f"ERR [sample] = ...{block.error[-200:]}")
+                    logger.info(f"ERR [sample] = ...{block.error[-200:]}")
             else:
                 if block.error:
-                    logging.info(f"ERR = {block.error}")
+                    logger.info(f"ERR = {block.error}")
                 if r.returncode != 0:
                     err(f"Command failed: {cmd}")
                 else:
-                    logging.info("Success!")
+                    logger.info("Success!")
         elif block.is_stdout():
             if "compare_rdf" in block.annotations:
-                logging.warning("SKIPPING RDF COMPARISON. TODO: https://github.com/linkml/linkml/issues/427")
+                logger.warning("SKIPPING RDF COMPARISON. TODO: https://github.com/linkml/linkml/issues/427")
             elif last_block.output:
                 if last_block.output.strip() != block.content.strip():
                     err(f"Mismatch: {str(last_block.output)} != {block.content}")
                 else:
-                    logging.info("Hurray! Contents match!")
+                    logger.info("Hurray! Contents match!")
             else:
-                logging.info("No comparison performed")
+                logger.info("No comparison performed")
         else:
-            logging.warning(f"Ignoring block: {block}")
+            logger.warning(f"Ignoring block: {block}")
         last_block = block
     return errs
 
@@ -201,20 +203,20 @@ def cli(inputs, directory):
     logging.basicConfig(level=logging.INFO)
     errs = []
     for input in inputs:
-        logging.info(f"INPUT={input}")
+        logger.info(f"INPUT={input}")
         blocks = parse_file_to_blocks(input)
         print(f"## {len(blocks)} Blocks")
         localdir = Path(input).stem
         subdir = PurePath(directory, localdir)
         input_errs = execute_blocks(str(subdir), blocks)
         if len(input_errs) > 0:
-            logging.error(f"TUTORIAL {input} FAILURES: {len(input_errs)}")
+            logger.error(f"TUTORIAL {input} FAILURES: {len(input_errs)}")
         errs += input_errs
-    logging.info(f"Errors = {len(errs)}")
+    logger.info(f"Errors = {len(errs)}")
     if len(errs) > 0:
-        logging.error(f"Encountered {len(errs)} Errors")
+        logger.error(f"Encountered {len(errs)} Errors")
         for err in errs:
-            logging.error(f"Error: {err}")
+            logger.error(f"Error: {err}")
         sys.exit(1)
 
 

linkml/utils/generator.py

@@ -54,6 +54,8 @@ from linkml.utils.mergeutils import alias_root
 from linkml.utils.schemaloader import SchemaLoader
 from linkml.utils.typereferences import References
 
+logger = logging.getLogger(__name__)
+
 
 @lru_cache
 def _resolved_metamodel(mergeimports):
@@ -61,7 +63,7 @@ def _resolved_metamodel(mergeimports):
         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}")
+    logger.debug(f"BASE={base_dir}")
     metamodel = SchemaLoader(
         LOCAL_METAMODEL_YAML_FILE,
         importmap={"linkml": base_dir},
@@ -179,7 +181,7 @@ class Generator(metaclass=abc.ABCMeta):
 
     def __post_init__(self) -> None:
         if not self.logger:
-            self.logger = logging.getLogger()
+            self.logger = logger
         if self.log_level is not None:
             self.logger.setLevel(self.log_level)
         if self.format is None:
@@ -203,7 +205,7 @@ class Generator(metaclass=abc.ABCMeta):
         if self.uses_schemaloader:
             self._initialize_using_schemaloader(schema)
         else:
-            logging.info(f"Using SchemaView with im={self.importmap} // base_dir={self.base_dir}")
+            self.logger.info(f"Using SchemaView with im={self.importmap} // base_dir={self.base_dir}")
             self.schemaview = SchemaView(schema, importmap=self.importmap, base_dir=self.base_dir)
             if self.include:
                 if isinstance(self.include, (str, Path)):
@@ -840,7 +842,7 @@ class Generator(metaclass=abc.ABCMeta):
             if ":" not in mapping or len(mapping.split(":")) != 2:
                 raise ValueError(f"Definition {defn.name} - unrecognized mapping: {mapping}")
             ns = mapping.split(":")[0]
-            logging.debug(f"Adding {ns} from {mapping} // {defn}")
+            self.logger.debug(f"Adding {ns} from {mapping} // {defn}")
             if ns:
                 self.add_prefix(ns)
 

linkml/utils/mergeutils.py

@@ -18,6 +18,8 @@ from linkml_runtime.utils.namespaces import Namespaces
 from linkml_runtime.utils.yamlutils import extended_str
 from rdflib import URIRef
 
+logger = logging.getLogger(__name__)
+
 
 def merge_schemas(
     target: SchemaDefinition,
@@ -72,7 +74,7 @@ def merge_namespaces(target: SchemaDefinition, mergee: SchemaDefinition, namespa
             # We cannot resolve this to an absolute path, so we have to assume that
             # this prefix is already defined correctly in the target
             if prefix.prefix_prefix not in namespaces:
-                logging.info(
+                logger.info(
                     "Adding an unadjusted relative prefix for %s from %s, "
                     + "as the prefix is not yet defined, even as we cannot adjust it relative to the final file. "
                     + "If it cannot be resolved, add the prefix definition to the input schema!",
@@ -85,7 +87,7 @@ def merge_namespaces(target: SchemaDefinition, mergee: SchemaDefinition, namespa
                     prefix.prefix_prefix in target.prefixes
                     and target.prefixes[prefix.prefix_prefix].prefix_reference != prefix.prefix_reference
                 ):
-                    logging.info(
+                    logger.info(
                         "Ignoring different relative prefix for %s from %s, "
                         + "as we cannot adjust it relative to the final file. "
                         + "Assuming the first found location is correct: %s!",

linkml/utils/schema_fixer.py

@@ -94,7 +94,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("Forcing addition of containers")
+                logger.info("Forcing addition of containers")
             else:
                 raise ValueError(f"Schema already has containers: {tree_roots}")
         container = ClassDefinition(class_name, tree_root=True)
@@ -228,7 +228,7 @@ class SchemaFixer:
             # slots within that are redundant
             slot_usage_keys = list(cls.slot_usage.keys())
             for slot_usage_key in slot_usage_keys:
-                logging.debug(f"TESTING: {class_name}.{slot_usage_key}")
+                logger.debug(f"TESTING: {class_name}.{slot_usage_key}")
                 slot_usage_value = cls.slot_usage[slot_usage_key]
                 # perform a deletion test: what can be retrieved by inference
                 del cls.slot_usage[slot_usage_key]
@@ -236,7 +236,7 @@ class SchemaFixer:
                 try:
                     induced_slot = sv.induced_slot(slot_usage_key, class_name)
                 except ValueError:
-                    logging.warning(f"slot_usage with no slot: {slot_usage_key}")
+                    logger.warning(f"slot_usage with no slot: {slot_usage_key}")
                     continue
                 # restore value
                 cls.slot_usage[slot_usage_key] = slot_usage_value
@@ -258,7 +258,7 @@ class SchemaFixer:
                         continue
                     induced_v = getattr(induced_slot, metaslot_name, None)
                     if v is not None and v != [] and v != {} and v == induced_v:
-                        logging.info(f"REDUNDANT: {class_name}.{slot_usage_key}[{metaslot_name}] = {v}")
+                        logger.info(f"REDUNDANT: {class_name}.{slot_usage_key}[{metaslot_name}] = {v}")
                         to_delete.append(metaslot_name)
                 for metaslot_name in to_delete:
                     del slot_usage_value[metaslot_name]
@@ -302,7 +302,7 @@ class SchemaFixer:
                 if len(vals_strs) == 1:
                     harmonized_slot[k] = vals.pop()
                 elif len(vals_strs) > 1:
-                    logging.info(f"Variable values in {slot_name}.{k}: {vals_strs}")
+                    logger.info(f"Variable values in {slot_name}.{k}: {vals_strs}")
             new_slots[str(slot_name)] = harmonized_slot
         return new_slots
 

linkml/utils/schemaloader.py

@@ -29,6 +29,8 @@ from linkml.utils.mergeutils import merge_classes, merge_schemas, merge_slots, s
 from linkml.utils.rawloader import load_raw_schema
 from linkml.utils.schemasynopsis import SchemaSynopsis
 
+lgr = logging.getLogger(__name__)
+
 
 class SchemaLoader:
     def __init__(
@@ -57,7 +59,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 lgr
         if isinstance(data, SchemaDefinition):
             self.schema = data
         else:
@@ -176,7 +178,7 @@ class SchemaLoader:
                     # mangled names are overwritten if a schema with attributes is passed in
                     # TODO: handle this in a more graceful way
                     #  see https://github.com/linkml/linkml/issues/872
-                    logging.warning(
+                    self.logger.warning(
                         f'Class: "{cls.name}" attribute "{attribute.name}" - '
                         f"mangled name: {mangled_slot_name} already exists",
                     )
@@ -770,7 +772,7 @@ class SchemaLoader:
             if slotname in self.schema.slots:
                 base_slot = self.schema.slots[slotname]
             else:
-                logging.error(f"slot_usage for undefined slot: {slotname}")
+                self.logger.error(f"slot_usage for undefined slot: {slotname}")
                 base_slot = None
             parent_slot = self.schema.slots.get(slot_usage.is_a)
             # Follow the ancestry of the class to get the most proximal parent

linkml/utils/sqlutils.py

@@ -40,6 +40,8 @@ from linkml.utils.datautils import (
     infer_root_class,
 )
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class SQLStore:
@@ -376,7 +378,7 @@ def dump(
 
         inputs = [item for input in inputs for item in glob.glob(input)]
     for input in inputs:
-        logging.info(f"Loading: {input}")
+        logger.info(f"Loading: {input}")
         input_format = _get_format(input, input_format)
         loader = get_loader(input_format)