linkml 1.7.8__py3-none-any.whl → 1.7.10__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/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
@@ -215,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
@@ -714,7 +723,7 @@ Available templates to override:
 @click.option(
     "--pydantic-version",
     type=click.IntRange(1, 2),
-    default=1,
+    default=int(PYDANTIC_VERSION[0]),
     help="Pydantic version to use (1 or 2)",
 )
 @click.option(
@@ -741,7 +750,7 @@ def cli(
     classvars=True,
     slots=True,
     array_representations=list("list"),
-    pydantic_version=1,
+    pydantic_version=int(PYDANTIC_VERSION[0]),
     extra_fields: Literal["allow", "forbid", "ignore"] = "forbid",
     **args,
 ):

linkml/generators/pythongen.py

@@ -185,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

@@ -47,7 +47,7 @@ class RDFGenerator(Generator):
     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.original_schema,
             format=JSONLDGenerator.valid_formats[0],
@@ -67,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

@@ -36,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()
@@ -129,7 +130,7 @@ class ShaclGenerator(Generator):
 
                             self._add_class(cl_node_pv, r)
                             range_list.append(class_node)
-                        elif r in sv.all_types().values():
+                        elif r in sv.all_types():
                             t_node = BNode()
 
                             def t_node_pv(p, v):
@@ -167,7 +168,7 @@ class ShaclGenerator(Generator):
                             prop_pv(SH.nodeKind, SH.IRI)
                         else:
                             prop_pv(SH.nodeKind, SH.BlankNodeOrIRI)
-                    elif r in sv.all_types().values():
+                    elif r in sv.all_types():
                         self._add_type(prop_pv, r)
                     elif r in sv.all_enums():
                         self._add_enum(g, prop_pv, r)
@@ -200,10 +201,11 @@ class ShaclGenerator(Generator):
         func(SH["in"], pv_node)
 
     def _add_type(self, func: Callable, r: ElementName) -> None:
+        func(SH.nodeKind, SH.Literal)
         sv = self.schemaview
         rt = sv.get_type(r)
         if rt.uri:
-            func(SH.datatype, rt.uri)
+            func(SH.datatype, URIRef(sv.get_uri(rt, expand=True)))
         else:
             logging.error(f"No URI for type {rt.name}")
 

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,

linkml/generators/summarygen.py

@@ -3,9 +3,9 @@
 """
 
 import os
-import sys
 from csv import DictWriter
 from dataclasses import dataclass
+from io import StringIO
 from typing import Optional
 
 import click
@@ -28,9 +28,12 @@ class SummaryGenerator(Generator):
     slottab: Optional[DictWriter] = None
     dialect: str = "excel-tab"
 
+    _str_io: Optional[StringIO] = None
+
     def visit_schema(self, **_) -> None:
+        self._str_io = StringIO()
         self.classtab = DictWriter(
-            sys.stdout,
+            self._str_io,
             [
                 "Class Name",
                 "Parent Class",
@@ -79,6 +82,9 @@ class SummaryGenerator(Generator):
             }
         )
 
+    def end_schema(self, **kwargs) -> Optional[str]:
+        return self._str_io.getvalue()
+
 
 @shared_arguments(SummaryGenerator)
 @click.version_option(__version__, "-V", "--version")

linkml/generators/terminusdbgen.py

@@ -71,8 +71,8 @@ class TerminusdbGenerator(Generator):
         self.classes = []
         self.raw_additions = []
 
-    def end_schema(self, **_) -> None:
-        print(json.dumps(WQ().woql_and(*self.classes, *self.raw_additions).to_dict(), indent=2))
+    def end_schema(self, **_) -> str:
+        return json.dumps(WQ().woql_and(*self.classes, *self.raw_additions).to_dict(), indent=2)
 
     def visit_class(self, cls: ClassDefinition) -> bool:
         self.clswq = WQ().add_class(camelcase(cls.name)).label(camelcase(cls.name)).description(be(cls.description))

linkml/generators/yumlgen.py

@@ -59,7 +59,7 @@ class YumlGenerator(Generator):
         diagram_name: Optional[str] = None,
         load_image: bool = True,
         **_,
-    ) -> None:
+    ) -> Optional[str]:
         if directory:
             os.makedirs(directory, exist_ok=True)
         if classes is not None:
@@ -106,7 +106,7 @@ class YumlGenerator(Generator):
                 else:
                     self.logger.error(f"{resp.reason} accessing {url}: {resp!r}")
         else:
-            print(str(YUML) + ",".join(yumlclassdef), end="")
+            return str(YUML) + ",".join(yumlclassdef)
 
     def class_box(self, cn: ClassDefinitionName) -> str:
         """Generate a box for the class.  Populate its interior only if (a) it hasn't previously been generated and

linkml/utils/__init__.py

@@ -0,0 +1,3 @@
+from linkml.utils.deprecation import deprecation_warning
+
+__all__ = ["deprecation_warning"]