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

linkml/generators/owlgen.py

@@ -30,7 +30,7 @@ from linkml_runtime.linkml_model.meta import (
 )
 from linkml_runtime.utils.formatutils import camelcase, underscore
 from linkml_runtime.utils.introspection import package_schemaview
-from rdflib import OWL, RDF, XSD, BNode, Graph, Literal, URIRef
+from rdflib import DCTERMS, OWL, RDF, XSD, BNode, Graph, Literal, URIRef
 from rdflib.collection import Collection
 from rdflib.namespace import RDFS, SKOS
 from rdflib.plugin import Parser as rdflib_Parser
@@ -147,6 +147,8 @@ class OwlSchemaGenerator(Generator):
     mixins_as_expressions: bool = None
     """EXPERIMENTAL: If True, use OWL existential restrictions to represent mixins"""
 
+    default_permissible_value_type: Union[str, URIRef] = field(default_factory=lambda: OWL.Class)
+
     slot_is_literal_map: Mapping[str, Set[bool]] = field(default_factory=lambda: defaultdict(set))
     """DEPRECATED: use node_owltypes"""
 
@@ -830,6 +832,28 @@ class OwlSchemaGenerator(Generator):
             if ixn:
                 self.graph.add((type_uri, OWL.equivalentClass, ixn))
 
+    def _get_metatype(
+        self, element: Union[Definition, PermissibleValue], default_value: Optional[Union[str, URIRef]] = None
+    ) -> Optional[URIRef]:
+        impls = []
+        if isinstance(element, Definition):
+            impls.extend(element.implements)
+        if isinstance(element, PermissibleValue):
+            if "implements" in element.annotations:
+                ann = element.annotations["implements"]
+                v = ann.value
+                if not isinstance(v, list):
+                    v = [v]
+                impls.extend(v)
+        for impl in impls:
+            if impl.startswith("owl:"):
+                return OWL[impl.split(":")[1]]
+            if impl.startswith("rdfs:"):
+                return RDFS[impl.split(":")[1]]
+        if isinstance(default_value, str):
+            return URIRef(default_value)
+        return default_value
+
     def add_enum(self, e: EnumDefinition) -> None:
         g = self.graph
         enum_uri = self._enum_uri(e.name)
@@ -856,26 +880,36 @@ class OwlSchemaGenerator(Generator):
                 )
             )
         pv_uris = []
+        owl_types = []
+        enum_owl_type = self._get_metatype(e, self.default_permissible_value_type)
+
         for pv in e.permissible_values.values():
