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

linkml/generators/shexgen.py

@@ -3,23 +3,25 @@
 """
 import os
 from dataclasses import dataclass, field
-from typing import List, Optional, TextIO, Union
+from typing import List, Optional, Union
 
 import click
 from jsonasobj import as_json as as_json_1
-from linkml_runtime.linkml_model.meta import (ClassDefinition, ElementName,
-                                              EnumDefinition, SchemaDefinition,
-                                              SlotDefinition,
-                                              SlotDefinitionName,
-                                              TypeDefinition)
+from linkml_runtime.linkml_model.meta import (
+    ClassDefinition,
+    ElementName,
+    EnumDefinition,
+    SlotDefinition,
+    SlotDefinitionName,
+    TypeDefinition,
+)
 from linkml_runtime.linkml_model.types import SHEX
 from linkml_runtime.utils.formatutils import camelcase, sfx
 from linkml_runtime.utils.metamodelcore import URIorCURIE
 from rdflib import OWL, RDF, XSD, Graph, Namespace
 from ShExJSG import ShExC
 from ShExJSG.SchemaWithContext import Schema
-from ShExJSG.ShExJ import (IRIREF, EachOf, NodeConstraint, Shape, ShapeOr,
-                           TripleConstraint)
+from ShExJSG.ShExJ import IRIREF, EachOf, NodeConstraint, Shape, ShapeOr, TripleConstraint
 
 from linkml import METAMODEL_NAMESPACE, METAMODEL_NAMESPACE_NAME
 from linkml._version import __version__
@@ -32,6 +34,7 @@ class ShExGenerator(Generator):
     generatorname = os.path.basename(__file__)
     generatorversion = "0.0.2"
     valid_formats = ["shex", "json", "rdf"]
+    file_extension = "shex.rdf"
     visit_all_class_slots = False
     uses_schemaloader = True
 
@@ -39,7 +42,9 @@ class ShExGenerator(Generator):
     shex: Schema = field(default_factory=lambda: Schema())  # ShEx Schema being generated
     shapes: List = field(default_factory=lambda: [])
     shape: Optional[Shape] = None  # Current shape being defined
-    list_shapes: List[IRIREF] = field(default_factory=lambda: [])  # Shapes that have been defined as lists
+    list_shapes: List[IRIREF] = field(
+        default_factory=lambda: []
+    )  # Shapes that have been defined as lists
 
     def __post_init__(self):
         super().__post_init__()
@@ -71,14 +76,10 @@ class ShExGenerator(Generator):
                 if typ_type_uri in (XSD.anyURI, SHEX.iri):
                     self.shapes.append(NodeConstraint(id=model_uri, nodeKind="iri"))
                 elif typ_type_uri == SHEX.nonLiteral:
-                    self.shapes.append(
-                        NodeConstraint(id=model_uri, nodeKind="nonliteral")
-                    )
+                    self.shapes.append(NodeConstraint(id=model_uri, nodeKind="nonliteral"))
                 else:
                     self.shapes.append(
-                        NodeConstraint(
-                            id=model_uri, datatype=self.namespaces.uri_for(typ.uri)
-                        )
+                        NodeConstraint(id=model_uri, datatype=self.namespaces.uri_for(typ.uri))
                     )
             else:
                 typeof_uri = self._class_or_type_uri(typ.typeof)
@@ -95,9 +96,7 @@ class ShExGenerator(Generator):
                 struct_ref_list.append(applier)
         for sr in struct_ref_list:
             self._add_constraint(self._class_or_type_uri(sr, "_tes"))
-            self._add_constraint(
-                self._type_arc(self.schema.classes[sr].class_uri, opt=True)
-            )
+            self._add_constraint(self._type_arc(self.schema.classes[sr].class_uri, opt=True))
         return True
 
     def end_class(self, cls: ClassDefinition) -> None:
@@ -121,9 +120,7 @@ class ShExGenerator(Generator):
         # If this class has subtypes, define the class as the union of its subtypes and itself (if not abstract)
         if cls.name in self.synopsis.isarefs:
             childrenExprs = []
-            for child_classname in sorted(
-                list(self.synopsis.isarefs[cls.name].classrefs)
-            ):
+            for child_classname in sorted(list(self.synopsis.isarefs[cls.name].classrefs)):
                 childrenExprs.append(self._class_or_type_uri(child_classname))
             if not (cls.mixin or cls.abstract) or len(childrenExprs) == 1:
                 childrenExprs.insert(0, self.shape)
@@ -203,9 +200,7 @@ class ShExGenerator(Generator):
             self.shape.expression = constraint
         # One constraint
         elif not isinstance(self.shape.expression, EachOf):
-            self.shape.expression = EachOf(
-                expressions=[self.shape.expression, constraint]
-            )
+            self.shape.expression = EachOf(expressions=[self.shape.expression, constraint])
         # Two or more constraints
         else:
             self.shape.expression.expressions.append(constraint)

linkml/generators/sparqlgen.py

@@ -3,18 +3,12 @@ import os
 from collections import defaultdict
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Dict, List, Optional, TextIO, Union, cast
+from typing import Dict, List, Optional
 
 import click
 from jinja2 import Template
-from linkml_runtime.linkml_model.meta import (ClassDefinition,
-                                              ClassDefinitionName, Element,
-                                              EnumDefinitionName, Prefix,
-                                              SchemaDefinition, SlotDefinition,
-                                              SlotDefinitionName,
-                                              TypeDefinition,
-                                              TypeDefinitionName)
-from linkml_runtime.utils.formatutils import camelcase, underscore
+from linkml_runtime.linkml_model.meta import Prefix
+from linkml_runtime.utils.formatutils import underscore
 from linkml_runtime.utils.schemaview import SchemaView
 
 from linkml._version import __version__
@@ -109,9 +103,7 @@ x = """
 def materialize_schema(schemaview: SchemaView):
     schema = schemaview.schema
     if "rdf" not in schema.prefixes:
