linkml 1.8.2__py3-none-any.whl → 1.8.3__py3-none-any.whl

linkml/cli/main.py

@@ -6,6 +6,7 @@ Gathers all the other linkml click entrypoints and puts them under ``linkml`` :)
 
 import click
 
+from linkml._version import __version__
 from linkml.generators.csvgen import cli as gen_csv
 from linkml.generators.docgen import cli as gen_doc
 from linkml.generators.dotgen import cli as gen_graphviz
@@ -54,6 +55,7 @@ from linkml.workspaces.example_runner import cli as linkml_run_examples
 
 
 @click.group()
+@click.version_option(__version__, "-V", "--version")
 def linkml():
     """
     LinkML: A flexible linked data modeling language
@@ -61,6 +63,7 @@ def linkml():
 
 
 @linkml.group()
+@click.version_option(__version__, "-V", "--version")
 def generate():
     """
     Generate formats from a LinkML schema
@@ -68,6 +71,7 @@ def generate():
 
 
 @linkml.group()
+@click.version_option(__version__, "-V", "--version")
 def dev():
     """
     Helper tools for linkml development

linkml/generators/common/ifabsent_processor.py

@@ -0,0 +1,286 @@
+import abc
+import re
+from abc import ABC
+from typing import Any, Optional
+
+from linkml_runtime import SchemaView
+from linkml_runtime.linkml_model import (
+    Boolean,
+    ClassDefinition,
+    Date,
+    Datetime,
+    Decimal,
+    Double,
+    EnumDefinitionName,
+    Float,
+    Integer,
+    SlotDefinition,
+    String,
+    Time,
+    Uri,
+)
+from linkml_runtime.linkml_model.types import (
+    Curie,
+    DateOrDatetime,
+    Jsonpath,
+    Jsonpointer,
+    Ncname,
+    Nodeidentifier,
+    Objectidentifier,
+    Sparqlpath,
+    Uriorcurie,
+)
+
+
+class IfAbsentProcessor(ABC):
+    """
+    Processes value of ifabsent slot.
+
+    See `<https://w3id.org/linkml/ifabsent>`_.
+    """
+
+    ifabsent_regex = re.compile("""(?:(?P<type>\w+)\()?[\"\']?(?P<default_value>[^\(\)\"\')]*)[\"\']?\)?""")
+
+    def __init__(self, schema_view: SchemaView):
+        self.schema_view = schema_view
+
+    def process_slot(self, slot: SlotDefinition, cls: ClassDefinition) -> Optional[str]:
+        if slot.ifabsent:
+            ifabsent_match = self.ifabsent_regex.search(slot.ifabsent)
+            ifabsent_default_value = ifabsent_match.group("default_value")
+
+            return self._map_to_default_value(slot, ifabsent_default_value, cls)
+
+        return None
+
+    def _map_to_default_value(
+        self, slot: SlotDefinition, ifabsent_default_value: Any, cls: ClassDefinition
+    ) -> Optional[str]:
+        # Used to manage specific cases that aren't generic
+        mapped, custom_default_value = self.map_custom_default_values(ifabsent_default_value, slot, cls)
+        if mapped:
+            return custom_default_value
+
+        if slot.range == String.type_name:
+            return self.map_string_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Boolean.type_name:
+            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):
+                return self.map_boolean_false_default_value(slot, cls)
+            else:
+                raise ValueError(
+                    f"The ifabsent value `{slot.ifabsent}` of the `{slot.name}` slot does not match a valid boolean "
+                    f"value"
+                )
+
+        if slot.range == Integer.type_name:
+            return self.map_integer_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Float.type_name:
+            return self.map_float_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Double.type_name:
+            return self.map_double_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Decimal.type_name:
+            return self.map_decimal_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Time.type_name:
+            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)
+            else:
+                raise ValueError(
+                    f"The ifabsent value `{slot.ifabsent}` of the `{slot.name}` slot does not match a valid time value"
+                )
+
+        # TODO manage timezones and offsets
+        if slot.range == Date.type_name:
+            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)
+            else:
+                raise ValueError(
+                    f"The ifabsent value `{slot.ifabsent}` of the `{slot.name}` slot does not match a valid date value"
+                )
+
+        # TODO manage timezones and offsets
+        if slot.range == Datetime.type_name:
+            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(
+                    match[1], match[2], match[3], match[4], match[5], match[6], slot, cls
+                )
+            else:
+                raise ValueError(
+                    f"The ifabsent value `{slot.ifabsent}` of the `{slot.name}` slot does not match a valid datetime "
+                    f"value"
+                )
+
+        # TODO manage timezones and offsets
+        if slot.range == DateOrDatetime.type_name:
+            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)
+            elif match:
+                return self.map_datetime_default_value(
+                    match[1], match[2], match[3], match[4], match[5], match[6], slot, cls
+                )
+            else:
+                raise ValueError(
+                    f"The ifabsent value `{slot.ifabsent}` of the `{slot.name}` slot does not match a valid date or "
+                    f"datetime value"
+                )
+
+        if slot.range == Uri.type_name:
+            return self.map_uri_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Curie.type_name:
+            return self.map_curie_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Uriorcurie.type_name:
+            return self.map_uri_or_curie_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Ncname.type_name:
+            return self.map_nc_name_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Objectidentifier.type_name:
+            return self.map_object_identifier_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Nodeidentifier.type_name:
+            return self.map_node_identifier_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Jsonpointer.type_name:
+            return self.map_json_pointer_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Jsonpath.type_name:
+            return self.map_json_path_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Sparqlpath.type_name:
+            return self.map_sparql_path_default_value(ifabsent_default_value, slot, cls)
+
+        # -----------------------
+        #    Enum slot ranges
+        # -----------------------
+
+        for enum_name, enum in self.schema_view.all_enums().items():
+            if enum_name == slot.range:
+                for permissible_value_name, permissible_value in enum.permissible_values.items():
+                    if permissible_value_name == ifabsent_default_value:
+                        return self.map_enum_default_value(enum_name, permissible_value_name, slot, cls)
+
+        raise ValueError(f"The ifabsent value `{slot.ifabsent}` of the `{slot.name}` slot could not be processed")
+
+    @abc.abstractmethod
+    def map_custom_default_values(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition) -> (bool, str):
+        """
+        Maps custom default values that aren't generic behaviours.
+
+        @param default_value: the default value extracted from the ifabsent attribute
+        @param slot: the definition of the slot
+        @param cls: the definition of the class
+        @return: a boolean that indicates if the value has been mapped followed by the mapped value
+        """
+        return False, None
+
+    @abc.abstractmethod
+    def map_string_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_integer_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_boolean_true_default_value(self, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_boolean_false_default_value(self, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_float_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_double_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_decimal_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_time_default_value(self, hour: str, minutes: str, seconds: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_date_default_value(self, year: str, month: str, day: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_datetime_default_value(
+        self,
+        year: str,
+        month: str,
+        day: str,
+        hour: str,
+        minutes: str,
+        seconds: str,
+        slot: SlotDefinition,
+        cls: ClassDefinition,
+    ):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_uri_or_curie_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_curie_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_uri_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_nc_name_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_object_identifier_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_node_identifier_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_json_pointer_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_json_path_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_sparql_path_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_enum_default_value(
+        self, enum_name: EnumDefinitionName, permissible_value_name: str, slot: SlotDefinition, cls: ClassDefinition
+    ):
+        raise NotImplementedError()
+
+    def _uri_for(self, s: str) -> str:
+        uri = str(self.schema_view.namespaces().uri_for(s))
+        return self.schema_view.namespaces().curie_for(uri, True, True) or self._strval(uri)
+
+    def _strval(self, txt: str) -> str:
+        txt = str(txt).replace('"', '\\"')
+        return f'"{txt}"'

linkml/generators/jsonldcontextgen.py

@@ -21,7 +21,6 @@ from linkml.utils.generator import Generator, shared_arguments
 URI_RANGES = (SHEX.nonliteral, SHEX.bnode, SHEX.iri)
 
 ENUM_CONTEXT = {
-    "@vocab": "@null",
     "text": "skos:notation",
     "description": "skos:prefLabel",
     "meaning": "@id",

linkml/generators/pydanticgen/pydanticgen.py

@@ -41,9 +41,9 @@ from linkml.generators.pydanticgen.template import (
     PydanticModule,
     PydanticTemplateModel,
 )
+from linkml.generators.python.python_ifabsent_processor import PythonIfAbsentProcessor
 from linkml.utils import deprecation_warning
 from linkml.utils.generator import shared_arguments
-from linkml.utils.ifabsent_functions import ifabsent_value_declaration
 
 if int(PYDANTIC_VERSION[0]) == 1:
     deprecation_warning("pydantic-v1")
@@ -67,7 +67,9 @@ def _get_pyrange(t: TypeDefinition, sv: SchemaView) -> str:
 DEFAULT_IMPORTS = (
     Imports()
     + Import(module="__future__", objects=[ObjectImport(name="annotations")])
-    + Import(module="datetime", objects=[ObjectImport(name="datetime"), ObjectImport(name="date")])
+    + Import(
+        module="datetime", objects=[ObjectImport(name="datetime"), ObjectImport(name="date"), ObjectImport(name="time")]
+    )
     + Import(module="decimal", objects=[ObjectImport(name="Decimal")])
     + Import(module="enum", objects=[ObjectImport(name="Enum")])
     + Import(module="re")
@@ -526,6 +528,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         """
         if self._predefined_slot_values is None:
             sv = self.schemaview
+            ifabsent_processor = PythonIfAbsentProcessor(sv)
             slot_values = defaultdict(dict)
             for class_def in sv.all_classes().values():
                 for slot_name in sv.class_slots(class_def.name):
@@ -541,10 +544,10 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
                             slot.name
                         ]
                     elif slot.ifabsent is not None:
-                        value = ifabsent_value_declaration(slot.ifabsent, sv, class_def, slot)
+                        value = ifabsent_processor.process_slot(slot, class_def)
                         slot_values[camelcase(class_def.name)][slot.name] = value
 
-            self._predefined_slot_values = slot_values
+                self._predefined_slot_values = slot_values
 
         return self._predefined_slot_values
 
@@ -1061,7 +1064,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         # interpret all imported schema paths as relative to that
         output_path.parent.mkdir(parents=True, exist_ok=True)
         serialized = generator.serialize(rendered_module=rendered)
-        with open(output_path, "w") as ofile:
+        with open(output_path, "w", encoding="utf-8") as ofile:
             ofile.write(serialized)
 
         results.append(
@@ -1080,7 +1083,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
             rel_path = _import_to_path(generated_import.module)
             abs_path = (output_path.parent / rel_path).resolve()
             abs_path.parent.mkdir(parents=True, exist_ok=True)
-            with open(abs_path, "w") as ofile:
+            with open(abs_path, "w", encoding="utf-8") as ofile:
                 ofile.write(serialized)
 
             results.append(
@@ -1123,7 +1126,7 @@ def _ensure_inits(paths: List[Path]):
     common_path = Path(os.path.commonpath(paths))
 
     if not (ipath := (common_path / "__init__.py")).exists():
-        with open(ipath, "w") as ifile:
+        with open(ipath, "w", encoding="utf-8") as ifile:
             ifile.write(" \n")
 
     for path in paths:
@@ -1131,7 +1134,7 @@ def _ensure_inits(paths: List[Path]):
         path = path.parent
         while path != common_path:
             if not (ipath := (path / "__init__.py")).exists():
-                with open(ipath, "w") as ifile:
+                with open(ipath, "w", encoding="utf-8") as ifile:
                     ifile.write(" \n")
             path = path.parent
 

linkml/generators/python/__init__.py

@@ -0,0 +1 @@
+__all__ = ["python_ifabsent_processor"]

linkml/generators/python/python_ifabsent_processor.py

@@ -0,0 +1,92 @@
+from linkml_runtime.linkml_model import (
+    ClassDefinition,
+    EnumDefinitionName,
+    SlotDefinition,
+)
+
+from linkml.generators.common.ifabsent_processor import IfAbsentProcessor
+
+
+class PythonIfAbsentProcessor(IfAbsentProcessor):
+    UNIMPLEMENTED_DEFAULT_VALUES = ["class_curie", "class_uri", "slot_uri", "slot_curie", "default_range", "default_ns"]
+
+    def map_custom_default_values(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition) -> (bool, str):
+        if default_value in self.UNIMPLEMENTED_DEFAULT_VALUES:
+            return True, None
+
+        if default_value == "bnode":
+            return True, "bnode()"
+
+        return False, None
+
+    def map_string_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return self._strval(default_value)
+
+    def map_boolean_true_default_value(self, slot: SlotDefinition, cls: ClassDefinition):
+        return "True"
+
+    def map_boolean_false_default_value(self, slot: SlotDefinition, cls: ClassDefinition):
+        return "False"
+
+    def map_integer_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return default_value
+
+    def map_float_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return default_value
+
+    def map_double_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return default_value
+
+    def map_decimal_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return default_value
+
+    def map_time_default_value(self, hour: str, minutes: str, seconds: str, slot: SlotDefinition, cls: ClassDefinition):
+        return f"time({int(hour)}, {int(minutes)}, {int(seconds)})"
+
+    def map_date_default_value(self, year: str, month: str, day: str, slot: SlotDefinition, cls: ClassDefinition):
+        return f"date({int(year)}, {int(month)}, {int(day)})"
+
+    def map_datetime_default_value(
+        self,
+        year: str,
+        month: str,
+        day: str,
+        hour: str,
+        minutes: str,
+        seconds: str,
+        slot: SlotDefinition,
+        cls: ClassDefinition,
+    ):
+        return f"datetime({int(year)}, {int(month)}, {int(day)}, " f"{int(hour)}, {int(minutes)}, {int(seconds)})"
+
+    def map_uri_or_curie_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return self._uri_for(default_value)
+
+    def map_curie_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return self._uri_for(default_value)
+
+    def map_uri_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return self._uri_for(default_value)
+
+    def map_enum_default_value(
+        self, enum_name: EnumDefinitionName, permissible_value_name: str, slot: SlotDefinition, cls: ClassDefinition
+    ):
+        return f"{enum_name}.{permissible_value_name}"
+
+    def map_nc_name_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_object_identifier_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_node_identifier_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_json_pointer_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_json_path_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_sparql_path_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()

linkml/generators/pythongen.py

@@ -29,8 +29,8 @@ from rdflib import URIRef
 
 import linkml
 from linkml._version import __version__
+from linkml.generators.python.python_ifabsent_processor import PythonIfAbsentProcessor
 from linkml.utils.generator import Generator, shared_arguments
-from linkml.utils.ifabsent_functions import ifabsent_postinit_declaration, ifabsent_value_declaration
 
 
 @dataclass
@@ -70,6 +70,7 @@ class PythonGenerator(Generator):
             self.schema = str(self.schema)
         self.sourcefile = self.schema
         self.schemaview = SchemaView(self.schema, base_dir=self.base_dir)
+        self.ifabsent_processor = PythonIfAbsentProcessor(self.schemaview)
         super().__post_init__()
         if self.format is None:
             self.format = self.valid_formats[0]
@@ -153,7 +154,7 @@ 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
+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
@@ -515,7 +516,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
 
         return "\n\t".join(initializers)
 
-    def gen_class_variable(self, cls: ClassDefinition, slot: SlotDefinition, can_be_positional: bool) -> str:
+    def gen_class_variable(self, cls: ClassDefinition, slot: SlotDefinition, can_be_positional: bool = False) -> str:
         """
         Generate a class variable declaration for the supplied slot.  Note: the can_be_positional attribute works,
         but it makes tag/value lists unduly complex, as you can't load them with tag=..., value=... -- you HAVE
@@ -527,12 +528,9 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
         :param can_be_positional: True means that positional parameters are allowed.
         :return: Initializer string
         """
-        can_be_positional = False  # Force everything to be tag values
         slotname = self.slot_name(slot.name)
         slot_range, default_val = self.range_cardinality(slot, cls, can_be_positional)
-        ifabsent_text = (
-            ifabsent_value_declaration(slot.ifabsent, self, cls, slot) if slot.ifabsent is not None else None
-        )
+        ifabsent_text = self.ifabsent_processor.process_slot(slot, cls) if slot.ifabsent is not None else None
         if ifabsent_text is not None:
             default = f"= {ifabsent_text}"
         else:
@@ -637,15 +635,6 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
 
     def gen_postinits(self, cls: ClassDefinition) -> str:
         """Generate all the typing and existence checks post initialize"""
-        post_inits_pre_super = []
-        for slot in self.domain_slots(cls):
-            if slot.ifabsent:
-                dflt = ifabsent_postinit_declaration(slot.ifabsent, self, cls, slot)
-
-                if dflt and dflt != "None":
-                    post_inits_pre_super.append(f"if self.{self.slot_name(slot.name)} is None:")
-                    post_inits_pre_super.append(f"\tself.{self.slot_name(slot.name)} = {dflt}")
-
         post_inits = []
         if not (cls.mixin or cls.abstract):
             pkeys = self.primary_keys_for(cls)
@@ -676,20 +665,17 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
             if slot.name not in domain_slot_names and slot.designates_type:
                 post_inits_designators.append(self.gen_postinit(cls, slot))
 
-        post_inits_pre_super_line = "\n\t\t".join([p for p in post_inits_pre_super if p]) + (
-            "\n\t\t" if post_inits_pre_super else ""
-        )
         post_inits_post_super_line = "\n\t\t".join(post_inits_designators)
         post_inits_line = "\n\t\t".join([p for p in post_inits if p])
         return (
             (
                 f"""
     def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
-        {post_inits_pre_super_line}{post_inits_line}
+        {post_inits_line}
         super().__post_init__(**kwargs)
         {post_inits_post_super_line}"""
             )
-            if post_inits_line or post_inits_pre_super_line or post_inits_post_super_line
+            if post_inits_line or post_inits_post_super_line
             else ""
         )
 

linkml/generators/shacl/__init__.py

@@ -1,3 +1 @@
-from linkml.generators.shacl import ifabsent_processor
-
-__all__ = ["shacl_data_type", "ifabsent_processor"]
+__all__ = ["shacl_data_type", "shacl_ifabsent_processor"]

linkml/generators/shacl/shacl_data_type.py

@@ -20,7 +20,7 @@ class ShaclDataType(DataType, Enum):
     FLOAT = ("float", URIRef("http://www.w3.org/2001/XMLSchema#float"))
     DOUBLE = ("double", URIRef("http://www.w3.org/2001/XMLSchema#double"))
     URI = ("uri", URIRef("http://www.w3.org/2001/XMLSchema#anyURI"))
-    CURI = ("curi", URIRef("http://www.w3.org/2001/XMLSchema#string"))
+    CURIE = ("curi", URIRef("http://www.w3.org/2001/XMLSchema#string"))
     NCNAME = ("ncname", URIRef("http://www.w3.org/2001/XMLSchema#string"))
     OBJECT_IDENTIFIER = ("objectidentifier", URIRef("http://www.w3.org/ns/shex#iri"))
     NODE_IDENTIFIER = ("nodeidentifier", URIRef("http://www.w3.org/ns/shex#nonLiteral"))

linkml/generators/shacl/shacl_ifabsent_processor.py

@@ -0,0 +1,89 @@
+from linkml_runtime.linkml_model import ClassDefinition, EnumDefinitionName, SlotDefinition
+from rdflib import Literal, URIRef
+
+from linkml.generators.common.ifabsent_processor import IfAbsentProcessor
+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)
+            if class_uri:
+                return True, URIRef(class_uri)
+            return True, ""
+
+        return False, None
+
+    def map_enum_default_value(
+        self, enum_name: EnumDefinitionName, permissible_value_name: str, slot: SlotDefinition, cls: ClassDefinition
+    ):
+        return Literal(permissible_value_name)
+
+    def map_string_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(default_value, datatype=ShaclDataType.STRING.uri_ref)
+
+    def map_integer_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(default_value, datatype=ShaclDataType.INTEGER.uri_ref)
+
+    def map_boolean_true_default_value(self, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(True, datatype=ShaclDataType.BOOLEAN.uri_ref)
+
+    def map_boolean_false_default_value(self, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(False, datatype=ShaclDataType.BOOLEAN.uri_ref)
+
+    def map_float_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(default_value, datatype=ShaclDataType.FLOAT.uri_ref)
+
+    def map_double_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(default_value, datatype=ShaclDataType.DOUBLE.uri_ref)
+
+    def map_decimal_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(default_value, datatype=ShaclDataType.DECIMAL.uri_ref)
+
+    def map_time_default_value(self, hour: str, minutes: str, seconds: str, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(f"{hour}:{minutes}:{seconds}", datatype=ShaclDataType.TIME.uri_ref)
+
+    def map_date_default_value(self, year: str, month: str, day: str, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(f"{year}-{month}-{day}", datatype=ShaclDataType.DATE.uri_ref)
+
+    def map_datetime_default_value(
+        self,
+        year: str,
+        month: str,
+        day: str,
+        hour: str,
+        minutes: str,
+        seconds: str,
+        slot: SlotDefinition,
+        cls: ClassDefinition,
+    ):
+        return Literal(f"{year}-{month}-{day}T{hour}:{minutes}:{seconds}", datatype=ShaclDataType.DATETIME.uri_ref)
+
+    def map_uri_or_curie_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_curie_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(default_value, datatype=ShaclDataType.CURIE.uri_ref)
+
+    def map_uri_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return Literal(default_value, datatype=ShaclDataType.URI.uri_ref)
+
+    def map_nc_name_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_object_identifier_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_node_identifier_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_json_pointer_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_json_path_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_sparql_path_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()

linkml/generators/shaclgen.py

@@ -14,8 +14,8 @@ from rdflib.collection import Collection
 from rdflib.namespace import RDF, RDFS, SH, XSD
 
 from linkml._version import __version__
-from linkml.generators.shacl.ifabsent_processor import IfAbsentProcessor
 from linkml.generators.shacl.shacl_data_type import ShaclDataType
+from linkml.generators.shacl.shacl_ifabsent_processor import ShaclIfAbsentProcessor
 from linkml.utils.generator import Generator, shared_arguments
 
 
@@ -56,7 +56,7 @@ class ShaclGenerator(Generator):
         g = Graph()
         g.bind("sh", SH)
 
-        ifabsent_processor = IfAbsentProcessor(sv)
+        ifabsent_processor = ShaclIfAbsentProcessor(sv)
 
         for pfx in self.schema.prefixes.values():
             g.bind(str(pfx.prefix_prefix), pfx.prefix_reference)
@@ -208,7 +208,9 @@ class ShaclGenerator(Generator):
                         # Map equal_string and equal_string_in to sh:in
                         self._and_equals_string(g, prop_pv, s.equals_string_in)
 
-                ifabsent_processor.process_slot(prop_pv, s, class_uri)
+                default_value = ifabsent_processor.process_slot(s, c)
+                if default_value:
+                    prop_pv(SH.defaultValue, default_value)
 
         return g
 

{linkml-1.8.2.dist-info → linkml-1.8.3.dist-info}/METADATA

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

{linkml-1.8.2.dist-info → linkml-1.8.3.dist-info}/RECORD

@@ -2,12 +2,13 @@ linkml/__init__.py,sha256=0REu65rXiOk3F1CYLzq60HiSZ2DfFySfGS6QFljZ01s,3663
 linkml/_version.py,sha256=udxv6OEqcE89DTVMYPtetXYg8IA8Sgc6yW26-6f8C3M,310
 linkml/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 linkml/cli/__main__.py,sha256=oPa7Fl2DQP40UivpIWNRr1CgwT2SQM0rhE478155zBY,80
-linkml/cli/main.py,sha256=-VaV8Z6rhadMOIHS9kdeV30NdXsE6jG3kVpvGbkF2wY,5184
+linkml/cli/main.py,sha256=83lyx36tcy95StDRtN7BmwNFCPt4As1wb0wbC3YwHKg,5386
 linkml/generators/PythonGenNotes.md,sha256=wb9BPLLhF6378OKLbwSBAwmniLpwrcT5_bbfCHfLme8,51006
 linkml/generators/README.md,sha256=RMzT8EblC_GEdPy5WyfXHDBXlFI6k6mz3Cx2sdpcyWI,4438
 linkml/generators/__init__.py,sha256=dQ2EUKy_MctEVEzbC3XzEJL5YmYwjYfsa44mG2zKn7g,1517
 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/lifecycle.py,sha256=UOJXlIyWQkvsn0Dao9_ZDzlamJtiINyVJQ6SRj66L9s,4910
 linkml/generators/common/template.py,sha256=bjcSNiC85MYl9oGhk0ZpqwZpRxxy_NqxG8XBV-TXXDY,3338
 linkml/generators/common/type_designators.py,sha256=lgVcIRJJ-yCvVGeP9U_gQZpm77UmJBQo9Bh3lGJITno,1956
@@ -32,7 +33,7 @@ linkml/generators/graphqlgen.py,sha256=-BS-UHPyHqauUgtgcFCO4xSxxogk7BPAQFSXHIrKJ
 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
-linkml/generators/jsonldcontextgen.py,sha256=fZ22yjYGLMf_rQYKQSRh3IvMdGVAFhJ0PdQF8d514NI,8689
+linkml/generators/jsonldcontextgen.py,sha256=J-9QF7doco3-hYReiik67PjiaF_UudrFEiVsbnJFCJg,8666
 linkml/generators/jsonldgen.py,sha256=9ru1rb4_u7t_Rp8ILQSmDIsk_evrDL_OeilnQUsu338,7770
 linkml/generators/jsonschemagen.py,sha256=XoA0HJ1XlItogmhr3F8XNnAi1UG6fXeBAKkjme48n7o,30388
 linkml/generators/legacy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -50,7 +51,7 @@ linkml/generators/pydanticgen/array.py,sha256=mF_vhmlPfd9yVlVyANvT9GgLP6iQLSheqa
 linkml/generators/pydanticgen/black.py,sha256=BaJ7b-kMUbIN_cKRT3yCaMEbFwxzj1_U7w4fKQnkL44,723
 linkml/generators/pydanticgen/build.py,sha256=_NQzXK_wWJ-EAHBi1nqZCEWSTYy7KWkc5w-mRsEXycI,3936
 linkml/generators/pydanticgen/includes.py,sha256=kDAwonKbhTFzrFa2TrmTYuOSHXuzDy5WHgBaI5nVY6c,504
-linkml/generators/pydanticgen/pydanticgen.py,sha256=TCQG5O0GFT1GDsrMby79jDujWFJ3D_pXW8sUB3vw3L0,49059
+linkml/generators/pydanticgen/pydanticgen.py,sha256=GpGROIR1CX876NIvVoW9dlGe1r_vQSnojC7qnM9RNrM,49239
 linkml/generators/pydanticgen/template.py,sha256=alt5yXyf2zdh93rLhyuIu9Ctb9C3O1oM62Upr4JH6Cw,21000
 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
@@ -61,12 +62,14 @@ linkml/generators/pydanticgen/templates/footer.py.jinja,sha256=t_24p1xmqdbfxGqz_
 linkml/generators/pydanticgen/templates/imports.py.jinja,sha256=d1XFna2eOpkH8cgJML3vXwqGcocczvOcrbg6jjd4kP0,945
 linkml/generators/pydanticgen/templates/module.py.jinja,sha256=NLCYn4wgwVBCs8trV2hNq0_BkZgfIIS6zQTmjzFDJCQ,568
 linkml/generators/pydanticgen/templates/validator.py.jinja,sha256=BhXRGrT7HIweVHEE3Z7ZUtFFV8kP1dmRKJfu53jZBBQ,441
-linkml/generators/pythongen.py,sha256=Ti654YxzTwZRXap-vT5T7iP3NYWox0yFqdp4oHV8tNs,53289
+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=3XOWUMEUlknkdpzGMbJrNGWPWxnhwxLHPr5anOk_m2M,52612
 linkml/generators/rdfgen.py,sha256=OT8oS8MPUVf5UK3OKvRWgAh9iQiWwdyWJSA69PncOw4,2969
-linkml/generators/shacl/__init__.py,sha256=O-M-wndKw8rMW-U8X3QCNHal-ErXP6uXZqxiQSa77l4,108
-linkml/generators/shacl/ifabsent_processor.py,sha256=kV9BGA2ZPXLRfaFuW0o4jpkATvGggvrqpAo9c1UqWNE,2193
-linkml/generators/shacl/shacl_data_type.py,sha256=BT3C9tdFyBQnuucPN7YQiFAKEa9yuzy-Q26X6dmOXgo,1827
-linkml/generators/shaclgen.py,sha256=9fp7qsKhMpplDHNIBIwfFLguYubjOEUn9th_Fvtg8zA,13283
+linkml/generators/shacl/__init__.py,sha256=KgMOyESGTdKk2Vhx9uuUYgEJPuJQ-iT1vDQVIMoiXCM,58
+linkml/generators/shacl/shacl_data_type.py,sha256=gX3Y2KyTVPwMyef0cJMTEpU9h0oH-H0ThVDORdNW170,1828
+linkml/generators/shacl/shacl_ifabsent_processor.py,sha256=hbgt5UtVHo_z_JOLkg6ltGRdVuiv65b2PA3x1Oy4ssQ,4269
+linkml/generators/shaclgen.py,sha256=JGk4X-PQadF_D-ciWKBVHuKU4QdfKewC395ujR5EsBk,13392
 linkml/generators/shexgen.py,sha256=-GFdapDEAUXAjsXdTI7ZlS39YfuvaxfzPkdqUNM19qI,9941
 linkml/generators/sparqlgen.py,sha256=ULvWokNGPADq1qDENoFeRYg3FmjdTh4-Vq-eYjsAEK4,6151
 linkml/generators/sqlalchemy/__init__.py,sha256=mb9AC1rIFkSiNZhhG0TAk45ol9PjS1XvsrvCjgfVUpQ,249
@@ -113,7 +116,6 @@ linkml/utils/deprecation.py,sha256=onhB82qjIkKzyUOTO9WDqN6QF3I2cJoyBrbm66vHmgM,8
 linkml/utils/execute_tutorial.py,sha256=KGmSnaz6joIAShnrD24n8kD6URe6CBoSUYsDOTg7qCg,7039
 linkml/utils/generator.py,sha256=nAZTBFDKAZ2Asi6f54-GSOZoP03jQKgbYCW82KA34Z4,39100
 linkml/utils/helpers.py,sha256=yR8n4zFA5wPcYC7xzRuNF3wO16vG80v6j7DM3qTNmIc,447
-linkml/utils/ifabsent_functions.py,sha256=IkcBcmRYu8sllx7_mTCqu4aHfTxX2AnQoccZ1KOODds,5843
 linkml/utils/logictools.py,sha256=BGtcoqr_Rsu08Ywa6lNiL881uZzQmNWk1p4FEIVKYe0,23641
 linkml/utils/mergeutils.py,sha256=QVm2iQB4v_L2rSvPBsPe9C865R03BgV3TzlPoTTTwWQ,9044
 linkml/utils/rawloader.py,sha256=nUB8Gfn8yEVwyo6bx0TtB2mBGkilC-fybi0xvQ73Gks,4417
@@ -149,8 +151,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=qrn3EALJsHpyzQXo2npg5oTmMNQTrCjaNIAuMV0P5c8,11720
-linkml-1.8.2.dist-info/entry_points.txt,sha256=jvnPJ8UTca4_L-Dh8OdUm5td8I3ZFlKRhMPjqRLtaSg,2084
-linkml-1.8.2.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-linkml-1.8.2.dist-info/LICENSE,sha256=kORMoywK6j9_iy0UvLR-a80P1Rvc9AOM4gsKlUNZABg,535
-linkml-1.8.2.dist-info/METADATA,sha256=rdL9CvP5g68hZnKnQcInhtIMvcI2Ip5wqBdII0le-nY,3731
-linkml-1.8.2.dist-info/RECORD,,
+linkml-1.8.3.dist-info/entry_points.txt,sha256=jvnPJ8UTca4_L-Dh8OdUm5td8I3ZFlKRhMPjqRLtaSg,2084
+linkml-1.8.3.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+linkml-1.8.3.dist-info/LICENSE,sha256=kORMoywK6j9_iy0UvLR-a80P1Rvc9AOM4gsKlUNZABg,535
+linkml-1.8.3.dist-info/METADATA,sha256=riRcN5vHtkNy2v364JshSNmukypRDIFaw0B7JbQuv_E,3731
+linkml-1.8.3.dist-info/RECORD,,

linkml/generators/shacl/ifabsent_processor.py

@@ -1,59 +0,0 @@
-import re
-from typing import Any, Callable, Optional
-
-from linkml_runtime import SchemaView
-from linkml_runtime.linkml_model import SlotDefinition
-from rdflib import SH, Literal, URIRef
-from rdflib.term import Identifier
-
-from linkml.generators.shacl.shacl_data_type import ShaclDataType
-
-
-class IfAbsentProcessor:
-    """
-    Processes value of ifabsent slot.
-
-    See `<https://w3id.org/linkml/ifabsent>`_.
-
-    TODO: unify this with ifabsent_functions
-    """
-
-    ifabsent_regex = re.compile("""(?:(?P<type>\w+)\()?[\"\']?(?P<default_value>[^\(\)\"\')]*)[\"\']?\)?""")
-
-    def __init__(self, schema_view: SchemaView):
-        self.schema_view = schema_view
-
-    def process_slot(
-        self, add_prop: Callable[[URIRef, Identifier], None], slot: SlotDefinition, class_uri: Optional[URIRef] = None
-    ) -> None:
-        if slot.ifabsent:
-            ifabsent_match = self.ifabsent_regex.search(slot.ifabsent)
-            ifabsent_default_value = ifabsent_match.group("default_value")
-
-            self._map_to_default_value(slot, add_prop, ifabsent_default_value, class_uri)
-
-    def _map_to_default_value(
-        self,
-        slot: SlotDefinition,
-        add_prop: Callable[[URIRef, Identifier], None],
-        ifabsent_default_value: Any,
-        class_uri: Optional[URIRef] = None,
-    ) -> None:
-        for datatype in list(ShaclDataType):
-            if datatype.linkml_type == slot.range:
-                add_prop(SH.defaultValue, Literal(ifabsent_default_value, datatype=datatype.uri_ref))
-                return
-
-        for enum_name, enum in self.schema_view.all_enums().items():
-            if enum_name == slot.range:
-                for permissible_value_name, permissible_value in enum.permissible_values.items():
-                    if permissible_value_name == ifabsent_default_value:
-                        add_prop(SH.defaultValue, Literal(ifabsent_default_value))
-                        return
-
-        if ifabsent_default_value == "class_curie":
-            if class_uri:
-                add_prop(SH.defaultValue, class_uri)
-            return
-
-        raise ValueError(f"The ifabsent value `{slot.ifabsent}` of the `{slot.name}` slot could not be processed")

linkml/utils/ifabsent_functions.py

@@ -1,138 +0,0 @@
-import re
-from typing import Callable, List, Match, Optional, Text, Tuple, Union
-
-from linkml_runtime.linkml_model.meta import ClassDefinition, SlotDefinition
-from linkml_runtime.utils.formatutils import sfx
-
-from linkml.utils.schemaloader import SchemaLoader
-
-
-def strval(txt: str) -> str:
-    txt = str(txt).replace('"', '\\"')
-    return f'"{txt}"'
-
-
-def default_uri_for(loader: SchemaLoader) -> str:
-    dflt = loader.schema.default_prefix if loader.schema.default_prefix else sfx(loader.schema.id)
-    return sfx(loader.namespaces.uri_for(dflt))
-
-
-def default_curie_or_uri(loader: SchemaLoader) -> str:
-    dflt = loader.schema.default_prefix if loader.schema.default_prefix else sfx(loader.schema.id)
-    if ":/" in dflt:
-        prefix = loader.namespaces.prefix_for(loader.schema.default_prefix)
-        if prefix:
-            dflt = prefix
-    return dflt
-
-
-def curie_for(loader: SchemaLoader, is_class: bool) -> Optional[str]:
-    """Return the Curie for the schema in loader.  Return None if there is no curie form"""
-    prefix = default_curie_or_uri(loader)
-    suffix = "camelcase(self.name)" if is_class else "underscore(self.alias if self.alias else self.name)"
-    if ":/" not in prefix:
-        return '"' + prefix + ":" + '" + ' + suffix
-    else:
-        pn = loader.namespaces.curie_for(prefix, default_ok=False)
-        return ('"' + pn + '" + ' + suffix) if pn else None
-
-
-def uri_for(s: str, loader: SchemaLoader) -> str:
-    uri = str(loader.namespaces.uri_for(s))
-    return loader.namespaces.curie_for(uri, True, True) or strval(uri)
-
-
-def default_ns_for(loader: SchemaLoader, cls: ClassDefinition) -> str:
-    """Return code to produce the default namespace for the supplied class"""
-    # TODO: figure out how to mark a slot as a namespace
-    return "sfx(str(self.id))" if "id" in cls.slots else "None"
-    # cls_id = None
-    # for slotname in cls.slots:
-    #     slot = loader.schema.slots[slotname]
-    #     if slot.identifier:
-    #         cls_id = slotname
-    # return f"sfx(str(self.{cls_id}))" if cls_id else "None"
-
-
-# Library of named default values -- this is here to prevent code injection
-# Contents: Match text (as re),
-#           flag that indicates whether we're generating a default value expression or postinig code
-#           Function that takes the match string, SchemaLoader, ClassDefinition, and SlotDefinition and returns the
-#           appropriate string
-default_library: List[
-    Tuple[
-        Text,
-        bool,
-        Callable[[Match[str], SchemaLoader, ClassDefinition, SlotDefinition], str],
-    ]
-] = [
-    (r"[Tt]rue", False, lambda _, __, ___, ____: "True"),
-    (r"[Ff]alse", False, lambda _, __, ___, ____: "False"),
-    (r"int\(([-+]?[0-9]+)\)", False, lambda m, __, ___, ____: int(m[1])),
-    (
-        r"float\(([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)\)",
-        False,
-        lambda m, __, ___, ____: float(m[1]),
-    ),
-    (
-        r"date\((\d{4})-(\d{2})-(\d{2})\)",
-        False,
-        lambda m, __, ___, ____: f"date({int(m[1])}, {int(m[2])}, {int(m[3])})",
-    ),
-    (
-        r"datetime\((\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})Z\)",
-        False,
-        lambda m, __, ___, ____: f"datetime({int(m[1])}, {int(m[2])}, {int(m[3])}, "
-        f"{int(m[4])}, {int(m[5])}, {int(m[6])})",
-    ),
-    # TODO: We have to make the real URI available before any of these can work
-    # ("class_uri", True,
-    #     lambda _, loader, ___, ____: f'"{default_uri_for(loader)}" + camelcase(self.name)'),
-    # ("slot_uri", True,
-    #     lambda _, loader, ___, ____: f'"{default_uri_for(loader)}" +
-    #     underscore(self.alias if self.alias else self.name)'),
-    # ("class_curie", True, lambda _, loader, ___, ____: curie_for(loader, True)),
-    # ("slot_curie", True, lambda _, loader, ___, ____: curie_for(loader, False)),
-    ("class_uri", True, lambda _, loader, ___, ____: "None"),
-    ("slot_uri", True, lambda _, loader, ___, ____: "None"),
-    ("class_curie", True, lambda _, loader, ___, ____: "None"),
-    ("slot_curie", True, lambda _, loader, ___, ____: "None"),
-    # See: https://github.com/linkml/linkml/issues/1333
-    # ("class_uri", False, lambda _, __, class_definition, ____: 'class_class_uri'),
-    # ("class_curie", False, lambda _, __, class_definition, ____: 'class_class_curie'),
-    # ("slot_uri", True, lambda _, loader, ___, slot_definition: f'slots.{slot_definition.name}.uri'),
-    # ("slot_curie", True, lambda _, loader, ___, slot_definition: f'slots.{slot_definition.name}.curie'),
-    # ("default_range", False, lambda _, loader, __, ____: f"{strval(loader.schema.default_range)}"),
-    ("default_range", False, lambda _, __, ___, ____: "None"),
-    ("bnode", False, lambda _, __, ___, ____: "bnode()"),
-    (r"string\((.*)\)", False, lambda m, __, ___, ____: strval(m[1])),
-    (r"uri\((.*)\)", False, lambda m, loader, _, __: uri_for(m[1], loader)),
-    ("default_ns", True, lambda _, loader, cls, ____: default_ns_for(loader, cls)),
-    # ("default_ns", False, lambda _, loader, __, ____: f"{strval(loader.schema.default_prefix)}"),
-]
-
-
-def isabsent_match(
-    txt: Text,
-) -> Union[
-    Tuple[Match[str], bool, Callable[[Match[str], SchemaLoader, ClassDefinition, SlotDefinition], str]],
-    Tuple[None, None, None],
-]:
-    txt = str(txt)
-    for pattern, postinit, f in default_library:
-        m = re.match(pattern + "$", txt)
-        if m:
-            return m, postinit, f
-    raise ValueError(f"Incompatible default value: {txt}")
-
-
-def ifabsent_value_declaration(txt: Text, loader, cls, slot) -> Optional[str]:
-    m, postinit, f = isabsent_match(txt)
-    if m and not postinit:
-        return f(m, loader, cls, slot)
-
-
-def ifabsent_postinit_declaration(txt: Text, loader, cls, slot) -> Optional[str]:
-    m, postinit, f = isabsent_match(txt)
-    if m and postinit:
-        return f(m, loader, cls, slot)