linkml 1.7.5__py3-none-any.whl → 1.7.6__py3-none-any.whl

linkml/generators/pythongen.py

@@ -36,11 +36,7 @@ from rdflib import URIRef
 import linkml
 from linkml._version import __version__
 from linkml.utils.generator import Generator, shared_arguments
-from linkml.utils.ifabsent_functions import (
-    default_curie_or_uri,
-    ifabsent_postinit_declaration,
-    ifabsent_value_declaration,
-)
+from linkml.utils.ifabsent_functions import ifabsent_postinit_declaration, ifabsent_value_declaration
 
 
 @dataclass
@@ -67,7 +63,7 @@ class PythonGenerator(Generator):
 
     def __post_init__(self) -> None:
         self.sourcefile = self.schema
-        self.schemaview = SchemaView(self.schema)
+        self.schemaview = SchemaView(self.schema, base_dir=self.base_dir)
         super().__post_init__()
         if self.format is None:
             self.format = self.valid_formats[0]
@@ -151,6 +147,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
 {enumimports}
 from linkml_runtime.utils.slot import Slot
 from linkml_runtime.utils.metamodelcore import empty_list, empty_dict, bnode
@@ -294,7 +291,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
         return rval.values()
 
     def gen_namespaces(self) -> str:
-        dflt_prefix = default_curie_or_uri(self)
+        dflt_prefix = self._default_curie_or_uri()
         dflt = f"CurieNamespace('', '{sfx(dflt_prefix)}')" if ":/" in dflt_prefix else dflt_prefix.upper()
         curienamespace_defs = [
             {
@@ -641,6 +638,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
         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}")
@@ -1170,6 +1168,14 @@ class {enum_name}(EnumDefinitionImpl):
 
         return f'{prefix_string}"""{string}"""'
 
+    def _default_curie_or_uri(self) -> str:
+        dflt = self.schema.default_prefix if self.schema.default_prefix else sfx(self.schema.id)
+        if ":/" in dflt:
+            prefix = self.namespaces.prefix_for(self.schema.default_prefix)
+            if prefix:
+                dflt = prefix
+        return dflt
+
 
 @shared_arguments(PythonGenerator)
 @click.command()

linkml/generators/shacl/__init__.py

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

linkml/generators/shacl/ifabsent_processor.py

@@ -0,0 +1,41 @@
+import re
+from typing import Any, Callable
+
+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:
+
+    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):
+        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)
+
+    def _map_to_default_value(
+        self, slot: SlotDefinition, add_prop: Callable[[URIRef, Identifier], None], ifabsent_default_value: Any
+    ) -> 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
+
+        raise ValueError(f"The ifabsent value `{slot.ifabsent}` of the `{slot.name}` slot could not be processed")

linkml/generators/shacl/shacl_data_type.py

@@ -0,0 +1,40 @@
+from enum import Enum
+
+from rdflib import URIRef
+
+
+class DataType:
+    linkml_type: str
+    uri_ref: URIRef
+
+
+class ShaclDataType(DataType, Enum):
+    STRING = ("string", URIRef("http://www.w3.org/2001/XMLSchema#string"))
+    BOOLEAN = ("boolean", URIRef("http://www.w3.org/2001/XMLSchema#boolean"))
+    DURATION = ("duration", URIRef("http://www.w3.org/2001/XMLSchema#duration"))
+    DATETIME = ("datetime", URIRef("http://www.w3.org/2001/XMLSchema#dateTime"))
+    DATE = ("date", URIRef("http://www.w3.org/2001/XMLSchema#date"))
+    TIME = ("time", URIRef("http://www.w3.org/2001/XMLSchema#time"))
+    DECIMAL = ("decimal", URIRef("http://www.w3.org/2001/XMLSchema#decimal"))
+    INTEGER = ("integer", URIRef("http://www.w3.org/2001/XMLSchema#integer"))
+    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"))
+    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"))
+    JSON_POINTER = ("jsonpointer", URIRef("http://www.w3.org/2001/XMLSchema#string"))
+    JSON_PATH = ("jsonpath", URIRef("http://www.w3.org/2001/XMLSchema#string"))
+    SPARQL_PATH = ("sparqlpath", URIRef("http://www.w3.org/2001/XMLSchema#string"))
+
+    def __new__(cls, linkml_type, uri_ref):
+        obj = object.__new__(cls)
+        obj.linkml_type = linkml_type
+        obj.uri_ref = uri_ref
+
+        return obj
+
+    def __init__(self, linkml_type, uri_ref):
+        self.linkml_type = linkml_type
+        self.uri_ref = uri_ref