-        schema.prefixes["rdf"] = Prefix(
-            "rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-        )
+        schema.prefixes["rdf"] = Prefix("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#")
     for scn in schemaview.imports_closure():
         for pfxn, pfx in schemaview.schema_map[scn].prefixes.items():
             if pfxn not in schema:
@@ -203,7 +195,7 @@ class SparqlGenerator(Generator):
 def cli(yamlfile, dir, **kwargs):
     """Generate SPARQL queries for validation
 
-    This will generate a directory of queries that cann be used for QC over a triplestore that
+    This will generate a directory of queries that can be used for QC over a triplestore that
     is conformant to the same LinkML schema.
 
     Each query in the directory will be of the form

linkml/generators/sqlalchemy/__init__.py

@@ -1,3 +1,4 @@
-from .sqlalchemy_declarative_template import \
-    sqlalchemy_declarative_template_str
+from .sqlalchemy_declarative_template import sqlalchemy_declarative_template_str
 from .sqlalchemy_imperative_template import sqlalchemy_imperative_template_str
+
+__all__ = ["sqlalchemy_declarative_template_str", "sqlalchemy_imperative_template_str"]

linkml/generators/sqlalchemy/sqlalchemy_declarative_template.py

@@ -14,7 +14,7 @@ class {{classname(c.name)}}({% if c.is_a %}{{ classname(c.is_a) }}{% else %}Base
     {% if c.description %}{{c.description}}{% else %}{{c.alias}}{% endif %}
     \"\"\"
     __tablename__ = '{{c.name}}'
-    
+
     {% for s in c.attributes.values() -%}
     {{s.alias}} = Column({{s.annotations['sql_type'].value}}
            {%- if 'foreign_key' in s.annotations -%}, ForeignKey('{{ s.annotations['foreign_key'].value }}') {%- endif -%}
@@ -26,7 +26,7 @@ class {{classname(c.name)}}({% if c.is_a %}{{ classname(c.is_a) }}{% else %}Base
     {{s.annotations['original_slot'].value}} = relationship("{{classname(s.range)}}", uselist=False, foreign_keys=[{{s.alias}}])
     {% endif -%}
     {% endfor %}
-    
+
     {%- for mapping in backrefs[c.name] %}
     {% if mapping.mapping_type == "ManyToMany" %}
     # ManyToMany
@@ -40,15 +40,15 @@ class {{classname(c.name)}}({% if c.is_a %}{{ classname(c.is_a) }}{% else %}Base
     {{mapping.source_slot}} = relationship( "{{ classname(mapping.target_class) }}", foreign_keys="[{{ mapping.target_class }}.{{mapping.target_slot}}]")
     {% endif -%}
     {%- endfor %}
-    
+
     def __repr__(self):
         return f"{{c.name}}(
         {%- for s in c.attributes.values() -%}
-        {{s.alias}}={self.{{s.alias}}}, 
+        {{s.alias}}={self.{{s.alias}}},
         {%- endfor %})"
-        
-    
-        
+
+
+
     {% if c.is_a or c.mixins %}
     # Using concrete inheritance: see https://docs.sqlalchemy.org/en/14/orm/inheritance.html
     __mapper_args__ = {

linkml/generators/sqlalchemy/sqlalchemy_imperative_template.py

@@ -27,10 +27,10 @@ tbl_{{classname(c.name)}} = Table('{{c.name}}', metadata,
     Column('{{s.name}}',
           Text,
           {% if 'foreign_key' in s.annotations -%}
-            ForeignKey('{{ s.annotations['foreign_key'].value }}'), 
+            ForeignKey('{{ s.annotations['foreign_key'].value }}'),
           {% endif -%}
-          {% if 'primary_key' in s.annotations -%} 
-            primary_key=True 
+          {% if 'primary_key' in s.annotations -%}
+            primary_key=True
           {%- endif -%}
           ),
     {%- endfor %}

linkml/generators/sqlalchemygen.py

@@ -3,26 +3,30 @@ import os
 from collections import defaultdict
 from dataclasses import dataclass
 from types import ModuleType
-from typing import Dict, List, TextIO, Union
+from typing import List, Union
 
 import click
 from jinja2 import Template
-from linkml_runtime.linkml_model import (Annotation, ClassDefinition,
-                                         ClassDefinitionName, Prefix,
-                                         SchemaDefinition)
+from linkml_runtime.linkml_model import (
+    Annotation,
+    ClassDefinition,
+    ClassDefinitionName,
+    SchemaDefinition,
+)
 from linkml_runtime.utils.compile_python import compile_python
 from linkml_runtime.utils.formatutils import camelcase, underscore
 from linkml_runtime.utils.schemaview import SchemaView
-from sqlalchemy import *
+from sqlalchemy import Enum
 
 from linkml._version import __version__
 from linkml.generators.pydanticgen import PydanticGenerator
 from linkml.generators.pythongen import PythonGenerator
-from linkml.generators.sqlalchemy import (sqlalchemy_declarative_template_str,
-                                          sqlalchemy_imperative_template_str)
+from linkml.generators.sqlalchemy import (
+    sqlalchemy_declarative_template_str,
+    sqlalchemy_imperative_template_str,
+)
 from linkml.generators.sqltablegen import SQLTableGenerator
-from linkml.transformers.relmodel_transformer import (
-    ForeignKeyPolicy, RelationalModelTransformer)
+from linkml.transformers.relmodel_transformer import ForeignKeyPolicy, RelationalModelTransformer
 from linkml.utils.generator import Generator, shared_arguments
 
 
@@ -43,7 +47,9 @@ class SQLAlchemyGenerator(Generator):
     generatorname = os.path.basename(__file__)
     generatorversion = "0.1.1"
     valid_formats = ["sqla"]
+    file_extension = "py"
     uses_schemaloader = False
+    template: TemplateEnum = None
 
     # ObjectVars
     original_schema: Union[SchemaDefinition, str] = None
@@ -53,17 +59,20 @@ class SQLAlchemyGenerator(Generator):
         self.schemaview = SchemaView(self.schema)
         super().__post_init__()
 
-
     def generate_sqla(
         self,
         model_path: str = None,
         no_model_import=False,
-        template: TemplateEnum = TemplateEnum.IMPERATIVE,
+        template: TemplateEnum = None,
         foreign_key_policy: ForeignKeyPolicy = None,
         **kwargs,
     ) -> str:
         # src_sv = SchemaView(self.schema)
         # self.schema = src_sv.schema
+        if template is None:
+            template = self.template
+        if template is None:
+            template = TemplateEnum.IMPERATIVE
         sqltr = RelationalModelTransformer(self.schemaview)
         if foreign_key_policy:
             sqltr.foreign_key_policy = foreign_key_policy
@@ -90,7 +99,6 @@ class SQLAlchemyGenerator(Generator):
         backrefs = defaultdict(list)
         for m in tr_result.mappings:
             backrefs[m.source_class].append(m)
-        skip = {}
         # for c in tr_schema.classes.values():
         #    if len(c.attributes) == 0:
         #        skip[c.name] = True
@@ -98,18 +106,13 @@ class SQLAlchemyGenerator(Generator):
         self.add_safe_aliases(tr_schema)
         tr_sv = SchemaView(tr_schema)
         rel_schema_classes_ordered = [
-            tr_sv.get_class(cn, strict=True)
-            for cn in self.order_classes_by_hierarchy(tr_sv)
-        ]
-        rel_schema_classes_ordered = [
-            c for c in rel_schema_classes_ordered if not self.skip(c)
+            tr_sv.get_class(cn, strict=True) for cn in self.order_classes_by_hierarchy(tr_sv)
         ]
+        rel_schema_classes_ordered = [c for c in rel_schema_classes_ordered if not self.skip(c)]
         for c in rel_schema_classes_ordered:
             # For SQLA there needs to be a primary key for each class;
             # autogenerate this as a compound key if none declared
-            has_pk = any(
-                a for a in c.attributes.values() if "primary_key" in a.annotations
-            )
+            has_pk = any(a for a in c.attributes.values() if "primary_key" in a.annotations)
             if not has_pk:
                 for a in c.attributes.values():
                     ann = Annotation("primary_key", "true")
@@ -127,6 +130,9 @@ class SQLAlchemyGenerator(Generator):
         )
         return code
 
+    def serialize(self, **kwargs) -> str:
+        return self.generate_sqla(**kwargs)
+
     def compile_sqla(
         self,
         compile_python_dataclasses=False,
@@ -167,9 +173,7 @@ class SQLAlchemyGenerator(Generator):
             else:
                 pygen = PythonGenerator(self.original_schema)
             dc_code = pygen.serialize()
-            sqla_code = self.generate_sqla(
-                model_path=None, no_model_import=True, **kwargs
-            )
+            sqla_code = self.generate_sqla(model_path=None, no_model_import=True, **kwargs)
             return compile_python(f"{dc_code}\n{sqla_code}", package_path=model_path)
         else:
             code = self.generate_sqla(model_path=model_path, **kwargs)
@@ -231,9 +235,7 @@ class SQLAlchemyGenerator(Generator):
 )
 @click.version_option(__version__, "-V", "--version")
 @click.command()
-def cli(
-    yamlfile, declarative, generate_classes, pydantic, use_foreign_keys=True, **args
-):
+def cli(yamlfile, declarative, generate_classes, pydantic, use_foreign_keys=True, **args):
     """Generate SQL DDL representation"""
     if pydantic:
         pygen = PydanticGenerator(yamlfile)
@@ -249,7 +251,7 @@ def cli(
         foreign_key_policy = ForeignKeyPolicy.NO_FOREIGN_KEYS
     print(gen.generate_sqla(template=t, foreign_key_policy=foreign_key_policy))
     if generate_classes:
-        raise NotImplementedError(f"generate classes not implemented")
+        raise NotImplementedError("generate classes not implemented")
 
 
 if __name__ == "__main__":

linkml/generators/sqlddlgen.py

@@ -1,17 +1,34 @@
+"""DEPRECATED: Use SQLTableGenerator instead"""
 import logging
 import os
 from contextlib import redirect_stdout
 from dataclasses import dataclass, field
-from typing import Dict, List, Optional, TextIO, Tuple, Union
+from typing import Dict, List, Optional, TextIO, Union
 
 import click
 from deprecated.classic import deprecated
-from linkml_runtime.linkml_model.meta import (ClassDefinition,
-                                              ClassDefinitionName,
-                                              SchemaDefinition, SlotDefinition,
-                                              SlotDefinitionName)
+from linkml_runtime.linkml_model.meta import (
+    ClassDefinition,
+    ClassDefinitionName,
+    SchemaDefinition,
+    SlotDefinition,
+)
 from linkml_runtime.utils.formatutils import camelcase, underscore
-from sqlalchemy import *
+from sqlalchemy import (
+    Boolean,
+    Column,
+    Date,
+    DateTime,
+    Enum,
+    Float,
+    ForeignKey,
+    Integer,
+    MetaData,
+    Table,
+    Text,
+    Time,
+    create_mock_engine,
+)
 
 from linkml._version import __version__
 from linkml.utils.generator import Generator, shared_arguments
@@ -202,7 +219,7 @@ class SQLDDLGenerator(Generator):
     generatorversion = "0.1.1"
     valid_formats = ["sql"]
     visit_all_class_slots: bool = True
-    use_inherits: bool = False  ## postgresql supports inheritance
+    use_inherits: bool = False  # postgresql supports inheritance
     dialect: str
     inject_primary_keys: bool = True
     sqlschema: SQLSchema = SQLSchema()
@@ -248,7 +265,7 @@ class SQLDDLGenerator(Generator):
         if self._is_hidden(cls):
             return False
         if cls.description:
-            None  ## TODO
+            None  # TODO
         tname = self._class_name_to_table(cls.name)
         # add table
         self.sqlschema.tables[tname] = SQLTable(name=tname, mapped_to=cls)
@@ -261,7 +278,7 @@ class SQLDDLGenerator(Generator):
             # postgresql supports inheritance
             # if you want to use plain SQL DDL then use sqlutils to unfold hierarchy
             # TODO: raise error if the target is standard SQL
-            raise Exception(f"PostgreSQL Inheritance not yet supported")
+            raise Exception("PostgreSQL Inheritance not yet supported")
 
     def visit_class_slot(
         self, cls: ClassDefinition, aliased_slot_name: str, slot: SlotDefinition
@@ -320,17 +337,11 @@ class SQLDDLGenerator(Generator):
                     linktable_name = f"{table.name}_{sqlcol.name}"
                     backref_col_name = "backref_id"
                     linktable = SQLTable(name=linktable_name)
-                    linktable.add_column(
-                        SQLColumn(name=backref_col_name, foreign_key=table_pk)
-                    )
+                    linktable.add_column(SQLColumn(name=backref_col_name, foreign_key=table_pk))
                     linktable.add_column(sqlcol)
                     sqlschema.add_table(linktable)
                     table.remove_column(sqlcol)
-                if (
-                    not is_primitive
-                    and table_pk is not None
-                    and len(ref.referenced_by) == 1
-                ):
+                if not is_primitive and table_pk is not None and len(ref.referenced_by) == 1:
                     # e.g. user->addresses
                     backref_col_name = f"{table.name}_{table_pk.name}"
                     backref_col = SQLColumn(name=backref_col_name, foreign_key=table_pk)
@@ -392,12 +403,9 @@ class SQLDDLGenerator(Generator):
         def dump(sql, *multiparams, **params):
             print(f"{str(sql.compile(dialect=engine.dialect)).rstrip()};")
 
-        engine = create_mock_engine(
-            f"{self.dialect}://./MyDb", strategy="mock", executor=dump
-        )
+        engine = create_mock_engine(f"{self.dialect}://./MyDb", strategy="mock", executor=dump)
         schema_metadata = MetaData()
         for t in self.sqlschema.tables.values():
-            cls = t.mapped_to
             sqlcols = t.columns.values()
             if len(sqlcols) > 0:
                 cols = []
@@ -415,14 +423,14 @@ class SQLDDLGenerator(Generator):
                     )
 
                     cols.append(col)
-                alchemy_tbl = Table(t.name, schema_metadata, *cols)
+                Table(t.name, schema_metadata, *cols)
         print()
         schema_metadata.create_all(engine)
 
     def write_sqla_python_imperative(self, model_path: str) -> str:
         """
         imperative mapping:
-        https://docs.sqlalchemy.org/en/14/orm/mapping_styles.html#imperative-mapping-with-dataclasses-and-attrs
+        https://docs.sqlalchemy.org/en/14/orm/dataclasses.html#mapping-dataclasses-using-imperative-mapping
 
         maps to the python classes generated using PythonGenerator
 
@@ -491,8 +499,8 @@ from {model_path} import *
                     backref_slot_range = camelcase(backref_slot.range)
                     print(
                         f"""
-    '{underscore(original_col.mapped_to_alias)}': 
-        relationship({backref_slot_range}, 
+    '{underscore(original_col.mapped_to_alias)}':
+        relationship({backref_slot_range},
                       foreign_keys={backref.backref_column.table.as_var()}.columns["{backref.backref_column.name}"],
                       backref='{cn}'),
 """
@@ -527,7 +535,7 @@ Python import header for generated sql-alchemy code
     default=False,
     show_default=True,
     help="""
-Map classes directly to 
+Map classes directly to
 """,
 )
 @click.option(

linkml/generators/sqltablegen.py

@@ -1,22 +1,18 @@
 import logging
 import os
 from dataclasses import dataclass, field
-from typing import Dict, List, Optional, TextIO, Union
+from typing import Optional
 
 import click
 from linkml_runtime.dumpers import yaml_dumper
-from linkml_runtime.linkml_model import (ClassDefinition, SchemaDefinition,
-                                         SlotDefinition)
+from linkml_runtime.linkml_model import SchemaDefinition, SlotDefinition
 from linkml_runtime.utils.formatutils import camelcase, underscore
 from linkml_runtime.utils.schemaview import SchemaView
-from sqlalchemy import Column, ForeignKey, MetaData, Table, create_mock_engine
-from sqlalchemy.types import (Boolean, Date, DateTime, Enum, Float, Integer,
-                              Text, Time)
+from sqlalchemy import Column, ForeignKey, MetaData, Table, UniqueConstraint, create_mock_engine
+from sqlalchemy.types import Boolean, Date, DateTime, Enum, Float, Integer, Text, Time
 
 from linkml._version import __version__
-from linkml.generators.yamlgen import YAMLGenerator
-from linkml.transformers.relmodel_transformer import (
-    ForeignKeyPolicy, RelationalModelTransformer)
+from linkml.transformers.relmodel_transformer import ForeignKeyPolicy, RelationalModelTransformer
 from linkml.utils.generator import Generator, shared_arguments
 from linkml.utils.schemaloader import SchemaLoader
 
@@ -122,10 +118,11 @@ class SQLTableGenerator(Generator):
     generatorname = os.path.basename(__file__)
     generatorversion = "0.1.1"
     valid_formats = ["sql"]
+    file_extension = "sql"
     uses_schemaloader = False
 
     # ObjectVars
-    use_inherits: bool = False  ## postgresql supports inheritance
+    use_inherits: bool = False  # postgresql supports inheritance
     dialect: str = field(default_factory=lambda: "sqlite")
     inject_primary_keys: bool = field(default_factory=lambda: True)
     use_foreign_keys: bool = field(default_factory=lambda: True)
@@ -133,6 +130,9 @@ class SQLTableGenerator(Generator):
     direct_mapping: bool = field(default_factory=lambda: False)
     relative_slot_num: bool = field(default_factory=lambda: 0)
 
+    def serialize(self, **kwargs) -> str:
+        return self.generate_ddl(**kwargs)
+
     def generate_ddl(self, naming_policy: SqlNamingPolicy = None, **kwargs) -> str:
         ddl_str = ""
 
@@ -140,9 +140,7 @@ class SQLTableGenerator(Generator):
             nonlocal ddl_str
             ddl_str += f"{str(sql.compile(dialect=engine.dialect)).rstrip()};"
 
-        engine = create_mock_engine(
-            f"{self.dialect}://./MyDb", strategy="mock", executor=dump
-        )
+        engine = create_mock_engine(f"{self.dialect}://./MyDb", strategy="mock", executor=dump)
         schema_metadata = MetaData()
         sqltr = RelationalModelTransformer(SchemaView(self.schema))
         if not self.use_foreign_keys:
@@ -168,7 +166,8 @@ class SQLTableGenerator(Generator):
                 return ""
             return txt.replace("\n", "")
 
-        # Currently SQLite dialect in SQLA does not generated comments; see https://github.com/sqlalchemy/sqlalchemy/issues/1546#issuecomment-1067389172
+        # Currently SQLite dialect in SQLA does not generate comments; see
+        # https://github.com/sqlalchemy/sqlalchemy/issues/1546#issuecomment-1067389172
         # As a workaround we add these as "--" comments via direct string manipulation
         include_comments = self.dialect == "sqlite"
         sv = SchemaView(schema)
@@ -197,10 +196,15 @@ class SQLTableGenerator(Generator):
                         nullable=not s.required,
                     )
                     if include_comments:
-                        ddl_str += f"--     * Slot: {sn} Description: {strip_newlines(s.description)}\n"
+                        ddl_str += (
+                            f"--     * Slot: {sn} Description: {strip_newlines(s.description)}\n"
+                        )
                     if s.description:
                         col.comment = s.description
                     cols.append(col)
+                for uc_name, uc in c.unique_keys.items():
+                    sql_uc = UniqueConstraint(*[sql_name(sn) for sn in uc.unique_key_slots])
+                    cols.append(sql_uc)
                 Table(sql_name(cn), schema_metadata, *cols, comment=str(c.description))
         schema_metadata.create_all(engine)
         return ddl_str
@@ -235,9 +239,7 @@ class SQLTableGenerator(Generator):
         if range_base in RANGEMAP:
             return RANGEMAP[range_base]
         else:
-            logging.error(
-                f"UNKNOWN range base: {range_base} for {slot.name} = {slot.range}"
-            )
+            logging.error(f"UNKNOWN range base: {range_base} for {slot.name} = {slot.range}")
             return Text()
 
     def get_foreign_key(self, cn: str, sv: SchemaView) -> str:
@@ -271,9 +273,7 @@ class SQLTableGenerator(Generator):
     "--relmodel-output",
     help="Path to intermediate LinkML YAML of transformed relational model",
 )
