linkml 1.8.2__py3-none-any.whl → 1.8.4__py3-none-any.whl

linkml/generators/pythongen.py

@@ -29,8 +29,10 @@ from rdflib import URIRef
 
 import linkml
 from linkml._version import __version__
+from linkml.generators.python.python_ifabsent_processor import PythonIfAbsentProcessor
 from linkml.utils.generator import Generator, shared_arguments
-from linkml.utils.ifabsent_functions import ifabsent_postinit_declaration, ifabsent_value_declaration
+
+logger = logging.getLogger(__name__)
 
 
 @dataclass
@@ -57,10 +59,10 @@ class PythonGenerator(Generator):
     dataclass_repr: bool = False
     """
     Whether generated dataclasses should also generate a default __repr__ method.
-    
+
     Default ``False`` so that the parent :class:`linkml_runtime.utils.yamlutils.YAMLRoot` 's
     ``__repr__`` method is inherited for model pretty printing.
-    
+
     References:
         - https://docs.python.org/3/library/dataclasses.html#dataclasses.dataclass
     """
@@ -70,11 +72,12 @@ class PythonGenerator(Generator):
             self.schema = str(self.schema)
         self.sourcefile = self.schema
         self.schemaview = SchemaView(self.schema, base_dir=self.base_dir)
+        self.ifabsent_processor = PythonIfAbsentProcessor(self.schemaview)
         super().__post_init__()
         if self.format is None:
             self.format = self.valid_formats[0]
         if self.schema.default_prefix == "linkml" and not self.genmeta:
-            logging.error("Generating metamodel without --genmeta is highly inadvisable!")
+            logger.error("Generating metamodel without --genmeta is highly inadvisable!")
         if not self.schema.source_file and isinstance(self.sourcefile, str) and "\n" not in self.sourcefile:
             self.schema.source_file = os.path.basename(self.sourcefile)
 
@@ -87,8 +90,8 @@ class PythonGenerator(Generator):
         try:
             return compile_python(pycode)
         except NameError as e:
-            logging.error(f"Code:\n{pycode}")
-            logging.error(f"Error compiling generated python code: {e}")
+            logger.error(f"Code:\n{pycode}")
+            logger.error(f"Error compiling generated python code: {e}")
             raise e
 
     def visit_schema(self, **kwargs) -> None:
@@ -153,7 +156,7 @@ import re
 from jsonasobj2 import JsonObj, as_dict
 from typing import Optional, List, Union, Dict, ClassVar, Any
 from dataclasses import dataclass
-from datetime import date, datetime
+from datetime import date, datetime, time
 {enumimports}
 from linkml_runtime.utils.slot import Slot
 from linkml_runtime.utils.metamodelcore import empty_list, empty_dict, bnode
@@ -515,7 +518,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
 
         return "\n\t".join(initializers)
 
-    def gen_class_variable(self, cls: ClassDefinition, slot: SlotDefinition, can_be_positional: bool) -> str:
+    def gen_class_variable(self, cls: ClassDefinition, slot: SlotDefinition, can_be_positional: bool = False) -> str:
         """
         Generate a class variable declaration for the supplied slot.  Note: the can_be_positional attribute works,
         but it makes tag/value lists unduly complex, as you can't load them with tag=..., value=... -- you HAVE
@@ -527,12 +530,9 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
         :param can_be_positional: True means that positional parameters are allowed.
         :return: Initializer string
         """
-        can_be_positional = False  # Force everything to be tag values
         slotname = self.slot_name(slot.name)
         slot_range, default_val = self.range_cardinality(slot, cls, can_be_positional)
-        ifabsent_text = (
-            ifabsent_value_declaration(slot.ifabsent, self, cls, slot) if slot.ifabsent is not None else None
-        )
+        ifabsent_text = self.ifabsent_processor.process_slot(slot, cls) if slot.ifabsent is not None else None
         if ifabsent_text is not None:
             default = f"= {ifabsent_text}"
         else:
@@ -637,15 +637,6 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
 
     def gen_postinits(self, cls: ClassDefinition) -> str:
         """Generate all the typing and existence checks post initialize"""