-            pv_uri = self._permissible_value_uri(pv, enum_uri, e)
-            pv_uris.append(pv_uri)
-            if pv_uri:
-                g.add((pv_uri, RDF.type, OWL.Class))
-                g.add((pv_uri, RDFS.label, Literal(pv.text)))
-                # TODO: make this configurable
-                g.add(
-                    (
-                        enum_uri,
-                        self.metamodel.namespaces[METAMODEL_NAMESPACE_NAME]["permissible_values"],
-                        pv_uri,
-                    )
+            pv_owl_type = self._get_metatype(pv, enum_owl_type)
+            owl_types.append(pv_owl_type)
+            if pv_owl_type == RDFS.Literal:
+                pv_node = Literal(pv.text)
+                if pv.meaning:
+                    logging.warning(f"Meaning on literal {pv.text} in {e.name} is ignored")
+            else:
+                pv_node = self._permissible_value_uri(pv, enum_uri, e)
+            pv_uris.append(pv_node)
+            g.add(
+                (
+                    enum_uri,
+                    self.metamodel.namespaces[METAMODEL_NAMESPACE_NAME]["permissible_values"],
+                    pv_node,
                 )
+            )
+            if not isinstance(pv_node, Literal):
+                g.add((pv_node, RDF.type, pv_owl_type))
+                g.add((pv_node, RDFS.label, Literal(pv.text)))
+                # TODO: make this configurable
                 # self._add_element_properties(pv_uri, pv)
                 if self.metaclasses:
-                    g.add((pv_uri, RDF.type, enum_uri))
+                    g.add((pv_node, RDF.type, enum_uri))
                 has_parent = False
                 if pv.is_a:
-                    self.graph.add((pv_uri, RDFS.subClassOf, self._permissible_value_uri(pv.is_a, enum_uri, e)))
+                    self.graph.add((pv_node, RDFS.subClassOf, self._permissible_value_uri(pv.is_a, enum_uri, e)))
                     has_parent = True
                 for mixin in sorted(pv.mixins):
                     parent = self._permissible_value_uri(mixin, enum_uri, e)
@@ -885,13 +919,33 @@ class OwlSchemaGenerator(Generator):
                         has_parent = True
                     self.graph.add((enum_uri, RDFS.subClassOf, parent))
                 if not has_parent and self.add_root_classes:
-                    self.graph.add((pv_uri, RDFS.subClassOf, URIRef(PermissibleValue.class_class_uri)))
+                    self.graph.add((pv_node, RDFS.subClassOf, URIRef(PermissibleValue.class_class_uri)))
         if all([pv is not None for pv in pv_uris]):
-            self._union_of(pv_uris, node=enum_uri)
-            for pv_uri in pv_uris:
+            all_is_class = all([owl_type == OWL.Class for owl_type in owl_types])
+            all_is_individual = all([owl_type == OWL.NamedIndividual for owl_type in owl_types])
+            all_is_literal = all([owl_type == RDFS.Literal for owl_type in owl_types])
+            sub_pred = DCTERMS.isPartOf
+            combo_pred = None
+            if all_is_class or all_is_individual or all_is_literal:
+                if all_is_class:
+                    combo_pred = OWL.unionOf
+                    # self._union_of(pv_uris, node=enum_uri)
+                    sub_pred = RDFS.subClassOf
+                elif all_is_individual:
+                    combo_pred = OWL.oneOf
+                    # self._object_one_of(pv_uris, node=enum_uri)
+                    sub_pred = RDF.type
+                elif all_is_literal:
+                    combo_pred = OWL.oneOf
+                    # self._object_one_of(pv_uris, node=enum_uri)
+                    sub_pred = RDF.type
+                if combo_pred:
+                    self._boolean_expression(pv_uris, combo_pred, enum_uri, owl_types=set(owl_types))
+            for pv_node in pv_uris:
                 # this would normally be entailed, but we assert here so it is visible
                 # without reasoning
-                g.add((pv_uri, RDFS.subClassOf, enum_uri))
+                if not isinstance(pv_node, Literal):
+                    g.add((pv_node, sub_pred, enum_uri))
 
     def _add_rule(self, subject: Union[URIRef, BNode], rule: ClassRule, cls: ClassDefinition):
         if not self.use_swrl:
@@ -1030,6 +1084,9 @@ class OwlSchemaGenerator(Generator):
     def _union_of(self, exprs: List[Union[BNode, URIRef]], **kwargs) -> Optional[Union[BNode, URIRef]]:
         return self._boolean_expression(exprs, OWL.unionOf, **kwargs)
 
+    def _object_one_of(self, exprs: List[Union[BNode, URIRef]], **kwargs) -> Optional[Union[BNode, URIRef]]:
+        return self._boolean_expression(exprs, OWL.oneOf, **kwargs)
+
     def _exactly_one_of(self, exprs: List[Union[BNode, URIRef]]) -> Optional[Union[BNode, URIRef]]:
         if not exprs:
             raise ValueError("Must pass at least one")
@@ -1165,7 +1222,7 @@ class OwlSchemaGenerator(Generator):
         return URIRef(expanded)
 
     def _permissible_value_uri(
-        self, pv: Union[str, EnumDefinition], enum_uri: str, enum_def: EnumDefinition = None
+        self, pv: Union[str, PermissibleValue], enum_uri: str, enum_def: EnumDefinition = None
     ) -> URIRef:
         if isinstance(pv, str):
             pv_name = pv
@@ -1182,6 +1239,10 @@ class OwlSchemaGenerator(Generator):
 
     def slot_owl_type(self, slot: SlotDefinition) -> URIRef:
         sv = self.schemaview
+        if slot.implements:
+            for t in ["owl:AnnotationProperty", "owl:ObjectProperty", "owl:DatatypeProperty"]:
+                if t in slot.implements:
+                    return OWL[t.replace("owl:", "")]
         if slot.range is None:
             range = self.schemaview.schema.default_range
         else:
@@ -1267,6 +1328,12 @@ class OwlSchemaGenerator(Generator):
     show_default=True,
     help="Use model URIs rather than class/slot URIs",
 )
