linkml 1.8.4__tar.gz → 1.8.6__tar.gz

{linkml-1.8.4 → linkml-1.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml
-Version: 1.8.4
+Version: 1.8.6
 Summary: Linked Open Data Modeling Language
 Home-page: https://linkml.io/linkml/
 Keywords: schema,linked data,data modeling,rdf,owl,biolink
@@ -53,7 +53,7 @@ Requires-Dist: pyyaml
 Requires-Dist: rdflib (>=6.0.0)
 Requires-Dist: requests (>=2.22)
 Requires-Dist: sqlalchemy (>=1.4.31)
-Requires-Dist: typing-extensions (>=4.4.0) ; python_version < "3.9"
+Requires-Dist: typing-extensions (>=4.6.0) ; python_version < "3.12"
 Requires-Dist: watchdog (>=0.9.0)
 Project-URL: Documentation, https://linkml.io/linkml/
 Project-URL: Repository, https://github.com/linkml/linkml

{linkml-1.8.4 → linkml-1.8.6}/linkml/cli/main.py

@@ -8,6 +8,7 @@ import click
 
 from linkml._version import __version__
 from linkml.generators.csvgen import cli as gen_csv
+from linkml.generators.dbmlgen import cli as gen_dbml
 from linkml.generators.docgen import cli as gen_doc
 from linkml.generators.dotgen import cli as gen_graphviz
 from linkml.generators.erdiagramgen import cli as gen_erdiagram
@@ -125,6 +126,7 @@ generate.add_command(gen_project, name="project")
 generate.add_command(gen_excel, name="excel")
 generate.add_command(gen_sssom, name="sssom")
 generate.add_command(gen_linkml, name="linkml")
+generate.add_command(gen_dbml, name="dbml")
 
 # Dev helpers
 dev.add_command(run_tutorial, name="tutorial")

{linkml-1.8.4 → linkml-1.8.6}/linkml/generators/common/build.py

@@ -5,7 +5,6 @@ Models for intermediate build results
 """
 
 import dataclasses
-from abc import abstractmethod
 from typing import Any, TypeVar
 
 try:
@@ -57,11 +56,11 @@ class BuildResult(BaseModel):
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    @abstractmethod
     def merge(self, other: T) -> T:
         """
         Build results should have some means of merging results of a like kind
         """
+        raise NotImplementedError("This build result doesn't know how to merge!")
 
 
 class SchemaResult(BuildResult):

{linkml-1.8.4 → linkml-1.8.6}/linkml/generators/common/ifabsent_processor.py

@@ -1,7 +1,13 @@
 import abc
 import re
+import sys
 from abc import ABC
-from typing import Any, Optional
+from typing import Any, Optional, Type, Union
+
+if sys.version_info < (3, 10):
+    from typing_extensions import TypeAlias
+else:
+    from typing import TypeAlias
 
 from linkml_runtime import SchemaView
 from linkml_runtime.linkml_model import (
@@ -18,6 +24,7 @@ from linkml_runtime.linkml_model import (
     String,
     Time,
     Uri,
+    types,
 )
 from linkml_runtime.linkml_model.types import (
     Curie,
@@ -31,6 +38,34 @@ from linkml_runtime.linkml_model.types import (
     Uriorcurie,
 )
 
+TYPES_TYPE: TypeAlias = Union[
+    Type[Boolean],
+    Type[Curie],
+    Type[Date],
+    Type[DateOrDatetime],
+    Type[Datetime],
+    Type[Decimal],
+    Type[Double],
+    Type[Float],
+    Type[Integer],
+    Type[Jsonpath],
+    Type[Jsonpointer],
+    Type[Ncname],
+    Type[Nodeidentifier],
+    Type[Objectidentifier],
+    Type[Sparqlpath],
+    Type[String],
+    Type[Time],
+    Type[Uri],
+    Type[Uriorcurie],
+]
+
+TYPES = [
+    t
+    for t in types.__dict__.values()
+    if isinstance(t, type) and t.__module__ == types.__name__ and hasattr(t, "type_name")
+]
+
 
 class IfAbsentProcessor(ABC):
     """
@@ -39,7 +74,7 @@ class IfAbsentProcessor(ABC):
     See `<https://w3id.org/linkml/ifabsent>`_.
     """
 
-    ifabsent_regex = re.compile("""(?:(?P<type>\w+)\()?[\"\']?(?P<default_value>[^\(\)\"\')]*)[\"\']?\)?""")
+    ifabsent_regex = re.compile(r"""(?:(?P<type>\w+)\()?[\"\']?(?P<default_value>[^\(\)\"\')]*)[\"\']?\)?""")
 
     def __init__(self, schema_view: SchemaView):
         self.schema_view = schema_view
@@ -61,10 +96,12 @@ class IfAbsentProcessor(ABC):
         if mapped:
             return custom_default_value
 
-        if slot.range == String.type_name:
+        base_type = self._base_type(slot.range)
+
+        if base_type is String:
             return self.map_string_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Boolean.type_name:
+        if base_type is Boolean:
             if re.match(r"^[Tt]rue$", ifabsent_default_value):
                 return self.map_boolean_true_default_value(slot, cls)
             elif re.match(r"^[Ff]alse$", ifabsent_default_value):
@@ -75,19 +112,19 @@ class IfAbsentProcessor(ABC):
                     f"value"
                 )
 
-        if slot.range == Integer.type_name:
+        if base_type is Integer:
             return self.map_integer_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Float.type_name:
+        if base_type is Float:
             return self.map_float_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Double.type_name:
+        if base_type is Double:
             return self.map_double_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Decimal.type_name:
+        if base_type is Decimal:
             return self.map_decimal_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Time.type_name:
+        if base_type is Time:
             match = re.match(r"^(\d{2}):(\d{2}):(\d{2}).*$", ifabsent_default_value)
             if match:
                 return self.map_time_default_value(match[1], match[2], match[3], slot, cls)
@@ -97,7 +134,7 @@ class IfAbsentProcessor(ABC):
                 )
 
         # TODO manage timezones and offsets
