linkml 1.8.2__tar.gz → 1.8.3__tar.gz

{linkml-1.8.2 → linkml-1.8.3}/PKG-INFO

@@ -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 → linkml-1.8.3}/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-1.8.3/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-1.8.2 → linkml-1.8.3}/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-1.8.2 → linkml-1.8.3}/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-1.8.3/linkml/generators/python/__init__.py

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

linkml-1.8.3/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-1.8.2 → linkml-1.8.3}/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-1.8.3/linkml/generators/shacl/__init__.py

@@ -0,0 +1 @@
+__all__ = ["shacl_data_type", "shacl_ifabsent_processor"]

{linkml-1.8.2 → linkml-1.8.3}/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"))