+@click.option(
+    "--default-permissible-value-type",
+    default=str(OWL.Class),
+    show_default=True,
+    help="Default OWL type for permissible values",
+)
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, metadata_profile: str, **kwargs):
     """Generate an OWL representation of a LinkML model

linkml/generators/plantumlgen.py

@@ -57,7 +57,7 @@ class PlantumlGenerator(Generator):
         directory: Optional[str] = None,
         load_image: bool = True,
         **_,
-    ) -> None:
+    ) -> Optional[str]:
         if directory:
             os.makedirs(directory, exist_ok=True)
         if classes is not None:
@@ -110,10 +110,13 @@ class PlantumlGenerator(Generator):
                 else:
                     self.logger.error(f"{resp.reason} accessing {plantuml_url}")
         else:
-            print(
-                "@startuml\nskinparam nodesep 10\n" + "\n".join(dedup_plantumlclassdef),
-                end="\n@enduml\n",
+            out = (
+                "@startuml\n"
+                "skinparam nodesep 10\n"
+                "hide circle\n"
+                "hide empty members\n" + "\n".join(dedup_plantumlclassdef) + "\n@enduml\n"
             )
+            return out
 
     def add_class(self, cn: ClassDefinitionName) -> str:
         """Define the class only if
@@ -130,13 +133,11 @@ class PlantumlGenerator(Generator):
                 if True or cn in slot.domain_of:
                     mod = self.prop_modifier(cls, slot)
                     slot_defs.append(
-                        '    {field} "'
+                        "    {field} "
                         + underscore(self.aliased_slot_name(slot))
-                        + '"'
                         + mod
-                        + ': "'
+                        + ": "
                         + underscore(slot.range)
-                        + '"'
                         + self.cardinality(slot)
                     )
             self.class_generated.add(cn)

linkml/generators/prefixmapgen.py