-        post_inits_pre_super = []
-        for slot in self.domain_slots(cls):
-            if slot.ifabsent:
-                dflt = ifabsent_postinit_declaration(slot.ifabsent, self, cls, slot)
-
-                if dflt and dflt != "None":
-                    post_inits_pre_super.append(f"if self.{self.slot_name(slot.name)} is None:")
-                    post_inits_pre_super.append(f"\tself.{self.slot_name(slot.name)} = {dflt}")
-
         post_inits = []
         if not (cls.mixin or cls.abstract):
             pkeys = self.primary_keys_for(cls)
@@ -676,20 +667,17 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
             if slot.name not in domain_slot_names and slot.designates_type:
                 post_inits_designators.append(self.gen_postinit(cls, slot))
 
-        post_inits_pre_super_line = "\n\t\t".join([p for p in post_inits_pre_super if p]) + (
-            "\n\t\t" if post_inits_pre_super else ""
-        )
         post_inits_post_super_line = "\n\t\t".join(post_inits_designators)
         post_inits_line = "\n\t\t".join([p for p in post_inits if p])
         return (
             (
                 f"""
     def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
-        {post_inits_pre_super_line}{post_inits_line}
+        {post_inits_line}
         super().__post_init__(**kwargs)
         {post_inits_post_super_line}"""
             )
-            if post_inits_line or post_inits_pre_super_line or post_inits_post_super_line
+            if post_inits_line or post_inits_post_super_line
             else ""
         )
 
@@ -958,11 +946,11 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
 
     def forward_reference(self, slot_range: str, owning_class: str) -> bool:
         """Determine whether slot_range is a forward reference"""
-        # logging.info(f"CHECKING: {slot_range} {owning_class}")
+        # logger.info(f"CHECKING: {slot_range} {owning_class}")
         if (slot_range in self.schema.classes and self.schema.classes[slot_range].imported_from) or (
             slot_range in self.schema.enums and self.schema.enums[slot_range].imported_from
         ):