-        if slot.range == Date.type_name:
+        if base_type is Date:
             match = re.match(r"^(\d{4})-(\d{2})-(\d{2})$", ifabsent_default_value)
             if match:
                 return self.map_date_default_value(match[1], match[2], match[3], slot, cls)
@@ -107,7 +144,7 @@ class IfAbsentProcessor(ABC):
                 )
 
         # TODO manage timezones and offsets
-        if slot.range == Datetime.type_name:
+        if base_type is Datetime:
             match = re.match(r"^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}).*$", ifabsent_default_value)
             if match:
                 return self.map_datetime_default_value(
@@ -120,7 +157,7 @@ class IfAbsentProcessor(ABC):
                 )
 
         # TODO manage timezones and offsets
-        if slot.range == DateOrDatetime.type_name:
+        if base_type is DateOrDatetime:
             match = re.match(r"^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2}):(\d{2}))?.*$", ifabsent_default_value)
             if match and (match[4] is None or match[5] is None or match[6] is None):
                 return self.map_date_default_value(match[1], match[2], match[3], slot, cls)
@@ -134,31 +171,31 @@ class IfAbsentProcessor(ABC):
                     f"datetime value"
                 )
 
-        if slot.range == Uri.type_name:
+        if base_type is Uri:
             return self.map_uri_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Curie.type_name:
+        if base_type is Curie:
             return self.map_curie_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Uriorcurie.type_name:
+        if base_type is Uriorcurie:
             return self.map_uri_or_curie_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Ncname.type_name:
+        if base_type is Ncname:
             return self.map_nc_name_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Objectidentifier.type_name:
+        if base_type is Objectidentifier:
             return self.map_object_identifier_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Nodeidentifier.type_name:
+        if base_type is Nodeidentifier:
             return self.map_node_identifier_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Jsonpointer.type_name:
+        if base_type is Jsonpointer:
             return self.map_json_pointer_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Jsonpath.type_name:
+        if base_type is Jsonpath:
             return self.map_json_path_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Sparqlpath.type_name:
+        if base_type is Sparqlpath:
             return self.map_sparql_path_default_value(ifabsent_default_value, slot, cls)
 
         # -----------------------
@@ -173,6 +210,46 @@ class IfAbsentProcessor(ABC):
 
         raise ValueError(f"The ifabsent value `{slot.ifabsent}` of the `{slot.name}` slot could not be processed")
 