@@ -3,7 +3,6 @@ Generate JSON-LD contexts
 
 """
 
-import csv
 import os
 from dataclasses import dataclass, field
 from typing import Dict, Optional, Set, Union
@@ -59,7 +58,7 @@ class PrefixGenerator(Generator):
             if self.default_ns:
                 self.emit_prefixes.add(self.default_ns)
 
-    def end_schema(self, base: Optional[Union[str, Namespace]] = None, output: Optional[str] = None, **_) -> None:
+    def end_schema(self, base: Optional[Union[str, Namespace]] = None, output: Optional[str] = None, **_) -> str:
         context = JsonObj()
         if base:
             base = str(base)
@@ -74,31 +73,24 @@ class PrefixGenerator(Generator):
         for k, v in self.slot_class_maps.items():
             context[k] = v
 
-        if output:
-            output_ext = output.split(".")[-1]
+        if self.format == "tsv":
+            mapping: Dict = {}  # prefix to IRI mapping
+            for prefix in sorted(self.emit_prefixes):
+                mapping[prefix] = self.namespaces[prefix]
 
-            if output_ext == "tsv":
-                mapping: Dict = {}
-                for prefix in sorted(self.emit_prefixes):
-                    mapping[prefix] = self.namespaces[prefix]
+            items = []
+            for key, value in mapping.items():
+                items.append("\t".join([key, value]))
+            out = "\n".join(items)
 
-                with open(output, "w", encoding="UTF-8") as outf:
-                    writer = csv.writer(outf, delimiter="\t")
-                    for key, value in mapping.items():
-                        writer.writerow([key, value])
-            else:
-                with open(output, "w", encoding="UTF-8") as outf:
-                    outf.write(as_json(context))
         else:
-            if self.format == "tsv":
-                mapping: Dict = {}  # prefix to IRI mapping
-                for prefix in sorted(self.emit_prefixes):
-                    mapping[prefix] = self.namespaces[prefix]
+            out = str(as_json(context))
 
-                for key, value in mapping.items():
-                    print(key, value, sep="\t")
-            else:
-                print(as_json(context))
+        if output:
+            with open(output, "w", encoding="UTF-8") as outf:
+                outf.write(out)
+
+        return out
 
     def visit_class(self, cls: ClassDefinition) -> bool:
         class_def = {}

linkml/generators/protogen.py

@@ -1,5 +1,6 @@
 import os
 from dataclasses import dataclass
+from typing import Optional
 
 import click
 from linkml_runtime.linkml_model.meta import ClassDefinition, SlotDefinition
@@ -26,32 +27,36 @@ class ProtoGenerator(Generator):
     # ObjectVars
     relative_slot_num: int = 0
 
-    def __post_init__(self):
-        super().__post_init__()
-        self.generate_header()
+    def visit_schema(self, **kwargs) -> Optional[str]:
+        return self.generate_header()
 
-    def generate_header(self):
-        print(' syntax="proto3";')
-        print(" package")
-        print(f"// metamodel_version: {self.schema.metamodel_version}")
+    def generate_header(self) -> str:
+        items = []
+        items.append(' syntax="proto3";')
+        items.append(" package")
+        items.append(f"// metamodel_version: {self.schema.metamodel_version}")
         if self.schema.version:
-            print(f"// version: {self.schema.version}")
+            items.append(f"// version: {self.schema.version}")
+        out = "\n".join(items) + "\n"
+        return out
 
-    def visit_class(self, cls: ClassDefinition) -> bool:
+    def visit_class(self, cls: ClassDefinition) -> Optional[str]:
         if cls.mixin or cls.abstract or not cls.slots:
-            return False
+            return None
+        items = []
         if cls.description:
             for dline in cls.description.split("\n"):
-                print(f"// {dline}")
-        print(f"message {camelcase(cls.name)}")
-        print(" {")
+                items.append(f"// {dline}")
+        items.append(f"message {camelcase(cls.name)}")
+        items.append(" {")
+        out = "\n".join(items)
         self.relative_slot_num = 0
-        return True
+        return out
 
-    def end_class(self, cls: ClassDefinition) -> None:
-        print(" }")
+    def end_class(self, cls: ClassDefinition) -> str:
+        return "\n }\n"
 
-    def visit_class_slot(self, cls: ClassDefinition, aliased_slot_name: str, slot: SlotDefinition) -> None:
+    def visit_class_slot(self, cls: ClassDefinition, aliased_slot_name: str, slot: SlotDefinition) -> str:
         qual = "repeated " if slot.multivalued else ""
         slotname = lcamelcase(aliased_slot_name)
         slot_range = camelcase(slot.range)
@@ -59,7 +64,7 @@ class ProtoGenerator(Generator):
             # numbering of slots is important in the proto implementation
             # and should be determined by the rank param.
             slot.rank = 0
-        print(f" {qual} {lcamelcase(slot_range)} {(slotname)} = {slot.rank}")
+        return f"\n {qual} {lcamelcase(slot_range)} {(slotname)} = {slot.rank}"
 
 
 @shared_arguments(ProtoGenerator)

linkml/generators/pydanticgen/array.py

@@ -30,7 +30,7 @@ else:
     from typing import Annotated
 
 from linkml.generators.pydanticgen.build import SlotResult
-from linkml.generators.pydanticgen.template import Import, Imports, ObjectImport
+from linkml.generators.pydanticgen.template import ConditionalImport, Import, Imports, ObjectImport
 
 
 class ArrayRepresentation(Enum):
@@ -54,7 +54,14 @@ if int(PYDANTIC_VERSION[0]) >= 2:
             item_schema = handler.generate_schema(item_type)
             if item_schema.get("type", "any") != "any":
                 item_schema["strict"] = True
-            array_ref = f"any-shape-array-{item_type.__name__}"
+
+            if item_type is Any:
+                # Before python 3.11, `Any` type was a special object without a __name__
+                item_name = "Any"
+            else:
+                item_name = item_type.__name__
+
+            array_ref = f"any-shape-array-{item_name}"
 
             schema = core_schema.definitions_schema(
                 core_schema.list_schema(core_schema.definition_reference_schema(array_ref)),
@@ -78,7 +85,6 @@ if int(PYDANTIC_VERSION[0]) >= 2:
         + Import(
             module="typing",
             objects=[
-                ObjectImport(name="Annotated"),
                 ObjectImport(name="Generic"),
                 ObjectImport(name="Iterable"),
                 ObjectImport(name="TypeVar"),
@@ -86,6 +92,12 @@ if int(PYDANTIC_VERSION[0]) >= 2:
                 ObjectImport(name="get_args"),
             ],
         )
+        + ConditionalImport(
+            condition="sys.version_info.minor > 8",
+            module="typing",
+            objects=[ObjectImport(name="Annotated")],
+            alternative=Import(module="typing_extensions", objects=[ObjectImport(name="Annotated")]),
+        )
         + Import(module="pydantic", objects=[ObjectImport(name="GetCoreSchemaHandler")])
         + Import(module="pydantic_core", objects=[ObjectImport(name="CoreSchema"), ObjectImport(name="core_schema")])
     )

linkml/generators/pydanticgen/pydanticgen.py

@@ -50,9 +50,13 @@ from linkml.generators.pydanticgen.template import (
     PydanticModule,
     TemplateModel,
 )
+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")
+
 
 def _get_pyrange(t: TypeDefinition, sv: SchemaView) -> str:
     pyrange = t.repr if t is not None else None
@@ -76,6 +80,7 @@ DEFAULT_IMPORTS = (
     + Import(module="decimal", objects=[ObjectImport(name="Decimal")])
     + Import(module="enum", objects=[ObjectImport(name="Enum")])
     + Import(module="re")
+    + Import(module="sys")
     + Import(
         module="typing",
         objects=[
@@ -214,6 +219,11 @@ class PydanticGenerator(OOCodeGenerator):
     genmeta: bool = False
     emit_metadata: bool = True
 
+    def __post_init__(self):
+        super().__post_init__()
+        if int(self.pydantic_version) == 1:
+            deprecation_warning("pydanticgen-v1")
+
     def compile_module(self, **kwargs) -> ModuleType:
         """
         Compiles generated python code to a module