linkml/generators/shaclgen.py

@@ -1,8 +1,10 @@
 import logging
 import os
 from dataclasses import dataclass
+from typing import Callable
 
 import click
+from linkml_runtime.linkml_model.meta import ElementName
 from linkml_runtime.utils.formatutils import underscore
 from linkml_runtime.utils.schemaview import SchemaView
 from rdflib import BNode, Graph, Literal, URIRef
@@ -10,23 +12,10 @@ from rdflib.collection import Collection
 from rdflib.namespace import RDF, SH
 
 from linkml._version import __version__
+from linkml.generators.shacl.ifabsent_processor import IfAbsentProcessor
+from linkml.generators.shacl.shacl_data_type import ShaclDataType
 from linkml.utils.generator import Generator, shared_arguments
 
-LINK_ML_TYPES_STRING = URIRef("http://www.w3.org/2001/XMLSchema#string")
-LINK_ML_TYPES_BOOL = URIRef("http://www.w3.org/2001/XMLSchema#boolean")
-LINK_ML_TYPES_DECIMAL = URIRef("http://www.w3.org/2001/XMLSchema#decimal")
-LINK_ML_TYPES_INTEGER = URIRef("http://www.w3.org/2001/XMLSchema#integer")
-LINK_ML_TYPES_FLOAT = URIRef("http://www.w3.org/2001/XMLSchema#float")
-LINK_ML_TYPES_DOUBLE = URIRef("http://www.w3.org/2001/XMLSchema#double")
-LINK_ML_TYPES_DURATION = URIRef("http://www.w3.org/2001/XMLSchema#duration")
-LINK_ML_TYPES_DATETIME = URIRef("http://www.w3.org/2001/XMLSchema#dateTime")
-LINK_ML_TYPES_DATE = URIRef("http://www.w3.org/2001/XMLSchema#date")
-LINK_ML_TYPES_TIME = URIRef("http://www.w3.org/2001/XMLSchema#time")
-LINK_ML_TYPES_DATE_TIME = URIRef("http://www.w3.org/2001/XMLSchema#datetime")
-LINK_ML_TYPES_URI = URIRef("http://www.w3.org/2001/XMLSchema#anyURI")
-LINK_ML_TYPES_OBJECT_ID = URIRef("http://www.w3.org/ns/shex#iri")
-LINK_ML_TYPES_NODE_ID = URIRef("http://www.w3.org/ns/shex#nonLiteral")
-
 
 @dataclass
 class ShaclGenerator(Generator):
@@ -60,6 +49,9 @@ class ShaclGenerator(Generator):
         sv = self.schemaview
         g = Graph()
         g.bind("sh", SH)
+
+        ifabsent_processor = IfAbsentProcessor(sv)
+
         for pfx in self.schema.prefixes.values():
             g.bind(str(pfx.prefix_prefix), pfx.prefix_reference)
 
@@ -116,76 +108,107 @@ class ShaclGenerator(Generator):
                     prop_pv_literal(SH.minCount, 1)
                 prop_pv_literal(SH.minInclusive, s.minimum_value)
                 prop_pv_literal(SH.maxInclusive, s.maximum_value)