-            logging.info(
+            logger.info(
                 f"FALSE: FORWARD: {slot_range} {owning_class} // IMP={self.schema.classes[slot_range].imported_from}"
             )
             return False
@@ -971,10 +959,10 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
         clist = [x.name for x in self._sort_classes(self.schema.classes.values())]
         for cname in clist:
             if cname == owning_class:
-                logging.info(f"TRUE: OCCURS SAME: {cname} == {slot_range} owning: {owning_class}")
+                logger.info(f"TRUE: OCCURS SAME: {cname} == {slot_range} owning: {owning_class}")
                 return True  # Occurs on or after
             elif cname == slot_range:
-                logging.info(f"FALSE: OCCURS BEFORE: {cname} == {slot_range} owning: {owning_class}")
+                logger.info(f"FALSE: OCCURS BEFORE: {cname} == {slot_range} owning: {owning_class}")
                 return False  # Occurs before
         return True
 
@@ -1228,7 +1216,7 @@ def cli(
     )
     if validate:
         mod = gen.compile_module()
-        logging.info(f"Module {mod} compiled successfully")
+        logger.info(f"Module {mod} compiled successfully")
     print(gen.serialize(emit_metadata=head, **args))
 
 

linkml/generators/shacl/__init__.py

@@ -1,3 +1 @@
-from linkml.generators.shacl import ifabsent_processor
-
-__all__ = ["shacl_data_type", "ifabsent_processor"]
+__all__ = ["shacl_data_type", "shacl_ifabsent_processor"]

linkml/generators/shacl/shacl_data_type.py

@@ -20,7 +20,7 @@ class ShaclDataType(DataType, Enum):
     FLOAT = ("float", URIRef("http://www.w3.org/2001/XMLSchema#float"))
     DOUBLE = ("double", URIRef("http://www.w3.org/2001/XMLSchema#double"))
     URI = ("uri", URIRef("http://www.w3.org/2001/XMLSchema#anyURI"))
-    CURI = ("curi", URIRef("http://www.w3.org/2001/XMLSchema#string"))
+    CURIE = ("curi", URIRef("http://www.w3.org/2001/XMLSchema#string"))
     NCNAME = ("ncname", URIRef("http://www.w3.org/2001/XMLSchema#string"))
     OBJECT_IDENTIFIER = ("objectidentifier", URIRef("http://www.w3.org/ns/shex#iri"))
     NODE_IDENTIFIER = ("nodeidentifier", URIRef("http://www.w3.org/ns/shex#nonLiteral"))

linkml/generators/shacl/shacl_ifabsent_processor.py

@@ -0,0 +1,89 @@
+from linkml_runtime.linkml_model import ClassDefinition, EnumDefinitionName, SlotDefinition
+from rdflib import Literal, URIRef
+
+from linkml.generators.common.ifabsent_processor import IfAbsentProcessor
+from linkml.generators.shacl.shacl_data_type import ShaclDataType
+
+
+class ShaclIfAbsentProcessor(IfAbsentProcessor):
+
+    def map_custom_default_values(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition) -> (bool, str):
+        if default_value == "class_curie":
+            class_uri = self.schema_view.get_uri(cls, expand=True)
+            if class_uri:
+                return True, URIRef(class_uri)
+            return True, ""
+
+        return False, None
+
+    def map_enum_default_value(
+        self, enum_name: EnumDefinitionName, permissible_value_name: str, slot: SlotDefinition, cls: ClassDefinition
+    ):
+        return Literal(permissible_value_name)
+
+    def map_string_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(default_value, datatype=ShaclDataType.STRING.uri_ref)
+
+    def map_integer_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(default_value, datatype=ShaclDataType.INTEGER.uri_ref)
+
+    def map_boolean_true_default_value(self, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(True, datatype=ShaclDataType.BOOLEAN.uri_ref)
+
+    def map_boolean_false_default_value(self, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(False, datatype=ShaclDataType.BOOLEAN.uri_ref)
+
+    def map_float_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(default_value, datatype=ShaclDataType.FLOAT.uri_ref)
+
+    def map_double_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(default_value, datatype=ShaclDataType.DOUBLE.uri_ref)
+
+    def map_decimal_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(default_value, datatype=ShaclDataType.DECIMAL.uri_ref)
+
+    def map_time_default_value(self, hour: str, minutes: str, seconds: str, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(f"{hour}:{minutes}:{seconds}", datatype=ShaclDataType.TIME.uri_ref)
+
+    def map_date_default_value(self, year: str, month: str, day: str, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(f"{year}-{month}-{day}", datatype=ShaclDataType.DATE.uri_ref)
+
+    def map_datetime_default_value(
+        self,
+        year: str,
+        month: str,
+        day: str,
+        hour: str,
+        minutes: str,
+        seconds: str,
+        slot: SlotDefinition,
+        cls: ClassDefinition,
+    ):
+        return Literal(f"{year}-{month}-{day}T{hour}:{minutes}:{seconds}", datatype=ShaclDataType.DATETIME.uri_ref)
+
+    def map_uri_or_curie_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_curie_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(default_value, datatype=ShaclDataType.CURIE.uri_ref)
+
+    def map_uri_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(default_value, datatype=ShaclDataType.URI.uri_ref)
+
+    def map_nc_name_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_object_identifier_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_node_identifier_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_json_pointer_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_json_path_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_sparql_path_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()

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.ifabsent_processor import IfAbsentProcessor
 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):
@@ -56,7 +58,7 @@ class ShaclGenerator(Generator):
         g = Graph()
         g.bind("sh", SH)
 
-        ifabsent_processor = IfAbsentProcessor(sv)
+        ifabsent_processor = ShaclIfAbsentProcessor(sv)
 
         for pfx in self.schema.prefixes.values():
             g.bind(str(pfx.prefix_prefix), pfx.prefix_reference)
@@ -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)
@@ -208,7 +207,9 @@ class ShaclGenerator(Generator):
                         # Map equal_string and equal_string_in to sh:in
                         self._and_equals_string(g, prop_pv, s.equals_string_in)
 
-                ifabsent_processor.process_slot(prop_pv, s, class_uri)
+                default_value = ifabsent_processor.process_slot(s, c)
+                if default_value:
+                    prop_pv(SH.defaultValue, default_value)
 
         return g
 
@@ -242,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()
@@ -299,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!"""