@@ -644,10 +654,11 @@ class PydanticGenerator(OOCodeGenerator):
         for k, c in pyschema.classes.items():
             attrs = {}
             for attr_name, src_attr in c.attributes.items():
+                src_attr = src_attr._as_dict
                 new_fields = {
-                    k: src_attr._as_dict.get(k, None)
+                    k: src_attr.get(k, None)
                     for k in PydanticAttribute.model_fields.keys()
-                    if src_attr._as_dict.get(k, None) is not None
+                    if src_attr.get(k, None) is not None
                 }
                 predef_slot = predefined.get(k, {}).get(attr_name, None)
                 if predef_slot is not None:

linkml/generators/pydanticgen/template.py

@@ -1,3 +1,4 @@
+from copy import copy
 from importlib.util import find_spec
 from typing import Any, ClassVar, Dict, Generator, List, Literal, Optional, Union, overload
 
@@ -54,6 +55,10 @@ class TemplateModel(BaseModel):
     """
 
     template: ClassVar[str]
+    _environment: ClassVar[Environment] = Environment(
+        loader=PackageLoader("linkml.generators.pydanticgen", "templates"), trim_blocks=True, lstrip_blocks=True
+    )
+
     pydantic_ver: int = int(PYDANTIC_VERSION[0])
 
     def render(self, environment: Optional[Environment] = None, black: bool = False) -> str:
@@ -95,14 +100,11 @@ class TemplateModel(BaseModel):
     def environment(cls) -> Environment:
         """
         Default environment for Template models.
