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

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/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/generators/docgen.py

@@ -164,6 +164,7 @@ class DocGenerator(Generator):
     use_slot_uris: bool = False
     use_class_uris: bool = False
     hierarchical_class_view: bool = False
+    render_imports: bool = False
 
     def __post_init__(self):
         dialect = self.dialect
@@ -759,7 +760,7 @@ class DocGenerator(Generator):
         Ensures rank is non-null
         :return: iterator
         """
-        elts = self.schemaview.all_classes(imports=self.mergeimports).values()
+        elts = self.schemaview.all_classes(imports=self.render_imports).values()
         _ensure_ranked(elts)
         for e in elts:
             yield e
@@ -771,7 +772,7 @@ class DocGenerator(Generator):
         Ensures rank is non-null
         :return: iterator
         """
-        elts = self.schemaview.all_slots(imports=self.mergeimports).values()
+        elts = self.schemaview.all_slots(imports=self.render_imports).values()
         _ensure_ranked(elts)
         for e in elts:
             yield e
@@ -783,7 +784,7 @@ class DocGenerator(Generator):
         Ensures rank is non-null
         :return: iterator
         """
-        elts = self.schemaview.all_types(imports=self.mergeimports).values()
+        elts = self.schemaview.all_types(imports=self.render_imports).values()
         _ensure_ranked(elts)
         for e in elts:
             yield e
@@ -798,7 +799,7 @@ class DocGenerator(Generator):
         Ensures rank is non-null
         :return: iterator
         """
-        elts = self.schemaview.all_enums(imports=self.mergeimports).values()
+        elts = self.schemaview.all_enums(imports=self.render_imports).values()
         _ensure_ranked(elts)
         for e in elts:
             yield e
@@ -810,7 +811,7 @@ class DocGenerator(Generator):
         Ensures rank is non-null
         :return: iterator
         """
-        elts = self.schemaview.all_subsets(imports=self.mergeimports).values()
+        elts = self.schemaview.all_subsets(imports=self.render_imports).values()
         _ensure_ranked(elts)
         for e in elts:
             yield e
@@ -834,7 +835,7 @@ class DocGenerator(Generator):
         :return: tuples (depth: int, cls: ClassDefinitionName)
         """
         sv = self.schemaview
-        roots = sv.class_roots(mixins=False, imports=self.mergeimports)
+        roots = sv.class_roots(mixins=False, imports=self.render_imports)
 
         # by default the classes are sorted alphabetically
         roots = sorted(roots, key=str.casefold, reverse=True)
@@ -848,7 +849,7 @@ class DocGenerator(Generator):
             depth, class_name = stack.pop()
             yield depth, class_name
             children = sorted(
-                sv.class_children(class_name=class_name, mixins=False, imports=self.mergeimports),
+                sv.class_children(class_name=class_name, mixins=False, imports=self.render_imports),
                 key=str.casefold,
                 reverse=True,
             )
@@ -1008,6 +1009,12 @@ class DocGenerator(Generator):
     default=True,
     help="Render class table on index page in a hierarchically indented view",
 )
