linkml 1.9.2rc1__py3-none-any.whl → 1.9.3__py3-none-any.whl

linkml/generators/pythongen.py

@@ -474,7 +474,7 @@ version = {'"' + self.schema.version + '"' if self.schema.version else None}
     def gen_classdef(self, cls: ClassDefinition) -> str:
         """Generate python definition for class cls"""
 
-        parentref = f'({self.formatted_element_name(cls.is_a, True) if cls.is_a else "YAMLRoot"})'
+        parentref = f"({self.formatted_element_name(cls.is_a, True) if cls.is_a else 'YAMLRoot'})"
         slotdefs = self.gen_class_variables(cls)
         postinits = self.gen_postinits(cls)
         constructor = self.gen_constructor(cls)
@@ -833,8 +833,7 @@ version = {'"' + self.schema.version + '"' if self.schema.version else None}
                 elif slot_range == "uri":
                     lookup_by_props = ["class_class_uri", "class_model_uri"]
                     td_val_expression = (
-                        f"URIRef({td_val_expression}) if "
-                        f"isinstance({td_val_expression}, str) else {td_val_expression}"
+                        f"URIRef({td_val_expression}) if isinstance({td_val_expression}, str) else {td_val_expression}"
                     )
                 elif slot_range == "uriorcurie":
                     lookup_by_props = ["class_class_curie", "class_class_uri", "class_model_uri"]
@@ -917,8 +916,7 @@ version = {'"' + self.schema.version + '"' if self.schema.version else None}
                 rlines.append(f"self.{aliased_slot_name} = str(self.{td_value_classvar})")
             elif (
                 # A really weird case -- a class that has no properties
-                slot.range in self.schema.classes
-                and not self.schema.classes[slot.range].slots
+                slot.range in self.schema.classes and not self.schema.classes[slot.range].slots
             ):
                 rlines.append(f"\tself.{aliased_slot_name} = {base_type_name}()")
             else:
@@ -985,7 +983,7 @@ version = {'"' + self.schema.version + '"' if self.schema.version else None}
             sn = f"self.{aliased_slot_name}"
             rlines.append(f"if not isinstance({sn}, list):")
             rlines.append(f"\t{sn} = [{sn}] if {sn} is not None else []")
-            rlines.append(f"{sn} = [v if isinstance(v, {base_type_name}) " f"else {base_type_name}(v) for v in {sn}]")
+            rlines.append(f"{sn} = [v if isinstance(v, {base_type_name}) else {base_type_name}(v) for v in {sn}]")
         while rlines and copy(rlines[-1]).strip() == "":
             rlines.pop()
         rlines.append("")
@@ -1213,6 +1211,7 @@ class {enum_name}(EnumDefinitionImpl):
         PermissibleValue(text="NAME_ONLY")
         PermissibleValue(
             text="CODE",
+            title="...",
             description="...",
             meaning="...")
 
@@ -1223,13 +1222,15 @@ class {enum_name}(EnumDefinitionImpl):
         constructor = "PermissibleValue"
         pv_text = pv.text.replace('"', '\\"')
 
-        if not pv.description and not pv.meaning:
+        if not pv.description and not pv.meaning and not pv.title:
             return f'{constructor}(text="{pv_text}")'
 
         indent_str = (4 + indent) * " "
         pv_attrs = [f'{indent_str}text="{pv_text}"']
+        if pv.title:
+            pv_attrs.append(f'{indent_str}title="{pv.title}"')
         if pv.description:
-            pv_attrs.append(f'{self.process_multiline_string(pv.description, f"{indent_str}description=")}')
+            pv_attrs.append(f"{self.process_multiline_string(pv.description, f'{indent_str}description=')}")
         if pv.meaning:
             pv_meaning = self.namespaces.curie_for(
                 self.namespaces.uri_for(pv.meaning), default_ok=False, pythonform=True

linkml/generators/shacl/shacl_ifabsent_processor.py

@@ -6,7 +6,6 @@ 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)

linkml/generators/shaclgen.py

@@ -141,7 +141,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(str(s), suffix="")} {error}')
+                        raise ValueError(f"{TypedNode.yaml_loc(str(s), suffix='')} {error}")
 
                     or_node = BNode()
                     prop_pv(SH["or"], or_node)