-
         uses a :class:`jinja2.PackageLoader` for the templates directory within this module
         with the ``trim_blocks`` and ``lstrip_blocks`` parameters set to ``True`` so that the
         default templates could be written in a more readable way.
         """
-        return Environment(
-            loader=PackageLoader("linkml.generators.pydanticgen", "templates"), trim_blocks=True, lstrip_blocks=True
-        )
+        return copy(cls._environment)
 
     if int(PYDANTIC_VERSION[0]) < 2:
         # simulate pydantic 2's model_fields behavior

linkml/generators/pythongen.py

@@ -4,6 +4,7 @@ import os
 import re
 from copy import copy
 from dataclasses import dataclass
+from pathlib import Path
 from types import ModuleType
 from typing import Callable, Dict, Iterator, List, Optional, Set, Tuple, Union
 
@@ -62,6 +63,8 @@ class PythonGenerator(Generator):
     emit_metadata: bool = True
 
     def __post_init__(self) -> None:
+        if isinstance(self.schema, Path):
+            self.schema = str(self.schema)
         self.sourcefile = self.schema
         self.schemaview = SchemaView(self.schema, base_dir=self.base_dir)
         super().__post_init__()
@@ -182,11 +185,8 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
 # Slots
 {self.gen_slotdefs()}"""
 
-    def end_schema(self, **_):
-        print(
-            re.sub(r" +\n", "\n", self.gen_schema().replace("\t", "    ")).strip(" "),
-            end="",
-        )
+    def end_schema(self, **_) -> str:
+        return re.sub(r" +\n", "\n", self.gen_schema().replace("\t", "    ")).strip(" ")
 
     def gen_imports(self) -> str:
         list_ents = [f"from {k} import {', '.join(v)}" for k, v in self.gen_import_list().items()]

linkml/generators/rdfgen.py

@@ -7,10 +7,12 @@ Generate a JSON LD representation of the model
 
 import os
 import urllib.parse as urlparse
+from copy import deepcopy
 from dataclasses import dataclass
 from typing import List, Optional
 
 import click
+from linkml_runtime.linkml_model import SchemaDefinition
 from rdflib import Graph
 from rdflib.plugin import Parser as rdflib_Parser
 from rdflib.plugin import plugins as rdflib_plugins
@@ -35,13 +37,19 @@ class RDFGenerator(Generator):
     # ObjectVars
     emit_metadata: bool = False
     context: List[str] = None
+    original_schema: SchemaDefinition = None
+    """See https://github.com/linkml/linkml/issues/871"""
+
+    def __post_init__(self):
+        self.original_schema = deepcopy(self.schema)
+        super().__post_init__()
 
     def _data(self, g: Graph) -> str:
         return g.serialize(format="turtle" if self.format == "ttl" else self.format)
 
-    def end_schema(self, output: Optional[str] = None, context: str = None, **_) -> None:
+    def end_schema(self, output: Optional[str] = None, context: str = None, **_) -> str:
         gen = JSONLDGenerator(
-            self,
+            self.original_schema,
             format=JSONLDGenerator.valid_formats[0],
             metadata=self.emit_metadata,
             importmap=self.importmap,
@@ -59,11 +67,12 @@ class RDFGenerator(Generator):
             base=str(self.namespaces._base),
             prefix=True,
         )
+        out = self._data(graph)
         if output:
             with open(output, "w", encoding="UTF-8") as outf:
-                outf.write(self._data(graph))
-        else:
-            print(self._data(graph))
+                outf.write(out)
+
+        return out
 
 
 @shared_arguments(RDFGenerator)

linkml/generators/shaclgen.py

@@ -22,7 +22,8 @@ class ShaclGenerator(Generator):
     # ClassVars
     closed: bool = True
     """True means add 'sh:closed=true' to all shapes, except of mixin shapes and shapes, that have parents"""
-
+    suffix: str = None
+    """parameterized suffix to be appended. No suffix per default."""
     generatorname = os.path.basename(__file__)
     generatorversion = "0.0.1"
     valid_formats = ["ttl"]