-                prop_pv_literal(SH.hasValue, s.equals_number)
-                r = s.range
-                if r in sv.all_classes():
-                    range_ref = sv.get_uri(r, expand=True)
-                    prop_pv(SH["class"], URIRef(range_ref))
-                    if sv.get_identifier_slot(r) is not None:
-                        prop_pv(SH.nodeKind, SH.IRI)
-                    else:
-                        prop_pv(SH.nodeKind, SH.BlankNode)
-                elif r in sv.all_types().values():
-                    rt = sv.get_type(r)
-                    if rt.uri:
-                        prop_pv(SH.datatype, rt.uri)
-                    else:
-                        logging.error(f"No URI for type {rt.name}")
-                elif r in sv.all_enums():
-                    e = sv.get_enum(r)
-                    pv_node = BNode()
-                    Collection(
-                        g,
-                        pv_node,
-                        [
-                            URIRef(sv.expand_curie(pv.meaning)) if pv.meaning else Literal(pv_name)
-                            for pv_name, pv in e.permissible_values.items()
-                        ],
-                    )
-                    prop_pv(SH["in"], pv_node)
+
+                all_classes = sv.all_classes()
+                if s.any_of:
+                    or_node = BNode()
+                    prop_pv(SH["or"], or_node)
+                    range_list = []
+                    for any in s.any_of:
+                        r = any.range
+                        if r in all_classes:
+                            class_node = BNode()
+
+                            def cl_node_pv(p, v):
+                                if v is not None:
+                                    g.add((class_node, p, v))
+
+                            self._add_class(cl_node_pv, r)
+                            range_list.append(class_node)
+                        elif r in sv.all_types().values():
+                            t_node = BNode()
+
+                            def t_node_pv(p, v):
+                                if v is not None:
+                                    g.add((t_node, p, v))
+
+                            self._add_type(t_node_pv, r)
+                            range_list.append(t_node)
+                        elif r in sv.all_enums():
+                            en_node = BNode()
+
+                            def en_node_pv(p, v):
+                                if v is not None:
+                                    g.add((en_node, p, v))
+
+                            self._add_enum(g, en_node_pv, r)
+                            range_list.append(en_node)
+                        else:
+                            st_node = BNode()
+
+                            def st_node_pv(p, v):
+                                if v is not None:
+                                    g.add((st_node, p, v))
+
+                            add_simple_data_type(st_node_pv, r)
+                            range_list.append(st_node)
+                    Collection(g, or_node, range_list)
+
                 else:
-                    if r == "string":
-                        prop_pv(SH.datatype, LINK_ML_TYPES_STRING)
-                    elif r == "boolean":
-                        prop_pv(SH.datatype, LINK_ML_TYPES_BOOL)
-                    elif r == "duration":
-                        prop_pv(SH.datatype, LINK_ML_TYPES_DURATION)
-                    elif r == "datetime":
-                        prop_pv(SH.datatype, LINK_ML_TYPES_DATETIME)
-                    elif r == "date":
-                        prop_pv(SH.datatype, LINK_ML_TYPES_DATE)
-                    elif r == "time":
-                        prop_pv(SH.datatype, LINK_ML_TYPES_TIME)
-                    elif r == "datetime":
-                        prop_pv(SH.datatype, LINK_ML_TYPES_DATE_TIME)
-                    elif r == "decimal":
-                        prop_pv(SH.datatype, LINK_ML_TYPES_DECIMAL)
-                    elif r == "integer":
-                        prop_pv(SH.datatype, LINK_ML_TYPES_INTEGER)
-                    elif r == "float":
-                        prop_pv(SH.datatype, LINK_ML_TYPES_FLOAT)
-                    elif r == "double":
-                        prop_pv(SH.datatype, LINK_ML_TYPES_DOUBLE)
-                    elif r == "uri":
-                        prop_pv(SH.datatype, LINK_ML_TYPES_URI)
-                    elif r == "curi":
-                        prop_pv(SH.datatype, LINK_ML_TYPES_STRING)
-                    elif r == "ncname":
-                        prop_pv(SH.datatype, LINK_ML_TYPES_STRING)
-                    elif r == "objectidentifier":
-                        prop_pv(SH.datatype, LINK_ML_TYPES_OBJECT_ID)
-                    elif r == "nodeidentifier":
-                        prop_pv(SH.datatype, LINK_ML_TYPES_NODE_ID)
-                    elif r == "jsonpointer":
-                        prop_pv(SH.datatype, LINK_ML_TYPES_STRING)
-                    elif r == "jsonpath":
-                        prop_pv(SH.datatype, LINK_ML_TYPES_STRING)
-                    elif r == "sparqlpath":
-                        prop_pv(SH.datatype, LINK_ML_TYPES_STRING)
-                if s.pattern:
-                    prop_pv(SH.pattern, Literal(s.pattern))
+                    prop_pv_literal(SH.hasValue, s.equals_number)
+                    r = s.range
+                    if r in all_classes:
+                        self._add_class(prop_pv, r)
+                        if sv.get_identifier_slot(r) is not None:
+                            prop_pv(SH.nodeKind, SH.IRI)
+                        else:
+                            prop_pv(SH.nodeKind, SH.BlankNode)
+                    elif r in sv.all_types().values():
+                        self._add_type(prop_pv, r)
+                    elif r in sv.all_enums():
+                        self._add_enum(g, prop_pv, r)
+                    else:
+                        add_simple_data_type(prop_pv, r)
+                    if s.pattern:
+                        prop_pv(SH.pattern, Literal(s.pattern))
+
+                ifabsent_processor.process_slot(prop_pv, s)
+
         return g
 