linkml/generators/sparqlgen.py

@@ -151,7 +151,7 @@ class SparqlGenerator(Generator):
         template_obj = Template(template)
         extra = ""
         if named_graphs is not None:
-            extra += f'FILTER( ?graph in ( {",".join(named_graphs)} ))'
+            extra += f"FILTER( ?graph in ( {','.join(named_graphs)} ))"
         logger.info(f"Named Graphs = {named_graphs} // extra={extra}")
         if limit is not None and isinstance(limit, int):
             limit = f"LIMIT {limit}"

linkml/generators/sqlalchemy/__init__.py

@@ -1,4 +0,0 @@
-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/sqlalchemygen.py

@@ -1,9 +1,10 @@
+from __future__ import annotations
+
 import logging
 import os
 from collections import defaultdict
 from dataclasses import dataclass
 from types import ModuleType
-from typing import Optional, Union
 
 import click
 from jinja2 import Template
@@ -16,7 +17,8 @@ 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.sqlalchemy_declarative_template import sqlalchemy_declarative_template_str
+from linkml.generators.sqlalchemy.sqlalchemy_imperative_template import sqlalchemy_imperative_template_str
 from linkml.generators.sqltablegen import SQLTableGenerator
 from linkml.transformers.relmodel_transformer import ForeignKeyPolicy, RelationalModelTransformer
 from linkml.utils.generator import Generator, shared_arguments
@@ -43,10 +45,10 @@ class SQLAlchemyGenerator(Generator):
     valid_formats = ["sqla"]
     file_extension = "py"
     uses_schemaloader = False
-    template: Optional[TemplateEnum] = None
+    template: TemplateEnum | None = None
 
     # ObjectVars
-    original_schema: Union[SchemaDefinition, str] = None
+    original_schema: SchemaDefinition | str = None
 
     def __post_init__(self) -> None:
         self.original_schema = self.schema
@@ -55,14 +57,12 @@ class SQLAlchemyGenerator(Generator):
 
     def generate_sqla(
         self,
-        model_path: Optional[str] = None,
+        model_path: str | None = None,
         no_model_import: bool = False,
-        template: Optional[TemplateEnum] = None,
-        foreign_key_policy: Optional[ForeignKeyPolicy] = None,
+        template: TemplateEnum | None = None,
+        foreign_key_policy: ForeignKeyPolicy | None = None,
         **kwargs,
     ) -> str:
-        # src_sv = SchemaView(self.schema)
-        # self.schema = src_sv.schema
         template = template or self.template or TemplateEnum.IMPERATIVE
         sqltr = RelationalModelTransformer(self.schemaview)
         if foreign_key_policy:
@@ -76,7 +76,6 @@ class SQLAlchemyGenerator(Generator):
                 sql_type = sql_range.__repr__()
                 ann = Annotation("sql_type", sql_type)
                 a.annotations[ann.tag] = ann
-                # a.sql_type = sql_type
         if template == TemplateEnum.IMPERATIVE:
             template_str = sqlalchemy_imperative_template_str
         elif template == TemplateEnum.DECLARATIVE:
@@ -90,10 +89,6 @@ class SQLAlchemyGenerator(Generator):
         backrefs = defaultdict(list)
         for m in tr_result.mappings:
             backrefs[m.source_class].append(m)
-        # for c in tr_schema.classes.values():
-        #    if len(c.attributes) == 0:
-        #        skip[c.name] = True
-        #        #raise ValueError(f'Class must have attrs: {c.name}')
         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)]
@@ -167,7 +162,6 @@ class SQLAlchemyGenerator(Generator):
     @staticmethod
     def add_safe_aliases(schema: SchemaDefinition) -> None:
         for c in schema.classes.values():
-            # c.alias = underscore(c.name)
             for a in c.attributes.values():
                 a.alias = underscore(a.name)
 

linkml/generators/sqltablegen.py

@@ -11,7 +11,7 @@ from linkml_runtime.dumpers import yaml_dumper
 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, UniqueConstraint, create_mock_engine
+from sqlalchemy import Column, ForeignKey, Index, MetaData, Table, UniqueConstraint, create_mock_engine
 from sqlalchemy.dialects.oracle import VARCHAR2
 from sqlalchemy.types import Boolean, Date, DateTime, Enum, Float, Integer, Text, Time
 