-@click.option(
-    "--python-import", help="Python import header for generated sql-alchemy code"
-)
+@click.option("--python-import", help="Python import header for generated sql-alchemy code")
 @click.option(
     "--use-foreign-keys/--no-use-foreign-keys",
     default=True,

linkml/generators/sssomgen.py

@@ -1,12 +1,16 @@
 import os
 from dataclasses import dataclass
 from datetime import date
-from typing import Optional, TextIO, Union
 
 import click
-from linkml_runtime.linkml_model.meta import (LINKML, ClassDefinition,
-                                              Definition, EnumDefinition,
-                                              SchemaDefinition, SlotDefinition)
+from linkml_runtime.linkml_model.meta import (
+    LINKML,
+    ClassDefinition,
+    Definition,
+    EnumDefinition,
+    SchemaDefinition,
+    SlotDefinition,
+)
 
 from linkml._version import __version__
 from linkml.utils.generator import Generator, shared_arguments
@@ -19,6 +23,7 @@ class SSSOMGenerator(Generator):
     """
     Generates Simple Standard for Sharing Ontology Mappings (SSSOM) TSVs
     """
+
     # ClassVats
     generatorname = os.path.basename(__file__)
     generatorversion = "0.0.1"
@@ -62,7 +67,6 @@ class SSSOMGenerator(Generator):
         else:
             self.output_file = DEFAULT_OUTPUT_FILENAME
 
-
     def make_msdf_list(self, row_as_dict: dict) -> None:
         list_of_row = []
         for col_name in self.msdf_columns:
@@ -118,11 +122,7 @@ class SSSOMGenerator(Generator):
                 for k, v in obj.permissible_values.items():
                     if v["meaning"]:
                         subject_id = (
-                            default_prefix
-                            + ":"
-                            + subject_category
-                            + "#"
-                            + k.replace(" ", "")
+                            default_prefix + ":" + subject_category + "#" + k.replace(" ", "")
                         )
                         subject_label = k.replace(" ", "")
                         object_id = obj.permissible_values[k]["meaning"]
@@ -164,9 +164,7 @@ class SSSOMGenerator(Generator):
         metadata["mapping_tool"] = LINKML
         metadata["creator_id"] = "linkml_user"
         metadata["mapping_date"] = date.today().strftime("%Y-%m-%d")
-        metadata["curie_map"] = {
-            k: v.prefix_reference for k, v in schema.prefixes.items()
-        }
+        metadata["curie_map"] = {k: v.prefix_reference for k, v in schema.prefixes.items()}
         with open(self.output_file, "w", encoding="UTF-8") as sssom_tsv:
             for k, v in metadata.items():
                 if k != "curie_map":