+    def _add_class(self, func: Callable, r: ElementName) -> None:
+        sv = self.schemaview
+        range_ref = sv.get_uri(r, expand=True)
+        func(SH["class"], URIRef(range_ref))
+
+    def _add_enum(self, g: Graph, func: Callable, r: ElementName) -> None:
+        sv = self.schemaview
+        enum = sv.get_enum(r)
+        pv_node = BNode()
+        Collection(
+            g,
+            pv_node,
+            [
+                URIRef(sv.expand_curie(pv.meaning)) if pv.meaning else Literal(pv_name)
+                for pv_name, pv in enum.permissible_values.items()
+            ],
+        )
+        func(SH["in"], pv_node)
+
+    def _add_type(self, func: Callable, r: ElementName) -> None:
+        sv = self.schemaview
+        rt = sv.get_type(r)
+        if rt.uri:
+            func(SH.datatype, rt.uri)
+        else:
+            logging.error(f"No URI for type {rt.name}")
+
+
+def add_simple_data_type(func: Callable, r: ElementName) -> None:
+    for datatype in list(ShaclDataType):
+        if datatype.linkml_type == r:
+            func(SH.datatype, datatype.uri_ref)
+
 
 @shared_arguments(ShaclGenerator)
 @click.option(

linkml/generators/shexgen.py

@@ -165,7 +165,7 @@ class ShExGenerator(Generator):
         shex = as_json_1(self.shex)
         if self.format == "rdf":
             g = Graph()
-            g.parse(data=shex, format="json-ld")
+            g.parse(data=shex, format="json-ld", version="1.1")
             g.bind("owl", OWL)
             shex = g.serialize(format="turtle")
         elif self.format == "shex":

linkml/generators/sqlalchemygen.py

@@ -40,7 +40,7 @@ class SQLAlchemyGenerator(Generator):
     """
     Generates SQL Alchemy classes
 
-    See also: :ref:`SQLTableGenerator`
+    See also: :class:`~linkml.generators.sqltablegen.SQLTableGenerator`
     """
 
     # ClassVars

linkml/generators/sqltablegen.py

@@ -61,19 +61,19 @@ RANGEMAP = {
 @dataclass
 class SQLTableGenerator(Generator):
     """
-    A :ref:`Generator` for creating SQL DDL
+    A :class:`~linkml.utils.generator.Generator` for creating SQL DDL
 
     The basic algorithm for mapping a linkml schema S is as follows:
 
-     - Each schema S corresponds to one database schema D (see SQLSchema)
-     - Each Class C in S is mapped to a table T (see SQLTable)
-     - Each slot S in each C is mapped to a column Col (see SQLColumn)
+    - Each schema S corresponds to one database schema D (see SQLSchema)
+    - Each Class C in S is mapped to a table T (see SQLTable)
+    - Each slot S in each C is mapped to a column Col (see SQLColumn)
 
     if the direct_mapping attribute is set to true, then no further transformations
     are applied. Note that this means:
 
-     - inline objects are modeled as Text strings
-     - multivalued fields are modeled as single Text strings
+    - inline objects are modeled as Text strings
+    - multivalued fields are modeled as single Text strings
 
     this direct mapping is useful for simple spreadsheet/denormalized representations of complex data.
     however, for other applications, additional transformations should occur. these are:
@@ -95,22 +95,30 @@ class SQLTableGenerator(Generator):
     E.g. if a class User has a multivalues slot alias whose range is a string,
     then create a table user_aliases, with two columns (1) alias [a string] and (2) a backref to user
 
-     Each mapped slot C.S has a range R
-
-     ranges that are types (literals):
-       - If R is a type, and the slot is NOT multivalued, do a direct type conversion
-       - If R is a type, and the slot is multivalued:
-         * do not include the mapped column
-         * create a new table T_S, with 2 columns: S, and a backref to T
-      ranges that are classes:
-       Ref = map_class_to_table(R)
-       - if R is a class, and the slot is NOT multivalued, and Ref has a singular primary key:
-         * Col.type = ForeignKey(Ref.PK)
-       - if R is a class, and the slot is NOT multivalued, and Ref has NO singular primary key:
-         * add a foreign key C.pk to Ref
-         * add a backref C.S => Ref, C.pk
-         * remove Col from T
-       - If R is a class, and the slot IS multivalued
+    Each mapped slot C.S has a range R
+
+    ranges that are types (literals):
+
+    * If R is a type, and the slot is NOT multivalued, do a direct type conversion
+    * If R is a type, and the slot is multivalued:
+
+        * do not include the mapped column
+        * create a new table T_S, with 2 columns: S, and a backref to T
+
+    ranges that are classes:
+
+    * Ref = map_class_to_table(R)
+    * if R is a class, and the slot is NOT multivalued, and Ref has a singular primary key:
+
+        * Col.type = ForeignKey(Ref.PK)
+
+    * if R is a class, and the slot is NOT multivalued, and Ref has NO singular primary key:
+
+        * add a foreign key C.pk to Ref
+        * add a backref C.S => Ref, C.pk
+        * remove Col from T
+
+    * If R is a class, and the slot IS multivalued
 
     """
 
@@ -236,6 +244,8 @@ class SQLTableGenerator(Generator):
             range_base = METAMODEL_TYPE_TO_BASE[range]
         elif range in schema.types:
             range_base = schema.types[range].base
+        elif range is None:
+            return Text()
         else:
             logging.error(f"Unknown range: {range} for {slot.name} = {slot.range}")
             return Text()

linkml/generators/terminusdbgen.py

@@ -6,7 +6,13 @@ from typing import List
 import click
 from linkml_runtime.linkml_model.meta import ClassDefinition, SlotDefinition
 from linkml_runtime.utils.formatutils import be, camelcase, underscore
-from terminusdb_client.woqlquery import WOQLQuery as WQ
+
+try:
+    from terminusdb_client.woqlquery import WOQLQuery as WQ
+except ImportError:
+    import warnings
+
+    warnings.warn("terminusdb_client is not a requirement of this package, please install it separately")
 
 from linkml._version import __version__
 from linkml.utils.generator import Generator, shared_arguments

linkml/linter/config/datamodel/config.py

@@ -232,11 +232,19 @@ class StandardNamingConfig(RuleConfig):
 
     level: Union[str, "RuleLevel"] = None
     permissible_values_upper_case: Optional[Union[bool, Bool]] = None
+    slot_pattern: Optional[str] = None
+    class_pattern: Optional[str] = None
 
     def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
         if self.permissible_values_upper_case is not None and not isinstance(self.permissible_values_upper_case, Bool):
             self.permissible_values_upper_case = Bool(self.permissible_values_upper_case)
 
+        if self.class_pattern is not None and not isinstance(self.class_pattern, str):
+            self.class_pattern = str(self.class_pattern)
+
+        if self.slot_pattern is not None and not isinstance(self.slot_pattern, str):
+            self.slot_pattern = str(self.slot_pattern)
+
         super().__post_init__(**kwargs)
 
 

linkml/linter/rules.py

@@ -219,8 +219,17 @@ class StandardNamingRule(LinterRule):
         self.config = config
 
     def check(self, schema_view: SchemaView, fix: bool = False) -> Iterable[LinterProblem]:
-        class_pattern = self.PATTERNS["uppercamel"]
-        slot_pattern = self.PATTERNS["snake"]
+        class_pattern = (
+            self.PATTERNS["uppercamel"]
+            if not self.config.class_pattern
+            else self.PATTERNS.get(self.config.class_pattern, re.compile(self.config.class_pattern))
+        )
+        slot_pattern = (
+            self.PATTERNS["snake"]
+            if not self.config.slot_pattern
+            else self.PATTERNS.get(self.config.slot_pattern, re.compile(self.config.slot_pattern))
+        )
+
         enum_pattern = self.PATTERNS["uppercamel"]
         permissible_value_pattern = (
             self.PATTERNS["uppersnake"] if self.config.permissible_values_upper_case else self.PATTERNS["snake"]

linkml/utils/generator.py

@@ -83,11 +83,11 @@ class Generator(metaclass=abc.ABCMeta):
     For usage `Generator Docs <https://linkml.io/linkml/generators/>`_
     """
 
-    # ClassVars
     schema: Union[str, TextIO, SchemaDefinition, "Generator"]
     """metamodel compliant schema.  Can be URI, file name, actual schema, another generator, an
         open file or a pre-parsed schema"""
 
+    # ClassVars
     generatorname: ClassVar[str] = None
     """ Name of the generator. Override with os.path.basename(__file__)"""
 
@@ -159,7 +159,8 @@ class Generator(metaclass=abc.ABCMeta):
     """True means output is to a directory, False is to stdout"""
 
     base_dir: str = None  # Base directory of schema
-    """Working directory or base URL of sources"""
+    """Working directory or base URL of sources.
+    Setting this is necessary for correct retrieval of relative imports."""
 
     metamodel_name_map: Dict[str, str] = None
     """Allows mapping of names of metamodel elements such as slot, etc"""
@@ -196,8 +197,8 @@ class Generator(metaclass=abc.ABCMeta):
         if self.uses_schemaloader:
             self._initialize_using_schemaloader(schema)
         else:
-            logging.info(f"Using SchemaView with im={self.importmap}")
-            self.schemaview = SchemaView(schema, importmap=self.importmap)
+            logging.info(f"Using SchemaView with im={self.importmap} // base_dir={self.base_dir}")
+            self.schemaview = SchemaView(schema, importmap=self.importmap, base_dir=self.base_dir)
             self.schema = self.schemaview.schema
         self._init_namespaces()
 
@@ -683,7 +684,7 @@ class Generator(metaclass=abc.ABCMeta):
 
     def slot_name(self, name: str) -> str:
         """
-        Return the underscored version of the aliased slot name if name is a slot. Prepend "unknown_" if the name
+        Return the underscored version of the aliased slot name if name is a slot. Prepend "unknown\_" if the name
         isn't valid.
         """
         slot = self.slot_for(name)
@@ -705,7 +706,7 @@ class Generator(metaclass=abc.ABCMeta):
 
         :param el_or_elname: element or name to map
         :param is_range_name: True means that we're looking for a class or type.  False means Slot or Subset. Only
-        applies if el_or_elname is an ElementName (otherwise we know what we've got
+            applies if el_or_elname is an ElementName (otherwise we know what we've got
         :return: Formatted name if type can be known else None
         """
         if isinstance(el_or_elname, str):

linkml/utils/ifabsent_functions.py

@@ -1,5 +1,5 @@
 import re
-from typing import Callable, List, Match, Optional, Text, Tuple
+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
@@ -77,12 +77,13 @@ default_library: List[
     (
         r"date\((\d{4})-(\d{2})-(\d{2})\)",
         False,
-        lambda m, __, ___, ____: f"datetime.date({m[1]}, {m[2]}, {m[3]})",
+        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.datetime({m[1]}, {m[2]}, {m[3]}, {m[4]}, {m[5]}, {m[6]})",
+        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,
@@ -113,12 +114,9 @@ default_library: List[
 
 def isabsent_match(
     txt: Text,
-) -> Optional[
-    Tuple[
-        Match[str],
-        bool,
-        Callable[[Match[str], SchemaLoader, ClassDefinition, SlotDefinition], str],
-    ]
+) -> 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:

linkml/utils/schemaloader.py

@@ -118,7 +118,7 @@ class SchemaLoader:
             sname = self.importmap.get(str(sname), sname)  # It may also use URI or other forms
             import_schemadefinition = load_raw_schema(
                 sname + ".yaml",
-                base_dir=os.path.dirname(self.schema.source_file) if self.schema.source_file else None,
+                base_dir=os.path.dirname(self.schema.source_file) if self.schema.source_file else self.base_dir,
                 merge_modules=self.merge_modules,
                 emit_metadata=self.emit_metadata,
             )
@@ -351,14 +351,6 @@ class SchemaLoader:
                     f"slot: {slot.name} - unrecognized domain ({slot.domain})",
                     slot.domain,
                 )
-            if slot.ifabsent:
-                from linkml.utils.ifabsent_functions import isabsent_match
-
-                if isabsent_match(slot.ifabsent) is None:
-                    self.raise_value_error(
-                        f"Unrecognized ifabsent action for slot '{slot.name}': '{slot.ifabsent}'",
-                        slot.ifabsent,
-                    )
 
             # Keys and identifiers must be present
             if bool(slot.key or slot.identifier):