@@ -149,6 +149,8 @@ class SQLTableGenerator(Generator):
     relative_slot_num: bool = False
     default_length_oracle: int = ORACLE_MAX_VARCHAR_LENGTH
     generate_abstract_class_ddl: bool = True
+    autogenerate_pk_index: bool = True
+    autogenerate_fk_index: bool = True
 
     def serialize(self, **kwargs: dict[str, Any]) -> str:
         return self.generate_ddl(**kwargs)
@@ -191,21 +193,34 @@ class SQLTableGenerator(Generator):
                 return ""
             return txt.replace("\n", "")
 
+        def strip_dangling_whitespace(txt: str) -> str:
+            return "\n".join(line.rstrip() for line in txt.splitlines())
+
         # 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)
 
+        # This is a safeguard for checking duplicate item names within a table
+        autogenerated_item_names = []
+
         # Iterate through the attributes in each class, creating Column objects.
         # This includes generating the appropriate column name, converting the range
         # into an SQL type, and adding a foreign key notation if appropriate.
         for cn, c in schema.classes.items():
+            desc = strip_newlines(c.description)
             if include_comments:
                 if c.abstract:
-                    ddl_str += f'-- # Abstract Class: "{cn}" Description: "{strip_newlines(c.description)}"\n'
+                    if desc:
+                        ddl_str += f"-- # Abstract Class: {cn} Description: {desc}\n"
+                    else:
+                        ddl_str += f"-- # Abstract Class: {cn}\n"
                 else:
-                    ddl_str += f'-- # Class: "{cn}" Description: "{strip_newlines(c.description)}"\n'
+                    if desc:
+                        ddl_str += f"-- # Class: {cn} Description: {desc}\n"
+                    else:
+                        ddl_str += f"-- # Class: {cn}\n"
             pk_slot = sv.get_identifier_slot(cn)
             if c.attributes:
                 cols = []
@@ -220,15 +235,26 @@ class SQLTableGenerator(Generator):
                         fk = sql_name(self.get_id_or_key(s.range, sv))
                         args = [ForeignKey(fk)]
                     field_type = self.get_sql_range(s, schema)
+                    fk_index_cond = (s.key or s.identifier) and self.autogenerate_fk_index
+                    pk_index_cond = is_pk and self.autogenerate_pk_index
+                    is_index = fk_index_cond or pk_index_cond
                     col = Column(
                         sql_name(sn),
                         field_type,
                         *args,
                         primary_key=is_pk,
                         nullable=not s.required,
+                        index=is_index,
                     )
+                    if is_index:
+                        # this is what SQLAlchemy generates, TODO: perhaps we need to expand this
+                        autogenerated_item_names.append(sql_name("ix_" + sql_name(cn) + "_" + sql_name(sn)))
                     if include_comments:
-                        ddl_str += f"--     * Slot: {sn} Description: {strip_newlines(s.description)}\n"
+                        desc = strip_newlines(s.description)
+                        comment_str = f"--     * Slot: {sn}"
+                        if desc:
+                            comment_str += f" Description: {desc}"
+                        ddl_str += comment_str + "\n"
                     if s.description:
                         col.comment = s.description
                     cols.append(col)
@@ -239,9 +265,34 @@ class SQLTableGenerator(Generator):
                         continue
                     sql_uc = UniqueConstraint(*sql_names)
                     cols.append(sql_uc)
+                    # Anything that has a unique constraint should have an associated index with it
+                    uc_index_name = sql_name(cn)
+                    for name in sql_names:
+                        uc_index_name = uc_index_name + "_" + name
+                    uc_index_name = uc_index_name + "_idx"
+                    is_duplicate = self.check_duplicate_entry_names(autogenerated_item_names, sql_name(uc_index_name))
+                    if not is_duplicate:
+                        sql_names = [sql_name(uc_index_name)] + sql_names
+                        uc_index = Index(*sql_names)
+                        cols.append(uc_index)
+                        autogenerated_item_names.append(sql_name(uc_index_name))
             if not c.abstract or (c.abstract and self.generate_abstract_class_ddl):