@@ -35,10 +36,11 @@ class ShaclGenerator(Generator):
         super().__post_init__()
         self.generate_header()
 
-    def generate_header(self):
-        print(f"# metamodel_version: {self.schema.metamodel_version}")
+    def generate_header(self) -> str:
+        out = f"\n# metamodel_version: {self.schema.metamodel_version}"
         if self.schema.version:
-            print(f"# version: {self.schema.version}")
+            out += f"\n# version: {self.schema.version}"
+        return out
 
     def serialize(self, **args) -> str:
         g = self.as_graph()
@@ -59,9 +61,12 @@ class ShaclGenerator(Generator):
 
             def shape_pv(p, v):
                 if v is not None:
-                    g.add((class_uri, p, v))
+                    g.add((class_uri_with_suffix, p, v))
 
             class_uri = URIRef(sv.get_uri(c, expand=True))
+            class_uri_with_suffix = class_uri
+            if self.suffix is not None:
+                class_uri_with_suffix += self.suffix
             shape_pv(RDF.type, SH.NodeShape)
             shape_pv(SH.targetClass, class_uri)  # TODO
             if self.closed:
@@ -211,14 +216,21 @@ def add_simple_data_type(func: Callable, r: ElementName) -> None:
 
 
 @shared_arguments(ShaclGenerator)
+@click.command()
 @click.option(
     "--closed/--non-closed",
     default=True,
     show_default=True,
     help="Use '--closed' to generate closed SHACL shapes. Use '--non-closed' to generate open SHACL shapes.",
 )
+@click.option(
+    "-s",
+    "--suffix",
+    default=None,
+    show_default=True,
+    help="Use --suffix to append given string to SHACL class name (e. g. --suffix Shape: Person becomes PersonShape).",
+)
 @click.version_option(__version__, "-V", "--version")
-@click.command()
 def cli(yamlfile, **args):
     """Generate SHACL turtle from a LinkML model"""
     gen = ShaclGenerator(yamlfile, **args)

linkml/generators/shexgen.py

@@ -55,12 +55,12 @@ class ShExGenerator(Generator):
             self.namespaces.join(self.namespaces[METAMODEL_NAMESPACE_NAME], "")
         )  # URI for the metamodel
         self.base = Namespace(self.namespaces.join(self.namespaces._base, ""))  # Base URI for what is being modeled
-        self.generate_header()
 
-    def generate_header(self):
-        print(f"# metamodel_version: {self.schema.metamodel_version}")
+    def generate_header(self) -> str:
+        out = f"# metamodel_version: {self.schema.metamodel_version}\n"
         if self.schema.version:
-            print(f"# version: {self.schema.version}")
+            out += f"# version: {self.schema.version}\n"
+        return out
 
     def visit_schema(self, **_):
         # Adjust the schema context to include the base model URI
@@ -80,6 +80,8 @@ class ShExGenerator(Generator):
             else:
                 typeof_uri = self._class_or_type_uri(typ.typeof)
                 self.shapes.append(Shape(id=model_uri, expression=typeof_uri))
+        if self.format != "json":
+            return self.generate_header()
 
     def visit_class(self, cls: ClassDefinition) -> bool:
         self.shape = Shape()
@@ -160,7 +162,7 @@ class ShExGenerator(Generator):
             else:
                 constraint.valueExpr = self._class_or_type_uri(slot.range)
 
-    def end_schema(self, output: Optional[str] = None, **_) -> None:
+    def end_schema(self, output: Optional[str] = None, **_) -> str:
         self.shex.shapes = self.shapes if self.shapes else [Shape()]
         shex = as_json_1(self.shex)
         if self.format == "rdf":
@@ -172,11 +174,11 @@ class ShExGenerator(Generator):
             g = Graph()
             self.namespaces.load_graph(g)
             shex = str(ShExC(self.shex, base=sfx(self.namespaces._base), namespaces=g))
+
         if output:
             with open(output, "w", encoding="UTF-8") as outf:
                 outf.write(shex)
-        else:
-            print(shex)
+        return shex
 
     def _class_or_type_uri(
         self,