+    def _base_type(self, range_: str) -> Optional[TYPES_TYPE]:
+        """
+        Find the linkml base type that corresponds to either a matching type_name or custom type
+
+        First check for an explicit match of the range == TypeDefinition.type_name
+        Then check for explicit inheritance via typeof
+        Finally check for implicit matching via matching base
+
+        Don't raise here, just return None in case another method of resolution like enums are
+        available
+        """
+        # first check for matching type using type_name - ie. range is already a base type
+
+        for typ in TYPES:
+            if range_ == typ.type_name:
+                return typ
+
+        # if we're not a type, return None to indicate that, e.g. if an enum's permissible_value
+        if range_ not in self.schema_view.all_types(imports=True):
+            return
+
+        # then check explicit descendents of types
+        # base types do not inherit from one another, so the last ancestor is always a base type
+        # if it is inheriting from a base type
+        ancestor = self.schema_view.type_ancestors(range_)[-1]
+        for typ in TYPES:
+            if ancestor == typ.type_name:
+                return typ
+
+        # finally check if we have a matching base
+        induced_typ = self.schema_view.induced_type(range_)
+        if induced_typ.repr is None and induced_typ.base is None:
+            return None
+        for typ in TYPES:
+            # types always inherit from a single type, and that type is their base
+            # our range can match it with repr or base
+            typ_base = typ.__mro__[1].__name__
+            if typ_base == induced_typ.base:
+                return typ
+
     @abc.abstractmethod
     def map_custom_default_values(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition) -> (bool, str):
         """

{linkml-1.8.4 → linkml-1.8.6}/linkml/generators/common/lifecycle.py

@@ -13,7 +13,7 @@ from linkml_runtime.linkml_model.meta import (
     TypeDefinition,
 )
 
-from linkml.generators.common.build import ClassResult, RangeResult, SchemaResult, SlotResult, TypeResult
+from linkml.generators.common.build import ClassResult, EnumResult, RangeResult, SchemaResult, SlotResult, TypeResult
 from linkml.generators.common.template import TemplateModel
 
 TSchema = TypeVar("TSchema", bound=SchemaResult)
@@ -21,7 +21,7 @@ TClass = TypeVar("TClass", bound=ClassResult)
 TSlot = TypeVar("TSlot", bound=SlotResult)
 TRange = TypeVar("TRange", bound=RangeResult)
 TType = TypeVar("TType", bound=TypeResult)
-TEnum = TypeVar("TEnum", bound=EnumDefinition)
+TEnum = TypeVar("TEnum", bound=EnumResult)
 TTemplate = TypeVar("TTemplate", bound=TemplateModel)
 
 
@@ -93,6 +93,22 @@ class LifecycleMixin:
     def after_generate_slots(self, slot: Iterable[TSlot], sv: SchemaView) -> Iterable[TSlot]:
         return slot
 
+    def before_generate_class_slot(self, slot: SlotDefinition, cls: ClassDefinition, sv: SchemaView) -> SlotDefinition:
+        return slot
+
+    def after_generate_class_slot(self, slot: TSlot, cls: ClassDefinition, sv: SchemaView) -> TSlot:
+        return slot
+
+    def before_generate_class_slots(
+        self, slot: Iterable[SlotDefinition], cls: ClassDefinition, sv: SchemaView
+    ) -> Iterable[SlotDefinition]:
+        return slot
+
+    def after_generate_class_slots(
+        self, slot: Iterable[TSlot], cls: ClassDefinition, sv: SchemaView
+    ) -> Iterable[TSlot]:
+        return slot
+
     def before_generate_type(self, typ: TypeDefinition, sv: SchemaView) -> TypeDefinition:
         return typ
 

linkml-1.8.6/linkml/generators/common/naming.py

@@ -0,0 +1,106 @@
+import logging
+import re
+import unicodedata
+from enum import Enum
+
+
+class NamingProfiles(str, Enum):
+    # GraphQL naming profile ensures compatibility with the GraphQL specification
+    # WRT names: https://spec.graphql.org/October2021/#Name
+    graphql = "graphql"
+
+
+class NameCompatibility(object):
+    """Make a name compatible to the given profile"""
+
+    # heading double underscores and digit reserved to names starting with a digit
+    re_reserved_heading_digit = re.compile("^__[0-9]")
+    # valid name between double underscores is reserved for unicode name transformations
+    re_reserved_unicode_name_transformation = re.compile("__[0-9a-zA-Z][0-9a-zA-Z_]*__")
+    # something like '__U_xxxx_' is reserved for unicode code transformations
+    re_reserved_unicode_code_transformation = re.compile("__U_[0-9a-eA-E]{4}_")
+    # strings starting with a digit
+    re_heading_digit = re.compile("^[0-9]")
+    # character that is neither alphanumeric nor underscore
+    re_no_alphanum_underscore = re.compile("[^0-9a-zA-Z_]")
+
+    def __init__(self, profile: NamingProfiles, do_not_fix: bool = False):
+        """Specify the naming policy on instantiation"""
+        self.profile = profile
+        self.do_not_fix = do_not_fix
+
+    def _no_heading_digits(self, input: str) -> str:
+        """Ensure name does not start with a heading digit"""
+        output = input
+        if self.re_heading_digit.match(input):
+            if self.do_not_fix:
+                raise ValueError(f"Name '{input}' starts with digit (illegal GraphQL) and will not be fixed!")
+            else:
+                logging.warning(
+                    f"Name '{input}' starts with digit (illegal GraphQL), "
+                    + f"it has been prefixed with '__', resulting in {output}"
+                )
+            output = f"__{input}"
+        return output
+
+    def _transform_char(self, char: str) -> str:
+        """Transform unsupported characters"""
+        if len(char) != 1:
+            raise Exception(f"Single character expected, but got '{char}'!!")
+        # replace whitespaces with underscores
+        # the transformation cannot be inverted, but is a well-established
+        # and expected transformation
+        if char == " ":
+            return "_"
+        # try to use names for ASCII characters
+        if ord(char) < 128:
+            try:
+                # unicodedata.lookup should be able to invert the transformation
+                return f"__{unicodedata.name(char).replace(' ', '_').replace('-', '_')}__"
+            except ValueError:
+                pass
+        # fallback to code-transformation if none of the previous has worked
+        return f"__U_{ord(char):04X}_"
+
+    def _only_alphanum_underscore(self, input: str) -> str:
+        """Ensure name does not contain any unsupported characters"""
+        output = input
+        # with re.split and re.findall we get in the same order and separated in two arrays
+        # the substrings between special characters and the special characters
+        no_alphanum_underscore_match = self.re_no_alphanum_underscore.findall(input)
+        if no_alphanum_underscore_match:
+            if self.do_not_fix:
+                raise ValueError(f"Name '{input}' contains a character illegal in GraphQL and will not be fixed!")
+            else:
+                logging.warning(
+                    f"Name '{input}' contains a character illegal in GraphQL, "
+                    + f"the resulting encoded name is {output}"
+                )
+            to_keep = self.re_no_alphanum_underscore.split(input)
+            # first comes first substring to keep
+            output = to_keep[0]
+            # each char replacement is followed by the next substring to keep
+            for offset in range(0, len(to_keep) - 1):
+                output = output + self._transform_char(no_alphanum_underscore_match[offset])
+                output = output + to_keep[offset + 1]
+        return output
+
+    def _graphql_compatibility(self, input: str) -> str:
+        """Ensure name compatibility with GraphQL name policies"""
+        # as of now, some (hopefully) very rare patterns are reserved to mark transformations
+        if self.re_reserved_heading_digit.match(input):
+            raise NotImplementedError("Names starting with a double underscore followed by a digit are not supported!!")
+        if self.re_reserved_unicode_name_transformation.match(input):
+            raise NotImplementedError("Names containing valid names between double underscores are not supported!!")
+        if self.re_reserved_unicode_code_transformation.match(input):
+            raise NotImplementedError("Names containing strings like '__U_xxxx_' are not supported!!")
+        # apply transformation
+        output = input
+        output = self._no_heading_digits(output)
+        output = self._only_alphanum_underscore(output)
+        return output
+
+    def compatible(self, input: str) -> str:
+        """Make given name compatible with the given naming policy."""
+        if self.profile == "graphql":
+            return self._graphql_compatibility(input)

linkml-1.8.6/linkml/generators/dbmlgen.py

@@ -0,0 +1,173 @@
+import logging
+
+import click
+from linkml_runtime.utils.formatutils import camelcase, underscore
+from linkml_runtime.utils.schemaview import SchemaView
+
+from linkml.utils.generator import Generator
+
+
+def _map_range_to_dbml_type(range_name: str) -> str:
+    """
+    Map LinkML range types to DBML types.
+
+    :param range_name: LinkML range name
+    :return: Corresponding DBML type
+    """
+    type_mapping = {
+        "string": "varchar",
+        "integer": "int",
+        "float": "float",
+        "boolean": "boolean",
+        "date": "date",
+        "datetime": "datetime",
+    }
+    return type_mapping.get(range_name, "varchar")  # Default to varchar
+
+
+class DBMLGenerator(Generator):
+    """
+    A generator for converting a LinkML schema into DBML (Database Markup Language).
+    """
+
+    generatorname = "dbmlgen"
+    generatorversion = "0.2.0"
+    valid_formats = ["dbml"]
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        self.logger = logging.getLogger(__name__)
+        self.schemaview = SchemaView(self.schema)
+
+    def serialize(self) -> str:
+        """
+        Generate DBML representation of the LinkML schema.
+
+        :return: DBML as a string
+        """
+        dbml_lines = [
+            "// DBML generated from LinkML schema\n",
+            f"Project {{\n  name: '{self.schemaview.schema.name}'\n}}\n",
+        ]
+
+        for class_name, class_def in self.schemaview.all_classes().items():
+            dbml_lines.append(self._generate_table(class_name, class_def))
+
+        # Generate relationships if applicable
+        relationships = self._generate_relationships()
+        if relationships:
+            dbml_lines.append(relationships)
+
+        return "\n".join(dbml_lines)
+
+    def _generate_table(self, class_name: str, class_def) -> str:
+        """
+        Generate the DBML for a single class (table).
+
+        :param class_name: Name of the class
+        :param class_def: ClassDefinition object
+        :return: DBML representation of the class
+        """
+        dbml = [f"Table {camelcase(class_name)} {{"]
+
+        for slot_name in self.schemaview.class_induced_slots(class_name):
+            slot = self.schemaview.get_slot(slot_name.name)
+            dbml.append(self._generate_column(slot))
+
+        dbml.append("}\n")
+        return "\n".join(dbml)
+
+    def _generate_column(self, slot) -> str:
+        """
+        Generate the DBML for a single slot (column).
+
+        :param slot: SlotDefinition object
+        :return: DBML representation of the column
+        """
+        column_name = slot.name
+        data_type = _map_range_to_dbml_type(slot.range or "string")
+        constraints = []
+        constraints_str = ""
+
+        if slot.required:
+            constraints.append("not null")
+        if slot.identifier:
+            constraints.append("primary key")
+
+        if constraints:
+            constraints_str = f"{', '.join(constraints)}"
+            constraints_str = "[" + constraints_str + "]"
+
+        return f"  {underscore(column_name)} {data_type} {constraints_str}".strip()
+
+    def _generate_relationships(self) -> str:
+        """
+        Generate DBML relationships based on slot ranges referencing other classes.
+
+        :return: DBML representation of relationships
+        """
+        relationships = []
+        for class_name, class_def in self.schemaview.all_classes().items():
+            for slot_name in self.schemaview.class_induced_slots(class_name):
+                slot = self.schemaview.get_slot(slot_name.name)
+
+                # Check if the slot references another class
+                if slot.range in self.schemaview.all_classes():
+
+                    # Find the identifier slot of the referenced class
+                    identifier_slot_name = next(
+                        (
+                            slot_name.name
+                            for slot_name in self.schemaview.class_induced_slots(slot.range)
+                            if self.schemaview.get_slot(slot_name.name).identifier
+                        ),
+                        None,
+                    )
+
+                    if identifier_slot_name is None:
+                        raise ValueError(f"Referenced class '{slot.range}' does not have an identifier slot.")
+
+                    # Generate the DBML relationship
+                    relationships.append(
+                        f"Ref: {camelcase(class_name)}.{underscore(slot.name)} > "
+                        f"{camelcase(slot.range)}.{underscore(identifier_slot_name)}"
+                    )
+        return "\n".join(relationships)
+
+
+# CLI Definition
+@click.command()
+@click.option(
+    "--schema",
+    "-s",
+    required=True,
+    type=click.Path(exists=True, dir_okay=False, file_okay=True),
+    help="Path to the LinkML schema YAML file",
+)
+@click.option(
+    "--output",
+    "-o",
+    required=False,
+    type=click.Path(dir_okay=False, writable=True),
+    help="Path to save the generated DBML file. If not specified, DBML will be printed to stdout.",
+)
+def cli(schema, output):
+    """
+    CLI for LinkML to DBML generator.
+    """
+    generator = DBMLGenerator(schema)
+
+    # Generate the DBML
+    dbml_output = generator.serialize()
+
+    # Save to file or print to stdout
+    if output:
+        with open(output, "w", encoding="utf-8") as f:
+            f.write(dbml_output)
+        click.echo(f"DBML has been saved to {output}")
+    else:
+        click.echo(dbml_output)
+
+
+if __name__ == "__main__":
+    cli()