+                for tag, annotation in c.annotations.items():
+                    if tag == "index":
+                        value_dict = {k: annotation for k, annotation in annotation.value._items()}
+                        for key, value in value_dict.items():
+                            test_name = sql_name(key)
+                            name_exists = self.check_duplicate_entry_names(autogenerated_item_names, test_name)
+                            if not name_exists:
+                                value_sql_name = [sql_name(col_name) for col_name in value]
+                                annotation_ind = Index(test_name, *value_sql_name)
+                                autogenerated_item_names.append(test_name)
+                                cols.append(annotation_ind)
                 Table(sql_name(cn), schema_metadata, *cols, comment=str(c.description))
         schema_metadata.create_all(engine)
+        ddl_str = strip_dangling_whitespace(ddl_str)
+        if ddl_str[-1:] != "\n":
+            ddl_str += "\n"
         return ddl_str
 
     def get_oracle_sql_range(self, slot: SlotDefinition) -> Text | VARCHAR2 | None:
@@ -335,6 +386,15 @@ class SQLTableGenerator(Generator):
         pk_name = pk.alias if pk.alias else pk.name
         return f"{cn}.{pk_name}"
 
+    # Scans the schema for duplicate names that exist as a best practice
+    @staticmethod
+    def check_duplicate_entry_names(autogen: list, item_name: str) -> bool:
+        if item_name in autogen:
+            msg = f"Warning: {item_name} already exists, please generate a new name"
+            logger.warning(msg)
+            return True
+        return False
+
 
 @shared_arguments(SQLTableGenerator)
 @click.command(name="sqltables")
@@ -362,6 +422,12 @@ class SQLTableGenerator(Generator):
     show_default=True,
     help="Default length of varchar based arguments for oracle dialects",
 )
+@click.option(
+    "--autogenerate_index",
+    default=False,
+    show_default=True,
+    help="Enable the creation of indexes on all columns generated",
+)
 @click.option(
     "--generate_abstract_class_ddl",
     default=True,

linkml/generators/string_template.md

@@ -1,6 +1,6 @@
 # String Template proposal
 The `string_template` attribute allows a Python [format string](https://docs.python.org/3/library/string.html#formatstrings)
-to be associated with a LinkML model `Element`.  
+to be associated with a LinkML model `Element`.
 
 ## Syntax
 ```yaml
@@ -29,7 +29,7 @@ class FirstClass(YAMLRoot):
     name: str = None
     age: Optional[int] = None
     gender: Optional[str] = None
-    
+
     ...
 
     def __str__(self):
@@ -54,7 +54,7 @@ inst2 = FirstClass.parse("Jillian Johnson - a 93 year old female")
 print(str(inst2))
 > 'Jillian Johnson - a 93 year old female'
 
-# repr gives you the non-templated 
+# repr gives you the non-templated
 print(repr(inst2))
 > "FirstClass(name='Jillian Johnson', age=93, gender='female')"
 
@@ -71,4 +71,3 @@ name: Freddy Buster Jones
 age: 11
 gender: Undetermined
 ```
-

linkml/generators/terminusdbgen.py

@@ -114,8 +114,7 @@ class TerminusdbGenerator(Generator):
 
         if rng not in XSD_Ok and slot.range not in self.schema.classes:
             raise Exception(
-                f"slot range for {name} must be schema class or supported xsd type. "
-                f"Range {rng} is of type {type(rng)}."
+                f"slot range for {name} must be schema class or supported xsd type. Range {rng} is of type {type(rng)}."
             )
 
         self.clswq.property(underscore(name), rng, label=name, description=slot.description)

linkml/linter/cli.py

@@ -7,10 +7,9 @@ import click
 import yaml
 
 from linkml._version import __version__
-
-from .config.datamodel.config import RuleLevel
-from .formatters import JsonFormatter, MarkdownFormatter, TerminalFormatter, TsvFormatter
-from .linter import Linter
+from linkml.linter.config.datamodel.config import RuleLevel
+from linkml.linter.formatters import JsonFormatter, MarkdownFormatter, TerminalFormatter, TsvFormatter
+from linkml.linter.linter import Linter
 
 YAML_SUFFIXES = [".yml", ".yaml"]
 DEFAULT_CONFIG_FILES = [".linkmllint.yaml", ".linkmllint.yml"]