linkml 1.9.1rc3__py3-none-any.whl → 1.9.2rc1__py3-none-any.whl

linkml/generators/panderagen/panderagen_class_based/slots.jinja2

@@ -0,0 +1,36 @@
+{#-
+  Jinja2 macros for rendering slots in a Pandera class-based model
+
+-#}
+{%- import 'enums.jinja2' as enum_macros -%}
+
+{%- macro constraint_parameters(field, slot) -%}
+    {%- if coerce is true -%}coerce=True, {% endif -%}
+    {%- if field.default_value is not none -%}default={{ field.default_value }}, {% endif -%}
+    {%- if slot.minimum_value is not none -%}ge={{ slot.minimum_value }}, {% endif -%}
+    {%- if slot.maximum_value is not none -%}le={{ slot.maximum_value }}, {% endif -%}
+    {%- if slot.pattern is not none -%}str_matches=r"{{ slot.pattern }}", {% endif -%}
+    {%- if (slot.required is none or slot.required is false) and slot.identifier is not true -%}nullable=True, {% endif -%}
+{%- endmacro -%}
+
+{%- macro render_slot(field) -%}
+    {%- with slot = field.source_slot %}
+    {{ field.name }}:{{ ' ' }}
+        {%- if (slot.required is none or slot.required is false) and slot.identifier is not true -%}
+            Optional[
+        {%- endif -%}
+       {{field.range}}
+        {%- if (slot.required is none or slot.required is false) and slot.identifier is not true -%}
+            {{ '] ' }}
+        {%- endif -%}
+        = pla.Field(
+            {{- constraint_parameters(field, slot) -}}
+            {{- enum_macros.enum_parameter(slot) -}}
+        )
+        {%- if slot.description %}
+    """
+    {{ slot.description }}
+    """
+        {% endif -%}
+    {%- endwith -%}
+{%- endmacro %}

linkml/generators/panderagen/slot_generator_mixin.py

@@ -0,0 +1,77 @@
+import logging
+
+from linkml.generators.oocodegen import OOField
+
+logger = logging.getLogger(__file__)
+
+
+class SlotGeneratorMixin:
+    LINKML_ANY_CURIE = "linkml:Any"
+    ANY_RANGE_STRING = "Object"
+    CLASS_RANGE_STRING = "Struct"
+    ENUM_RANGE_STRING = "Enum"
+    DEFAULT_RANGE_STRING = "str"
+
+    # to be implemented by the class
+    def make_multivalued(self, range: str):
+        raise NotImplementedError("please implement make multivalued in the class")
+
+    def handle_none_slot(self, slot, range: str) -> str:
+        range = self.schema.default_range  # need to figure this out, set at the beginning?
+        if range is None:
+            range = SlotGeneratorMixin.DEFAULT_RANGE_STRING
+
+        return range
+
+    def handle_class_slot(self, slot, range: str) -> str:
+        logger.warning(f"PanderaGen does not support class range slots. Using Struct {slot.name}")
+        return SlotGeneratorMixin.CLASS_RANGE_STRING
+
+    def handle_type_slot(self, slot, range: str) -> str:
+        del slot  # unused for now
+
+        t = self.schemaview.all_types().get(range)
+        range = self.map_type(t)
+
+        return range
+
+    def handle_enum_slot(self, slot, range: str) -> str:
+        enum_definition = self.schemaview.all_enums().get(range)
+        range = SlotGeneratorMixin.ENUM_RANGE_STRING
+        slot.annotations["permissible_values"] = self.get_enum_permissible_values(enum_definition)
+
+        return range
+
+    def handle_multivalued_slot(self, slot, range: str) -> str:
+        if slot.multivalued:
+            if slot.inlined_as_list and range != SlotGeneratorMixin.CLASS_RANGE_STRING:
+                range = self.make_multivalued(range)
+
+        return range
+
+    def handle_slot(self, cn: str, sn: str):
+        safe_sn = self.get_slot_name(sn)
+        slot = self.schemaview.induced_slot(sn, cn)
+        range = slot.range
+
+        if slot.alias is not None:
+            safe_sn = self.get_slot_name(slot.alias)
+
+        if range is None:
+            range = self.handle_none_slot(slot, range)
+        elif range in self.schemaview.all_classes():
+            range = self.handle_class_slot(slot, range)
+        elif range in self.schemaview.all_types():
+            range = self.handle_type_slot(slot, range)
+        elif range in self.schemaview.all_enums():
+            range = self.handle_enum_slot(slot, range)
+        else:
+            raise Exception(f"Unknown range {range}")
+
+        range = self.handle_multivalued_slot(slot, range)
+
+        return OOField(
+            name=safe_sn,
+            source_slot=slot,
+            range=range,
+        )

linkml/generators/pydanticgen/templates/enum.py.jinja

@@ -5,12 +5,14 @@ class {{ name }}(str{% if values %}, Enum{% endif %}):
     """
 {% endif %}
 {% if values %}
-    {% for pv in values.values() -%}
+    {% for pv in values.values() %}
+    {{pv.label}} = "{{pv.value}}"
         {% if pv.description %}
-    # {{pv.description}}
+    """
+    {{ pv.description | indent(width=4) }}
+    """
         {% endif %}
-    {{pv.label}} = "{{pv.value}}"
     {% endfor %}
 {% else %}
     pass
-{% endif %}
+{% endif %}

linkml/generators/pydanticgen/templates/validator.py.jinja

@@ -1,11 +1,12 @@
 @field_validator('{{name}}')
     def pattern_{{name}}(cls, v):
         pattern=re.compile(r"{{pattern}}")
-        if isinstance(v,list):
+        if isinstance(v, list):
             for element in v:
-                if isinstance(v, str) and not pattern.match(element):
-                    raise ValueError(f"Invalid {{name}} format: {element}")
-        elif isinstance(v,str):
-            if not pattern.match(v):
-                raise ValueError(f"Invalid {{name}} format: {v}")
+                if isinstance(element, str) and not pattern.match(element):
+                    err_msg = f"Invalid {{name}} format: {element}"
+                    raise ValueError(err_msg)
+        elif isinstance(v, str) and not pattern.match(v):
+            err_msg = f"Invalid {{name}} format: {v}"
+            raise ValueError(err_msg)
         return v

linkml/generators/sqltablegen.py

@@ -1,7 +1,10 @@
+from __future__ import annotations
+
 import logging
 import os
+import re
 from dataclasses import dataclass
-from typing import Optional
+from typing import Any
 
 import click
 from linkml_runtime.dumpers import yaml_dumper
@@ -9,12 +12,12 @@ 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.dialects.oracle import VARCHAR2
 from sqlalchemy.types import Boolean, Date, DateTime, Enum, Float, Integer, Text, Time
 
 from linkml._version import __version__
 from linkml.transformers.relmodel_transformer import ForeignKeyPolicy, RelationalModelTransformer
 from linkml.utils.generator import Generator, shared_arguments
-from linkml.utils.schemaloader import SchemaLoader
 
 logger = logging.getLogger(__name__)
 
@@ -46,6 +49,7 @@ METAMODEL_TYPE_TO_BASE = {
 RANGEMAP = {
     "str": Text(),
     "string": Text(),
+    "String": Text(),
     "NCName": Text(),
     "URIorCURIE": Text(),
     "int": Integer(),
@@ -60,29 +64,33 @@ RANGEMAP = {
 }
 
 
+VARCHAR_REGEX = re.compile(r"VARCHAR2?(\((\d+)\))?")
+ORACLE_MAX_VARCHAR_LENGTH = 4096
+
+
 @dataclass
 class SQLTableGenerator(Generator):
     """
-    A :class:`~linkml.utils.generator.Generator` for creating SQL DDL
+    A :class:`~linkml.utils.generator.Generator` for creating SQL DDL.
 
     The basic algorithm for mapping a linkml schema S is as follows:
 
     - Each schema S corresponds to one database schema D (see SQLSchema)
-    - Each Class C in S is mapped to a table T (see SQLTable)
-    - Each slot S in each C is mapped to a column Col (see SQLColumn)
+    - Each Class C in S is mapped to a table T (see sqlalchemy.Table)
+    - Each slot S in each C is mapped to a column Col (see sqlalchemy.Column)
 
-    if the direct_mapping attribute is set to true, then no further transformations
+    If the direct_mapping attribute is set to true, then no further transformations
     are applied. Note that this means:
 
     - inline objects are modeled as Text strings
     - multivalued fields are modeled as single Text strings
 
-    this direct mapping is useful for simple spreadsheet/denormalized representations of complex data.
-    however, for other applications, additional transformations should occur. these are:
+    This direct mapping is useful for simple spreadsheet/denormalized representations of complex data.
+    However, for other applications, additional transformations should occur. These are:
 
     MULTIVALUED SLOTS
 
-    The relational model does not have direct representation of lists. These are normalized as follows.
+    The relational model does not have direct representation of lists. These are normalized as follows:
 
     If the range of the slot is a class, and there are no other slots whose range is this class,
     and the slot is for a class that has a singular primary key, then a backref is added.
@@ -90,11 +98,11 @@ class SQLTableGenerator(Generator):
     E.g. if we have User 0..* Address,
     then add a field User_id to Address.
 
-    When SQLAlchemy bindings are created, a backref mapping is added
+    When SQLAlchemy bindings are created, a backref mapping is added.
 
-    If the range of the slot is an enum or type, then a new linktable is created, and a backref added
+    If the range of the slot is an enum or type, then a new linktable is created, and a backref added.
 
-    E.g. if a class User has a multivalues slot alias whose range is a string,
+    E.g. if a class User has a multivalued slot alias whose range is a string,
     then create a table user_aliases, with two columns (1) alias [a string] and (2) a backref to user
 
     Each mapped slot C.S has a range R
@@ -139,11 +147,21 @@ class SQLTableGenerator(Generator):
     rename_foreign_keys: bool = False
     direct_mapping: bool = False
     relative_slot_num: bool = False
+    default_length_oracle: int = ORACLE_MAX_VARCHAR_LENGTH
+    generate_abstract_class_ddl: bool = True
 
-    def serialize(self, **kwargs) -> str:
+    def serialize(self, **kwargs: dict[str, Any]) -> str:
         return self.generate_ddl(**kwargs)
 
-    def generate_ddl(self, naming_policy: SqlNamingPolicy = None, **kwargs) -> str:
+    def generate_ddl(self, naming_policy: SqlNamingPolicy = None, **kwargs: dict[str, Any]) -> str:
+        """
+        Generate a DDL using the schema in self.schema.
+
+        :param naming_policy: naming policy for columns, defaults to None
+        :type naming_policy: SqlNamingPolicy, optional
+        :return: the DDL as a string
+        :rtype: str
+        """
         ddl_str = ""
 
         def dump(sql, *multiparams, **params):
@@ -155,25 +173,20 @@ class SQLTableGenerator(Generator):
         sqltr = RelationalModelTransformer(SchemaView(self.schema))
         if not self.use_foreign_keys:
             sqltr.foreign_key_policy = ForeignKeyPolicy.NO_FOREIGN_KEYS
-        tr_result = sqltr.transform(
-            tgt_schema_name=kwargs.get("tgt_schema_name", None), top_class=kwargs.get("top_class", None)
-        )
+        tr_result = sqltr.transform(tgt_schema_name=kwargs.get("tgt_schema_name"), top_class=kwargs.get("top_class"))
         schema = tr_result.schema
 
         def sql_name(n: str) -> str:
-            if naming_policy is not None:
-                if naming_policy == SqlNamingPolicy.underscore:
-                    return underscore(n)
-                elif naming_policy == SqlNamingPolicy.camelcase:
-                    return camelcase(n)
-                elif naming_policy == SqlNamingPolicy.preserve:
-                    return n
-                else:
-                    raise Exception(f"Unknown: {naming_policy}")
-            else:
+            if not naming_policy or naming_policy == SqlNamingPolicy.preserve:
                 return n
-
-        def strip_newlines(txt: Optional[str]) -> str:
+            if naming_policy == SqlNamingPolicy.underscore:
+                return underscore(n)
+            if naming_policy == SqlNamingPolicy.camelcase:
+                return camelcase(n)
+            msg = f"Unknown: {naming_policy}"
+            raise Exception(msg)
+
+        def strip_newlines(txt: str | None) -> str:
             if txt is None:
                 return ""
             return txt.replace("\n", "")
@@ -183,9 +196,16 @@ class SQLTableGenerator(Generator):
         # As a workaround we add these as "--" comments via direct string manipulation
         include_comments = self.dialect == "sqlite"
         sv = SchemaView(schema)
+
+        # 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():
             if include_comments:
-                ddl_str += f'-- # Class: "{cn}" Description: "{strip_newlines(c.description)}"\n'
+                if c.abstract:
+                    ddl_str += f'-- # Abstract Class: "{cn}" Description: "{strip_newlines(c.description)}"\n'
+                else:
+                    ddl_str += f'-- # Class: "{cn}" Description: "{strip_newlines(c.description)}"\n'
             pk_slot = sv.get_identifier_slot(cn)
             if c.attributes:
                 cols = []
@@ -197,7 +217,7 @@ class SQLTableGenerator(Generator):
                     #    is_pk = True  ## TODO: use unique key
                     args = []
                     if s.range in schema.classes and self.use_foreign_keys:
-                        fk = sql_name(self.get_foreign_key(s.range, sv))
+                        fk = sql_name(self.get_id_or_key(s.range, sv))
                         args = [ForeignKey(fk)]
                     field_type = self.get_sql_range(s, schema)
                     col = Column(
@@ -212,82 +232,107 @@ class SQLTableGenerator(Generator):
                     if s.description:
                         col.comment = s.description
                     cols.append(col)
-                for uc_name, uc in c.unique_keys.items():
-
-                    def _sql_name(sn: str):
-                        if sn in c.attributes:
-                            return sql_name(sn)
-                        else:
-                            # for candidate in c.attributes.values():
-                            #    if "original_slot" in candidate.annotations:
-                            #        original = candidate.annotations["original_slot"]
-                            #        if original.value == sn:
-                            #            return sql_name(candidate.name)
-                            return None
-
-                    sql_names = [_sql_name(sn) for sn in uc.unique_key_slots]
+                # convert unique_keys into a uniqueness constraint for the table
+                for uc in c.unique_keys.values():
+                    sql_names = [sql_name(sn) if sn in c.attributes else None for sn in uc.unique_key_slots]
                     if any(sn is None for sn in sql_names):
                         continue
                     sql_uc = UniqueConstraint(*sql_names)
                     cols.append(sql_uc)
+            if not c.abstract or (c.abstract and self.generate_abstract_class_ddl):
                 Table(sql_name(cn), schema_metadata, *cols, comment=str(c.description))
         schema_metadata.create_all(engine)
         return ddl_str
 
-    def get_sql_range(self, slot: SlotDefinition, schema: SchemaDefinition = None):
+    def get_oracle_sql_range(self, slot: SlotDefinition) -> Text | VARCHAR2 | None:
         """
-        returns a SQL Alchemy column type
+        Generate the appropriate range for Oracle SQL.
+
+        :param slot: the slot under examination
+        :type slot: SlotDefinition
+        :return: appropriate type for Oracle SQL or None
+        :rtype: Text | VARCHAR2 | None
         """
-        range = slot.range
+        slot_range = slot.range
+        if not slot_range:
+            return None
+
+        if slot_range.lower() in ["str", "string"]:
+            # string type data should be represented as a VARCHAR2
+            return VARCHAR2(self.default_length_oracle)
+
+        # check whether the slot range matches the regex "VARCHAR2?(\((\d+)\))?"
+        match = re.match(VARCHAR_REGEX, slot_range)
+        if match:
+            # match.group(2) is the digits in brackets after VARCHAR
+            # i.e. a defined length for the VARCHAR
+            if match.group(2) and int(match.group(2)) > ORACLE_MAX_VARCHAR_LENGTH:
+                msg = (
+                    "Warning: range exceeds maximum Oracle VARCHAR length, "
+                    f"CLOB type will be returned: {slot_range} for {slot.name} = {slot.range}"
+                )
+                logger.info(msg)
+                return Text()
+            # set the length to either the varchar length (as defined in the slot_range)
+            # or the default
+            return VARCHAR2(match.group(2) or self.default_length_oracle)
+
+        # use standard SQL range matching for anything else
+        return None
+
+    def get_sql_range(self, slot: SlotDefinition, schema: SchemaDefinition = None):
+        """Get the slot range as a SQL Alchemy column type."""
+        slot_range = slot.range
+
+        if self.dialect == "oracle":
+            range_type = self.get_oracle_sql_range(slot)
+            if range_type:
+                return range_type
+
+        if slot_range is None:
+            return Text()
 
         # if no SchemaDefinition is explicitly provided as an argument
         # then simply use the schema that is provided to the SQLTableGenerator() object
         if not schema:
-            schema = SchemaLoader(data=self.schema).resolve()
+            schema = self.schema
 
-        if range in schema.classes:
+        sv = SchemaView(schema)
+        if slot_range in sv.all_classes():
             # FK type should be the same as the identifier of the foreign key
-            fk = SchemaView(schema).get_identifier_slot(range)
+            fk = sv.get_identifier_slot(slot_range)
             if fk:
-                return self.get_sql_range(fk, schema)
-            else:
-                return Text()
-        if range in schema.enums:
-            e = schema.enums[range]
+                return self.get_sql_range(fk, sv.schema)
+            return Text()
+
+        if slot_range in sv.all_enums():
+            e = sv.all_enums()[slot_range]
             if e.permissible_values is not None:
                 vs = [str(v) for v in e.permissible_values]
                 return Enum(name=e.name, *vs)
-        if range in METAMODEL_TYPE_TO_BASE:
-            range_base = METAMODEL_TYPE_TO_BASE[range]
-        elif range in schema.types:
-            range_base = schema.types[range].base
-        elif range is None:
-            return Text()
+
+        if slot_range in METAMODEL_TYPE_TO_BASE:
+            range_base = METAMODEL_TYPE_TO_BASE[slot_range]
+        elif slot_range in sv.all_types():
+            range_base = sv.all_types()[slot_range].base
         else:
-            logger.error(f"Unknown range: {range} for {slot.name} = {slot.range}")
+            logger.error(f"Unknown range: {slot_range} for {slot.name} = {slot.range}")
             return Text()
+
         if range_base in RANGEMAP:
             return RANGEMAP[range_base]
-        else:
-            logger.error(f"UNKNOWN range base: {range_base} for {slot.name} = {slot.range}")
-            return Text()
+
+        logger.error(f"Unknown range base: {range_base} for {slot.name} = {slot.range}")
+        return Text()
 
     @staticmethod
-    def get_foreign_key(cn: str, sv: SchemaView) -> str:
-        pk = sv.get_identifier_slot(cn)
-        # TODO: move this to SV
+    def get_id_or_key(cn: str, sv: SchemaView) -> str:
+        """Given a named class, retrieve the identifier or key slot."""
+        pk = sv.get_identifier_slot(cn, use_key=True)
         if pk is None:
-            for sn in sv.class_slots(cn):
-                s = sv.induced_slot(sn, cn)
-                if s.key:
-                    pk = s
-                    break
-        if pk is None:
-            raise Exception(f"No PK for {cn}")
-        if pk.alias:
-            pk_name = pk.alias
-        else:
-            pk_name = pk.name
+            msg = f"No PK for {cn}"
+            raise Exception(msg)
+        pk_name = pk.alias if pk.alias else pk.name
         return f"{cn}.{pk_name}"
 
 
@@ -311,17 +356,29 @@ class SQLTableGenerator(Generator):
     show_default=True,
     help="Emit FK declarations",
 )
+@click.option(
+    "--default_length_oracle",
+    default=ORACLE_MAX_VARCHAR_LENGTH,
+    show_default=True,
+    help="Default length of varchar based arguments for oracle dialects",
+)
+@click.option(
+    "--generate_abstract_class_ddl",
+    default=True,
+    show_default=True,
+    help="A manual override to omit the abstract classes, set to true as a default for testing sake",
+)
 @click.version_option(__version__, "-V", "--version")
 def cli(
-    yamlfile,
-    relmodel_output,
-    sqla_file: str = None,
+    yamlfile: str,
+    relmodel_output: str,
+    sqla_file: str | None = None,
     python_import: str = None,
-    dialect=None,
-    use_foreign_keys=True,
+    dialect: str | None = None,
+    use_foreign_keys: bool = True,
     **args,
 ):
-    """Generate SQL DDL representation"""
+    """Generate SQL DDL representation."""
     if relmodel_output:
         sv = SchemaView(yamlfile)
         rtr = RelationalModelTransformer(sv)

linkml/generators/yumlgen.py

@@ -15,6 +15,7 @@ from linkml_runtime.utils.formatutils import camelcase, underscore
 from rdflib import Namespace
 
 from linkml import REQUESTS_TIMEOUT
+from linkml.utils.deprecation import deprecation_warning
 from linkml.utils.generator import Generator, shared_arguments
 
 yuml_is_a = "^-"
@@ -34,6 +35,30 @@ YUML = Namespace(yuml_base + yuml_scale + yuml_dir + yuml_class)
 
 @dataclass
 class YumlGenerator(Generator):
+    """
+    .. admonition:: Deprecated
+        :class: warning
+
+            The `yuml` generator is being deprecated and is no longer supported.
+
+            Going forward, we recommend using one of the following alternatives that offer improved visualization
+            capabilities:
+
+            - `gen-doc` – Generates documentation with **embedded Mermaid class diagrams**.
+            - `gen-plantuml` – Produces **PlantUML diagrams**.
+            - `gen-mermaid-class-diagram` – Creates **standalone Mermaid class diagrams**.
+            - `gen-erdiagram` – For **Entity-Relationship (ER) diagrams**.
+
+            .. deprecated:: v1.8.7
+
+            Recommendation: Migrate to one of the supported generators listed above.
+
+    """
+
+    def __post_init__(self) -> None:
+        deprecation_warning("gen-yuml")
+        super().__post_init__()
+
     generatorname = os.path.basename(__file__)
     generatorversion = "0.1.1"
     valid_formats = ["yuml", "png", "pdf", "jpg", "json", "svg"]
@@ -87,6 +112,7 @@ class YumlGenerator(Generator):
 
         file_suffix = ".svg" if self.format == "yuml" else "." + self.format
         file_name = diagram_name or camelcase(sorted(classes)[0] if classes else self.schema.name)
+
         if directory:
             self.output_file_name = os.path.join(
                 directory,
@@ -274,7 +300,13 @@ class YumlGenerator(Generator):
     help="Name of the diagram in the output directory (without suffix!)",
 )
 def cli(yamlfile, **args):
-    """Generate a UML representation of a LinkML model"""
+    """Generate a yUML representation of a LinkML model
+
+    .. warning::
+        `gen-yuml` is deprecated. Please use `gen-doc`, `gen-plantuml` or `gen-mermaid-class-diagram`.
+    """
+    deprecation_warning("gen-yuml")
+
     print(YumlGenerator(yamlfile, **args).serialize(**args), end="")