linkml 1.8.0rc2__py3-none-any.whl → 1.8.2__py3-none-any.whl

linkml/generators/jsonschemagen.py

@@ -126,7 +126,13 @@ class JsonSchema(dict):
 
     @property
     def is_array(self):
-        return self.get("type") == "array"
+        typ = self.get("type", False)
+        if isinstance(typ, str):
+            return typ == "array"
+        elif isinstance(typ, list):
+            return "array" in typ
+        else:
+            return False
 
     @property
     def is_object(self):
@@ -136,7 +142,7 @@ class JsonSchema(dict):
         return json.dumps(self, **kwargs)
 
     @classmethod
-    def ref_for(cls, class_name: Union[str, List[str]], identifier_optional: bool = False):
+    def ref_for(cls, class_name: Union[str, List[str]], identifier_optional: bool = False, required: bool = True):
         def _ref(class_name):
             def_name = camelcase(class_name)
             def_suffix = cls.OPTIONAL_IDENTIFIER_SUFFIX if identifier_optional else ""
@@ -144,15 +150,27 @@ class JsonSchema(dict):
 
         if isinstance(class_name, list):
             if len(class_name) == 1:
-                return _ref(class_name[0])
+                ref = _ref(class_name[0])
             else:
-                return JsonSchema({"anyOf": [_ref(name) for name in class_name]})
+                ref = JsonSchema({"anyOf": [_ref(name) for name in class_name]})
         else:
-            return _ref(class_name)
+            ref = _ref(class_name)
+
+        if not required:
+            if "anyOf" in ref:
+                ref["anyOf"].append({"type": "null"})
+            else:
+                ref = JsonSchema({"anyOf": [ref, {"type": "null"}]})
+        return ref
 
     @classmethod
-    def array_of(cls, subschema: "JsonSchema") -> "JsonSchema":
-        schema = {"type": "array", "items": subschema}
+    def array_of(cls, subschema: "JsonSchema", required: bool = True) -> "JsonSchema":
+        if required:
+            typ = "array"
+        else:
+            typ = ["array", "null"]
+
+        schema = {"type": typ, "items": subschema}
 
         return JsonSchema(schema)
 
@@ -199,6 +217,9 @@ class JsonSchemaGenerator(Generator):
 
     top_level_schema: JsonSchema = None
 
+    include_null: bool = True
+    """Whether to include a "null" type in optional slots"""
+
     def __post_init__(self):
         if self.topClass:
             logging.warning("topClass is deprecated - use top_class")
@@ -315,7 +336,7 @@ class JsonSchemaGenerator(Generator):
 
         subschema = JsonSchema()
         for slot in cls.slot_conditions.values():
-            prop = self.get_subschema_for_slot(slot, omit_type=True)
+            prop = self.get_subschema_for_slot(slot, omit_type=True, include_null=False)
             value_required = False
             value_disallowed = False
             if slot.value_presence:
@@ -433,12 +454,31 @@ class JsonSchemaGenerator(Generator):
         constraints.add_keyword("maximum", slot.maximum_value)
         constraints.add_keyword("const", slot.equals_string)
         constraints.add_keyword("const", slot.equals_number)
+        if slot.equals_string_in:
+            constraints.add_keyword("enum", slot.equals_string_in)
         return constraints
 
-    def get_subschema_for_slot(self, slot: SlotDefinition, omit_type: bool = False) -> JsonSchema:
+    def get_subschema_for_slot(
+        self, slot: Union[SlotDefinition, AnonymousSlotExpression], omit_type: bool = False, include_null: bool = True
+    ) -> JsonSchema:
+        """
+        Args:
+            include_null: Include ``type: null`` when generating ranges that are not required
+        """
         prop = JsonSchema()
+        if isinstance(slot, SlotDefinition) and slot.array:
+            # TODO: this is currently too lax, in that it will validate ANY array.
+            # see https://github.com/linkml/linkml/issues/2188
+            prop = JsonSchema(
+                {
+                    "type": ["null", "boolean", "object", "number", "string", "array"],
+                    "additionalProperties": True,
+                }
+            )
+            return JsonSchema.array_of(prop, required=slot.required)
         slot_is_multivalued = "multivalued" in slot and slot.multivalued
         slot_is_inlined = self.schemaview.is_inlined(slot)
+        slot_is_boolean = any([slot.any_of, slot.all_of, slot.exactly_one_of, slot.none_of])
         if not omit_type:
             typ, fmt, reference = self.get_type_info_for_slot_subschema(slot)
             if slot_is_inlined:
@@ -459,7 +499,9 @@ class JsonSchemaGenerator(Generator):
                         # If the range can be collected as a simple dict, then we can also accept the value
                         # of that simple dict directly.
                         if range_simple_dict_value_slot is not None:
-                            additionalProps.append(self.get_subschema_for_slot(range_simple_dict_value_slot))
+                            additionalProps.append(
+                                self.get_subschema_for_slot(range_simple_dict_value_slot, include_null=False)
+                            )
 
                         # If the range has no required slots, then null is acceptable
                         if len(range_required_slots) == 0:
@@ -471,12 +513,17 @@ class JsonSchemaGenerator(Generator):
                             additionalProps = additionalProps[0]
                         else:
                             additionalProps = JsonSchema({"anyOf": additionalProps})
-                        prop = JsonSchema({"type": "object", "additionalProperties": additionalProps})
+                        if slot.required or not include_null:
+                            typ = "object"
+                        else:
+                            typ = ["object", "null"]
+                        prop = JsonSchema({"type": typ, "additionalProperties": additionalProps})
                         self.top_level_schema.add_lax_def(reference, self.aliased_slot_name(range_id_slot))
                     else:
-                        prop = JsonSchema.array_of(JsonSchema.ref_for(reference))
+                        prop = JsonSchema.array_of(JsonSchema.ref_for(reference), required=slot.required)
                 else:
-                    prop = JsonSchema.ref_for(reference)
+                    prop = JsonSchema.ref_for(reference, required=slot.required or not include_null)
+
             else:
                 if reference is not None:
                     prop = JsonSchema.ref_for(reference)
@@ -486,7 +533,12 @@ class JsonSchemaGenerator(Generator):
                     prop = JsonSchema({"type": typ, "format": fmt})
 
                 if slot_is_multivalued:
-                    prop = JsonSchema.array_of(prop)
+                    prop = JsonSchema.array_of(prop, required=slot.required)
+                else:
+                    # handle optionals - bools like any_of, etc. below as they call this method recursively
+                    if not slot.required and not slot_is_boolean and include_null:
+                        if "type" in prop:
+                            prop["type"] = [prop["type"], "null"]
 
         prop.add_keyword("description", slot.description)
         if self.title_from == "title" and slot.title:
@@ -512,22 +564,29 @@ class JsonSchemaGenerator(Generator):
 
         bool_subschema = JsonSchema()
         if slot.any_of is not None and len(slot.any_of) > 0:
-            bool_subschema["anyOf"] = [self.get_subschema_for_slot(s) for s in slot.any_of]
+            bool_subschema["anyOf"] = [self.get_subschema_for_slot(s, include_null=False) for s in slot.any_of]
+            if not slot.required and not prop.is_array and include_null:
+                bool_subschema["anyOf"].append({"type": "null"})
 
         if slot.all_of is not None and len(slot.all_of) > 0:
-            bool_subschema["allOf"] = [self.get_subschema_for_slot(s) for s in slot.all_of]
+            bool_subschema["allOf"] = [self.get_subschema_for_slot(s, include_null=False) for s in slot.all_of]
 
         if slot.exactly_one_of is not None and len(slot.exactly_one_of) > 0:
-            bool_subschema["oneOf"] = [self.get_subschema_for_slot(s) for s in slot.exactly_one_of]
+            bool_subschema["oneOf"] = [self.get_subschema_for_slot(s, include_null=False) for s in slot.exactly_one_of]
 
         if slot.none_of is not None and len(slot.none_of) > 0:
-            bool_subschema["not"] = {"anyOf": [self.get_subschema_for_slot(s) for s in slot.none_of]}
+            bool_subschema["not"] = {
+                "anyOf": [self.get_subschema_for_slot(s, include_null=False) for s in slot.none_of]
+            }
 
         if bool_subschema:
             if prop.is_array:
                 if "items" not in prop:
                     prop["items"] = {}
-                prop["type"] = "array"
+                if slot.required or not include_null:
+                    prop["type"] = "array"
+                else:
+                    prop["type"] = ["array", "null"]
                 prop["items"].update(bool_subschema)
             else:
                 prop.update(bool_subschema)
@@ -542,7 +601,7 @@ class JsonSchemaGenerator(Generator):
         value_disallowed = slot.value_presence == PresenceEnum(PresenceEnum.ABSENT)
 
         aliased_slot_name = self.aliased_slot_name(slot)