+@click.option(
+    "--render-imports/--no-render-imports",
+    default=False,
+    show_default=True,
+    help="Render also the documentation of elements from imported schemas",
+)
 @click.option(
     "--example-directory",
     help="Folder in which example files are found. These are used to make inline examples",
@@ -1037,6 +1044,7 @@ def cli(
     use_class_uris,
     hierarchical_class_view,
     subfolder_type_separation,
+    render_imports,
     **args,
 ):
     """Generate documentation folder from a LinkML YAML schema
@@ -1068,6 +1076,7 @@ def cli(
         hierarchical_class_view=hierarchical_class_view,
         index_name=index_name,
         subfolder_type_separation=subfolder_type_separation,
+        render_imports=render_imports,
         **args,
     )
     print(gen.serialize())

linkml/generators/graphqlgen.py

@@ -1,11 +1,14 @@
+import logging
 import os
+import re
 from dataclasses import dataclass
 
 import click
-from linkml_runtime.linkml_model.meta import ClassDefinition, SlotDefinition
+from linkml_runtime.linkml_model.meta import ClassDefinition, EnumDefinition, SlotDefinition
 from linkml_runtime.utils.formatutils import camelcase, lcamelcase
 
 from linkml._version import __version__
+from linkml.generators.common.naming import NameCompatibility, NamingProfiles
 from linkml.utils.generator import Generator, shared_arguments
 
 
@@ -19,6 +22,13 @@ class GraphqlGenerator(Generator):
     uses_schemaloader = True
     requires_metamodel = False
 
+    strict_naming: bool = False
+    _permissible_value_valid_characters = re.compile("^[_A-Za-z][_0-9A-Za-z]*?$")
+
+    def __post_init__(self):
+        self.name_compatiblity = NameCompatibility(profile=NamingProfiles.graphql, do_not_fix=self.strict_naming)
+        super().__post_init__()
+
     def visit_schema(self, **kwargs) -> str:
         return self.generate_header()
 
@@ -50,13 +60,35 @@ class GraphqlGenerator(Generator):
             slotrange = slotrange + "!"
         return f"\n    {lcamelcase(aliased_slot_name)}: {slotrange}"
 
+    def visit_enum(self, enum: EnumDefinition):
+        if enum.permissible_values:
+            permissible_values = []
+            for value in enum.permissible_values:
+                permissible_values.append(self.name_compatiblity.compatible(value))
+            values = "\n    ".join(permissible_values)
+            return f"enum {camelcase(enum.name).replace(' ','')}\n  {{\n    {values}\n  }}\n\n"
+        else:
+            logging.warning(
+                f"Enumeration {enum.name} using `reachable_from` instead of `permissible_values` "
+                + "to specify permissible values is not supported yet."
+                + "Enumeration {enum.name} will be silently ignored!!"
+            )
+            return ""
+
 
 @shared_arguments(GraphqlGenerator)
 @click.command(name="graphql")
+@click.option(
+    "--strict-naming",
+    is_flag=True,
+    show_default=True,
+    help="Treat warnings about invalid names or schema elements as errors.",
+)
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, **args):
     """Generate graphql representation of a LinkML model"""
-    print(GraphqlGenerator(yamlfile, **args).serialize(**args))
+    generator = GraphqlGenerator(yamlfile, **args)
+    print(generator.serialize(**args))
 
 
 if __name__ == "__main__":

linkml/generators/pydanticgen/template.py

@@ -675,7 +675,18 @@ class PydanticModule(PydanticTemplateModel):
         return [c.name for c in self.classes.values()]
 
 
-_some_stdlib_module_names = {"copy", "datetime", "decimal", "enum", "inspect", "os", "re", "sys", "typing"}
+_some_stdlib_module_names = {
+    "copy",
+    "datetime",
+    "decimal",
+    "enum",
+    "inspect",
+    "os",
+    "re",
+    "sys",
+    "typing",
+    "dataclasses",
+}
 """
 sys.stdlib_module_names is only present in 3.10 and later
 so we make a cheap copy of the stdlib modules that we commonly use here,

linkml/generators/python/python_ifabsent_processor.py

@@ -71,7 +71,7 @@ class PythonIfAbsentProcessor(IfAbsentProcessor):
     def map_enum_default_value(
         self, enum_name: EnumDefinitionName, permissible_value_name: str, slot: SlotDefinition, cls: ClassDefinition
     ):
-        return f"{enum_name}.{permissible_value_name}"
+        return f"'{permissible_value_name}'"
 
     def map_nc_name_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
         raise NotImplementedError()

linkml/generators/pythongen.py

@@ -29,6 +29,7 @@ from rdflib import URIRef
 
 import linkml
 from linkml._version import __version__
+from linkml.generators.pydanticgen.template import Import, Imports, ObjectImport
 from linkml.generators.python.python_ifabsent_processor import PythonIfAbsentProcessor
 from linkml.utils.generator import Generator, shared_arguments
 
@@ -127,13 +128,120 @@ class PythonGenerator(Generator):
                 self.emit_prefixes.add(type_prefix)
 
     def gen_schema(self) -> str:
+        all_imports = Imports()
+        # generic imports
+        all_imports = (
+            all_imports
+            + Import(module="dataclasses")
+            + Import(module="re")
+            + Import(
+                module="jsonasobj2",
+                objects=[
+                    ObjectImport(name="JsonObj"),
+                    ObjectImport(name="as_dict"),
+                ],
+            )
+            + Import(
+                module="typing",
+                objects=[
+                    ObjectImport(name="Optional"),
+                    ObjectImport(name="List"),
+                    ObjectImport(name="Union"),
+                    ObjectImport(name="Dict"),
+                    ObjectImport(name="ClassVar"),
+                    ObjectImport(name="Any"),
+                ],
+            )
+            + Import(
+                module="dataclasses",
+                objects=[
+                    ObjectImport(name="dataclass"),
+                ],
+            )
+            + Import(
+                module="datetime",
+                objects=[
+                    ObjectImport(name="date"),
+                    ObjectImport(name="datetime"),
+                    ObjectImport(name="time"),
+                ],
+            )
+        )
+
         # The metamodel uses Enumerations to define itself, so don't import if we are generating the metamodel
-        enumimports = (
-            ""
-            if self.genmeta
-            else "from linkml_runtime.linkml_model.meta import EnumDefinition, PermissibleValue, PvFormulaOptions\n"
+        if not self.genmeta:
+            all_imports = all_imports + Import(
+                module="linkml_runtime.linkml_model.meta",
+                objects=[
+                    ObjectImport(name="EnumDefinition"),
+                    ObjectImport(name="PermissibleValue"),
+                    ObjectImport(name="PvFormulaOptions"),
+                ],
+            )
+        # linkml imports
+        all_imports = (
+            all_imports
+            + Import(
+                module="linkml_runtime.utils.slot",
+                objects=[
+                    ObjectImport(name="Slot"),
+                ],
+            )
+            + Import(
+                module="linkml_runtime.utils.metamodelcore",
+                objects=[
+                    ObjectImport(name="empty_list"),
+                    ObjectImport(name="empty_dict"),
+                    ObjectImport(name="bnode"),
+                ],
+            )
+            + Import(
+                module="linkml_runtime.utils.yamlutils",
+                objects=[
+                    ObjectImport(name="YAMLRoot"),
+                    ObjectImport(name="extended_str"),
+                    ObjectImport(name="extended_float"),
+                    ObjectImport(name="extended_int"),
+                ],
+            )
+            + Import(
+                module="linkml_runtime.utils.dataclass_extensions_376",
+                objects=[
+                    ObjectImport(name="dataclasses_init_fn_with_kwargs"),
+                ],
+            )
+            + Import(
+                module="linkml_runtime.utils.formatutils",
+                objects=[
+                    ObjectImport(name="camelcase"),
+                    ObjectImport(name="underscore"),
+                    ObjectImport(name="sfx"),
+                ],
+            )
+        )
+
+        # handler import
+        all_imports = all_imports + Import(
+            module="linkml_runtime.utils.enumerations", objects=[ObjectImport(name="EnumDefinitionImpl")]
+        )
+        # other imports
+        all_imports = (
+            all_imports
+            + Import(
+                module="rdflib",
+                objects=[
+                    ObjectImport(name="Namespace"),
+                    ObjectImport(name="URIRef"),
+                ],
+            )
+            + Import(
+                module="linkml_runtime.utils.curienamespace",
+                objects=[
+                    ObjectImport(name="CurieNamespace"),
+                ],
+            )
         )
-        handlerimport = "from linkml_runtime.utils.enumerations import EnumDefinitionImpl"
+
         split_description = ""
         if self.schema.description:
             split_description = "\n#   ".join(d for d in self.schema.description.split("\n") if d is not None)
@@ -151,21 +259,7 @@ class PythonGenerator(Generator):
 # description: {split_description}
 # license: {be(self.schema.license)}
 
-import dataclasses
-import re
-from jsonasobj2 import JsonObj, as_dict
-from typing import Optional, List, Union, Dict, ClassVar, Any
-from dataclasses import dataclass
-from datetime import date, datetime, time
-{enumimports}
-from linkml_runtime.utils.slot import Slot
-from linkml_runtime.utils.metamodelcore import empty_list, empty_dict, bnode
-from linkml_runtime.utils.yamlutils import YAMLRoot, extended_str, extended_float, extended_int
-from linkml_runtime.utils.dataclass_extensions_376 import dataclasses_init_fn_with_kwargs
-from linkml_runtime.utils.formatutils import camelcase, underscore, sfx
-{handlerimport}
-from rdflib import Namespace, URIRef
-from linkml_runtime.utils.curienamespace import CurieNamespace
+{all_imports.render()}
 {self.gen_imports()}
 
 metamodel_version = "{self.schema.metamodel_version}"
@@ -836,7 +930,15 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
             ):
                 rlines.append(f"\tself.{aliased_slot_name} = {base_type_name}()")
             else:
-                if (
+                if slot.range in self.schema.enums and slot.ifabsent:
+                    # `ifabsent` for an enumeration cannot be assigned to
+                    # the dataclass field default, because it would be a
+                    # mutable. `python_ifabsent_processor.py` can specify
+                    # the default as string and here that string gets
+                    # converted into an object attribute invocation
+                    # TODO: fix according https://github.com/linkml/linkml/pull/2329#discussion_r1797534588
+                    rlines.append(f"\tself.{aliased_slot_name} = getattr({slot.range}, self.{aliased_slot_name})")
+                elif (
                     (self.class_identifier(slot.range) and not slot.inlined)
                     or slot.range in self.schema.types
                     or slot.range in self.schema.enums

{linkml-1.8.4.dist-info → linkml-1.8.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml
-Version: 1.8.4
+Version: 1.8.5
 Summary: Linked Open Data Modeling Language
 Home-page: https://linkml.io/linkml/
 Keywords: schema,linked data,data modeling,rdf,owl,biolink

{linkml-1.8.4.dist-info → linkml-1.8.5.dist-info}/RECORD

@@ -8,8 +8,9 @@ linkml/generators/README.md,sha256=RMzT8EblC_GEdPy5WyfXHDBXlFI6k6mz3Cx2sdpcyWI,4
 linkml/generators/__init__.py,sha256=2qSOnibL6KtzBW3KNqVX1gx1LQttrXlOPbbVDLLV2go,1587
 linkml/generators/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 linkml/generators/common/build.py,sha256=hXf2gf1ox2hiR-D6N-qXt5w5QkISLlo1A-_GurY3yHo,2897
-linkml/generators/common/ifabsent_processor.py,sha256=D8vKZLa15mc_SUyvFsE3NZfWi-c4kawYW6WdGozJLRQ,11275
+linkml/generators/common/ifabsent_processor.py,sha256=hVm6mKq8qciL5Fa53TAtGO8ZJnbRuktvJnaA6-HutTk,13533
 linkml/generators/common/lifecycle.py,sha256=UOJXlIyWQkvsn0Dao9_ZDzlamJtiINyVJQ6SRj66L9s,4910
+linkml/generators/common/naming.py,sha256=AsLJ7e87TU_SnAM0Sy7q9HZc-qXvyIuqHt1CoHV-Y3Y,5089
 linkml/generators/common/template.py,sha256=bjcSNiC85MYl9oGhk0ZpqwZpRxxy_NqxG8XBV-TXXDY,3338
 linkml/generators/common/type_designators.py,sha256=lgVcIRJJ-yCvVGeP9U_gQZpm77UmJBQo9Bh3lGJITno,1956
 linkml/generators/csvgen.py,sha256=O20K3IuDxomGJAyNFJmm1_HbPyl6xUK0l-aKY0A3KcM,3253
@@ -23,13 +24,13 @@ linkml/generators/docgen/schema.md.jinja2,sha256=xlENfnzNRYgPT_0tdqNFxgklVM4Qf5B
 linkml/generators/docgen/slot.md.jinja2,sha256=dJHugIv9OPTi3FIn8Iez7CzjQizdXrcn0hcmCmXSgV4,3339
 linkml/generators/docgen/subset.md.jinja2,sha256=EPln_fjlhlkmwEGEp2iPX-9Xm2vVodPZLlRBlYCB_sA,2705
 linkml/generators/docgen/type.md.jinja2,sha256=QmCMJZrFwP33eHkggBVtypbyrxTb-XZn9vHOYojVaYk,635
-linkml/generators/docgen.py,sha256=SAkqAZxbzHqzKrX3JQpRJr51bdr2gQKs6Bs1h-aVrmI,38711
+linkml/generators/docgen.py,sha256=iDSu2LsZ7MStrzXdxFwK-oBlVevq2MwBc1n5WzHzTyw,38996
 linkml/generators/dotgen.py,sha256=vjHveFtKBItHRkowi1I4FHffcn4u4wLpBydYgVxB-vE,5028
 linkml/generators/erdiagramgen.py,sha256=5_VEPvRL0I819wCjk7T5hWffdBPc_qw3XpQdOYpO7uE,11357
 linkml/generators/excelgen.py,sha256=MQRRm1wDbg7auUQH9tGb5aRyrp-e4gjXsY10aoLb9LI,7708
 linkml/generators/golanggen.py,sha256=Qx1GZRIrKn8jNoO-8fJMjkrwV9ZLwR4NwYBW5kGGp9c,5840
 linkml/generators/golrgen.py,sha256=JB92VDhTuwyaOyxHxB4goIsjZbq4NMf36ESprC3GeBs,3454
-linkml/generators/graphqlgen.py,sha256=-BS-UHPyHqauUgtgcFCO4xSxxogk7BPAQFSXHIrKJT0,2163
+linkml/generators/graphqlgen.py,sha256=belU4f89vBHoHBipaMkHiE_ND42IV7L0Zp4akL9sQWk,3484
 linkml/generators/javagen/example_template.java.jinja2,sha256=ec4CVTv_0zS7V5Y-1E6H4lRraya10gfX7BEMBlu38X4,444
 linkml/generators/javagen/java_record_template.jinja2,sha256=OQZffLSy_xR3FIhQMltvrYyVeut7l2Q-tzK7AOiVmWs,1729
 linkml/generators/javagen.py,sha256=BTAXgvOOvRa3AOfaaiVFyuyaqg4XFR_JbO6_7tT_AnQ,5335
@@ -52,7 +53,7 @@ linkml/generators/pydanticgen/black.py,sha256=BaJ7b-kMUbIN_cKRT3yCaMEbFwxzj1_U7w
 linkml/generators/pydanticgen/build.py,sha256=xWNnxaNz0LqfNpgUuaUeVdvmXyFASwv5QED3bEaUVaM,4093
 linkml/generators/pydanticgen/includes.py,sha256=kDAwonKbhTFzrFa2TrmTYuOSHXuzDy5WHgBaI5nVY6c,504
 linkml/generators/pydanticgen/pydanticgen.py,sha256=IEmSPr9zu1dkgIMFvVKDswokhQvM_weXdmVNQ3l3eNQ,49938
-linkml/generators/pydanticgen/template.py,sha256=7EZD_niU9bnkmtNG7zTBjLtQ5kUbKkBsidQP0X8UxFI,24828
+linkml/generators/pydanticgen/template.py,sha256=wjUMiTay_EFh8zp5LfytBsgZJGlKjV96PVnBgI21KVc,24886
 linkml/generators/pydanticgen/templates/attribute.py.jinja,sha256=uMyVKpO5uQkAFlIvIBwA6FFZl_BSIotfwCorrSwMA3Q,873
 linkml/generators/pydanticgen/templates/base_model.py.jinja,sha256=6KRQ1ZVHh1uwZnYL3qxBnyit8_DNE7D-4l2-1wsRsG0,406
 linkml/generators/pydanticgen/templates/class.py.jinja,sha256=GqR2t5y0vLmvUpT2vyP5VX42PO9AkAnGE-U2RZPa9AI,690
@@ -63,8 +64,8 @@ linkml/generators/pydanticgen/templates/imports.py.jinja,sha256=vwAOWV98rM4reAUX
 linkml/generators/pydanticgen/templates/module.py.jinja,sha256=hqZKsJ72yUioBkZAunscVgLSe58OFHf0z6-so_b43U4,526
 linkml/generators/pydanticgen/templates/validator.py.jinja,sha256=5vDpqdfxLpie4BzcyjE82agO6NsThIZjNlcz6gq_kFg,465
 linkml/generators/python/__init__.py,sha256=NS9fPEuAo0punDplD91F9mcViXMJJv04Q5NkFcKPNvY,40
-linkml/generators/python/python_ifabsent_processor.py,sha256=a98JCbMsR_Fsdaw8s299-0jFhE0V6F4zLl326ITA7lQ,3848
-linkml/generators/pythongen.py,sha256=pOGoLvF-MxshwS-UJbIvqogWSwr4-sqhhpW5LMzRhbQ,52634
+linkml/generators/python/python_ifabsent_processor.py,sha256=io-bLevkdy2xgKl0kqGB3o5iR7O7P1uE4qWEhKt-GcM,3838
+linkml/generators/pythongen.py,sha256=-W8ZgvgDP-Hm4Q9weQiB7xtXMJyadtyfZ6BHC1CmClw,56127
 linkml/generators/rdfgen.py,sha256=OT8oS8MPUVf5UK3OKvRWgAh9iQiWwdyWJSA69PncOw4,2969
 linkml/generators/shacl/__init__.py,sha256=KgMOyESGTdKk2Vhx9uuUYgEJPuJQ-iT1vDQVIMoiXCM,58
 linkml/generators/shacl/shacl_data_type.py,sha256=gX3Y2KyTVPwMyef0cJMTEpU9h0oH-H0ThVDORdNW170,1828
@@ -152,8 +153,8 @@ linkml/workspaces/datamodel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 linkml/workspaces/datamodel/workspaces.py,sha256=4HdkqweGNfMPqnB1_Onc9DcTfkhoagTRcqruh08nRoI,14905
 linkml/workspaces/datamodel/workspaces.yaml,sha256=EjVrwPpeRZqJRjuGyyDRxxFzuv55SiLIXPBRUG6HStU,4233
 linkml/workspaces/example_runner.py,sha256=T7sHQetV6a-dG5Kjuh2L4rHQ6-SPG3Kj1J1nPB_1uoQ,11757
-linkml-1.8.4.dist-info/LICENSE,sha256=kORMoywK6j9_iy0UvLR-a80P1Rvc9AOM4gsKlUNZABg,535
-linkml-1.8.4.dist-info/METADATA,sha256=G7CFrUedBRAKCg2p1-QuO9aA7KgVCh0n48KlZ1RjuZc,3873
-linkml-1.8.4.dist-info/entry_points.txt,sha256=jvnPJ8UTca4_L-Dh8OdUm5td8I3ZFlKRhMPjqRLtaSg,2084
-linkml-1.8.4.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-linkml-1.8.4.dist-info/RECORD,,
+linkml-1.8.5.dist-info/LICENSE,sha256=kORMoywK6j9_iy0UvLR-a80P1Rvc9AOM4gsKlUNZABg,535
+linkml-1.8.5.dist-info/entry_points.txt,sha256=jvnPJ8UTca4_L-Dh8OdUm5td8I3ZFlKRhMPjqRLtaSg,2084
+linkml-1.8.5.dist-info/METADATA,sha256=9isA7CyNTTGO9A1qH-RvsfN0TH2JGw6ss0RBEwuRa5k,3873
+linkml-1.8.5.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+linkml-1.8.5.dist-info/RECORD,,