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

linkml/generators/pydanticgen/templates/imports.py.jinja

@@ -0,0 +1,31 @@
+{% macro import_(module, alias=None, objects = None) %}
+{%- if objects is none and alias is none %}
+import {{ module }}
+{%- elif objects is none and alias is string %}
+import {{ module }} as {{ alias }}
+{%- else %}
+    {% if objects | length == 1 %}
+from {{ module }} import {{ objects[0]['name'] }} {% if objects[0]['alias'] is not none %} as {{ objects[0]['alias'] }} {% endif %}
+    {%- else %}
+from {{ module }} import (
+    {% for object in objects %}
+        {% if object['alias'] is string %}
+    {{ object['name'] }} as {{ object['alias'] }}
+        {%- else %}
+    {{ object['name'] }}
+        {%- endif %}
+        {% if not loop.last %},{{ '\n' }}{% else %}{{ '\n' }}{% endif %}
+    {% endfor %}
+)
+    {%- endif %}
+{%- endif %}
+{% endmacro %}
+{%- if module %}
+{{ import_(module, alias, objects) }}
+{% endif -%}
+{#- For when used with Imports container -#}
+{%- if imports -%}
+{%- for i in imports -%}
+{{ i }}
+{%- endfor -%}
+{% endif -%}

linkml/generators/pydanticgen/templates/module.py.jinja

@@ -0,0 +1,27 @@
+{% for import in imports %}
+{{ import }}
+{%- endfor -%}
+
+metamodel_version = "{{metamodel_version}}"
+version = "{{version if version else None}}"
+
+
+{{ base_model }}
+{% if enums %}
+    {% for e in enums.values() %}
+
+{{ e }}
+    {% endfor %}
+{% endif %}
+{% if injected_classes %}
+    {% for c in injected_classes%}
+
+{{ c }}
+    {% endfor %}
+{% endif %}
+{% for c in classes.values() %}
+
+{{ c }}
+{% endfor %}
+
+{% include 'footer.py.jinja' %}

linkml/generators/pydanticgen/templates/validator.py.jinja

@@ -0,0 +1,15 @@
+{% if pydantic_ver == 1 %}
+@validator('{{name}}', allow_reuse=True)
+{% else %}
+@field_validator('{{name}}')
+{% endif %}
+    def pattern_{{name}}(cls, v):
+        pattern=re.compile(r"{{pattern}}")
+        if isinstance(v,list):
+            for element in v:
+                if not pattern.match(element):
+                    raise ValueError(f"Invalid {{name}} format: {element}")
+        elif isinstance(v,str):
+            if not pattern.match(v):
+                raise ValueError(f"Invalid {{name}} format: {v}")
+        return v

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,59 @@
+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/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.BlankNodeOrIRI)
+                    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, class_uri)
+
         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"]