-        prop = self.get_subschema_for_slot(slot)
+        prop = self.get_subschema_for_slot(slot, include_null=self.include_null)
         subschema.add_property(
             aliased_slot_name, prop, value_required=value_required, value_disallowed=value_disallowed
         )
@@ -613,7 +672,7 @@ class JsonSchemaGenerator(Generator):
 
 
 @shared_arguments(JsonSchemaGenerator)
-@click.command()
+@click.command(name="json-schema")
 @click.option(
     "-i",
     "--inline",

linkml/generators/linkmlgen.py

@@ -97,7 +97,7 @@ class LinkmlGenerator(Generator):
     help="Name of JSON or YAML file to be created",
 )
 @click.version_option(__version__, "-V", "--version")
-@click.command()
+@click.command(name="linkml")
 def cli(
     yamlfile,
     materialize_attributes: bool,

linkml/generators/markdowngen.py

@@ -789,7 +789,7 @@ def pad_heading(text: str) -> str:
 
 
 @shared_arguments(MarkdownGenerator)
-@click.command()
+@click.command(name="markdown")
 @click.option("--dir", "-d", required=True, help="Output directory")
 @click.option("--classes", "-c", multiple=True, help="Class(es) to emit")
 @click.option("--map-fields", "-M", multiple=True, help="Map metamodel fields, e.g. slot=field")

linkml/generators/namespacegen.py

@@ -195,7 +195,7 @@ def curie(identifier) -> str:
 
 @shared_arguments(NamespaceGenerator)
 @click.version_option(__version__, "-V", "--version")
-@click.command()
+@click.command(name="namespaces")
 def cli(yamlfile, **args):
     """Generate a namespace manager for all of the prefixes represented in a LinkML model"""
     print(NamespaceGenerator(yamlfile, **args).serialize(**args))

linkml/generators/oocodegen.py

@@ -76,6 +76,7 @@ class OOCodeGenerator(Generator):
     visit_all_class_slots = False
     uses_schemaloader = False
     requires_metamodel = False
+    schemaview: SchemaView = None
 
     template_file: str = None
     """Path to template"""
@@ -84,7 +85,7 @@ class OOCodeGenerator(Generator):
 
     def __post_init__(self):
         # TODO: consider moving up a level
-        self.schemaview = SchemaView(self.schema)
+        self.schemaview: SchemaView = SchemaView(self.schema)
         super().__post_init__()
 
     @abc.abstractmethod

linkml/generators/owlgen.py

@@ -1271,7 +1271,7 @@ class OwlSchemaGenerator(Generator):
 
 
 @shared_arguments(OwlSchemaGenerator)
-@click.command()
+@click.command(name="owl")
 @click.option("-o", "--output", help="Output file name")
 @click.option(
     "--metadata-profile",

linkml/generators/plantumlgen.py

@@ -12,7 +12,11 @@ from typing import Callable, List, Optional, Set, cast
 
 import click
 import requests
-from linkml_runtime.linkml_model.meta import ClassDefinition, ClassDefinitionName, SlotDefinition
+from linkml_runtime.linkml_model.meta import (
+    ClassDefinition,
+    ClassDefinitionName,
+    SlotDefinition,
+)
 from linkml_runtime.utils.formatutils import camelcase, underscore
 
 from linkml import REQUESTS_TIMEOUT
@@ -46,6 +50,7 @@ class PlantumlGenerator(Generator):
     directory: Optional[str] = None
     kroki_server: Optional[str] = "https://kroki.io"
     load_image: bool = True
+    tooltips_flag: bool = False
 
     def visit_schema(
         self,
@@ -132,18 +137,28 @@ class PlantumlGenerator(Generator):
                         "    {field} "
                         + underscore(self.aliased_slot_name(slot))
                         + mod
-                        + ": "
+                        + " : "
                         + underscore(slot.range)
+                        + " "
                         + self.cardinality(slot)
                     )
             self.class_generated.add(cn)
         self.referenced.add(cn)
         cls = self.schema.classes[cn]
+
+        tooltip_contents = str(cls.description)
+        first_newline_index = tooltip_contents.find("\n")
+        tooltip_contents = tooltip_contents if first_newline_index < 0 else tooltip_contents[0:first_newline_index]
+
+        if self.format == "svg" and len(tooltip_contents) > 200:
+            tooltip_contents = tooltip_contents[0:197] + " ... "
+
+        tooltip = " [[{" + tooltip_contents + "}]] "
         if cls.abstract:
             class_type = "abstract"
         else:
             class_type = "class"
-        return class_type + ' "' + cn + ('" {\n' + "\n".join(slot_defs) + "\n}" if slot_defs else '"')
+        return class_type + ' "' + cn + '"' + tooltip + ("{\n" + "\n".join(slot_defs) + "\n}")
 
     def class_associations(self, cn: ClassDefinitionName, must_render: bool = False) -> str:
         """Emit all associations for a focus class.  If none are specified, all classes are generated
@@ -217,7 +232,7 @@ class PlantumlGenerator(Generator):
                     classes.append(self.add_class(cn))
                 if mixin not in self.class_generated:
                     classes.append(self.add_class(mixin))
-                assocs.append(cn + plantuml_uses[0] + mixin + plantuml_uses[1])
+                assocs.append('"' + cn + '" ' + plantuml_uses[0] + ' "' + mixin + '" ' + plantuml_uses[1])
 
             # Classes that use the class as a mixin
             if cls.name in self.synopsis.mixinrefs:
@@ -226,7 +241,9 @@ class PlantumlGenerator(Generator):
                         classes.append(self.add_class(ClassDefinitionName(mixin)))
                     if cn not in self.class_generated:
                         classes.append(self.add_class(cn))
-                    assocs.append(ClassDefinitionName(mixin) + plantuml_uses[0] + cn + plantuml_uses[1])
+                    assocs.append(
+                        '"' + ClassDefinitionName(mixin) + '" ' + plantuml_uses[0] + ' "' + cn + '" ' + plantuml_uses[1]
+                    )
 
             # Classes that inject information
             if cn in self.synopsis.applytos.classrefs:
@@ -265,7 +282,7 @@ class PlantumlGenerator(Generator):
             if slot.multivalued:
                 return " [1..*]" if slot.required else " [0..*]"
             else:
-                return " [req]" if slot.required else " [opt]"
+                return " "
         else:
             if slot.multivalued:
                 return '"1..*" ' if slot.required else '"0..*" '
@@ -322,7 +339,7 @@ class PlantumlGenerator(Generator):
 
 
 @shared_arguments(PlantumlGenerator)
-@click.command()
+@click.command(name="plantuml")
 @click.option("--classes", "-c", multiple=True, help="Class(es) to emit")
 @click.option(
     "--directory",

linkml/generators/prefixmapgen.py

@@ -112,7 +112,7 @@ class PrefixGenerator(Generator):
 
 
 @shared_arguments(PrefixGenerator)
-@click.command()
+@click.command(name="prefix-map")
 @click.option("--base", help="Base URI for model")
 @click.option("--output", "-o", help="Output file path")
 @click.version_option(__version__, "-V", "--version")

linkml/generators/projectgen.py

@@ -159,7 +159,7 @@ class ProjectGenerator:
                     gen.serialize(**serialize_args)
 
 
-@click.command()
+@click.command(name="project")
 @click.option(
     "--dir",
     "-d",

linkml/generators/protogen.py

@@ -69,7 +69,7 @@ class ProtoGenerator(Generator):
 
 @shared_arguments(ProtoGenerator)
 @click.version_option(__version__, "-V", "--version")
-@click.command()
+@click.command(name="proto")
 def cli(yamlfile, **args):
     """Generate proto representation of LinkML model"""
     print(ProtoGenerator(yamlfile, **args).serialize(**args))

linkml/generators/pydanticgen/__init__.py

@@ -1,4 +1,9 @@
-from linkml.generators.pydanticgen.pydanticgen import DEFAULT_IMPORTS, PydanticGenerator, cli
+from linkml.generators.pydanticgen.pydanticgen import (
+    DEFAULT_IMPORTS,
+    MetadataMode,
+    PydanticGenerator,
+    cli,
+)
 from linkml.generators.pydanticgen.template import (
     ConditionalImport,
     Import,
@@ -8,8 +13,8 @@ from linkml.generators.pydanticgen.template import (
     PydanticClass,
     PydanticEnum,
     PydanticModule,
+    PydanticTemplateModel,
     PydanticValidator,
-    TemplateModel,
 )
 
 __all__ = [
@@ -18,6 +23,7 @@ __all__ = [
     "DEFAULT_IMPORTS",
     "Import",
     "Imports",
+    "MetadataMode",
     "PydanticAttribute",
     "PydanticBaseModel",
     "PydanticClass",
@@ -25,5 +31,5 @@ __all__ = [
     "PydanticGenerator",
     "PydanticModule",
     "PydanticValidator",
-    "TemplateModel",
+    "PydanticTemplateModel",
 ]