linkml 1.5.6__py3-none-any.whl → 1.5.7__py3-none-any.whl

linkml/generators/erdiagramgen.py

@@ -1,18 +1,11 @@
-import logging
 import os
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import List, Union, Optional
+from typing import List, Optional, Union
 
 import click
 import pydantic
-from linkml_runtime.linkml_model.meta import (Annotation, ClassDefinition,
-                                              ClassDefinitionName, Definition,
-                                              DefinitionName, Element,
-                                              EnumDefinition, SchemaDefinition,
-                                              SlotDefinition,
-                                              SlotDefinitionName,
-                                              SubsetDefinition, TypeDefinition)
+from linkml_runtime.linkml_model.meta import ClassDefinitionName, SlotDefinition
 from linkml_runtime.utils.formatutils import camelcase, underscore
 from linkml_runtime.utils.schemaview import SchemaView
 
@@ -21,6 +14,7 @@ from linkml.utils.generator import Generator, shared_arguments
 
 MERMAID_SERIALIZATION = str
 
+
 class Attribute(pydantic.BaseModel):
     datatype: str = "string"
     name: str = None
@@ -28,14 +22,15 @@ class Attribute(pydantic.BaseModel):
     comment: str = None
 
     def __str__(self):
-        cmt = f'"{self.comment}"' if self.comment else ''
+        cmt = f'"{self.comment}"' if self.comment else ""
         return f'    {self.datatype} {self.name} {self.key if self.key else ""} {cmt}'
 
 
 class IdentifyingType(str, Enum):
-    """ Identifying types.
+    """Identifying types.
 
     See: https://mermaid.js.org/syntax/entityRelationshipDiagram.html#identification"""
+
     IDENTIFYING = "--"
     NON_IDENTIFYING = ".."
 
@@ -44,9 +39,10 @@ class IdentifyingType(str, Enum):
 
 
 class Cardinality(pydantic.BaseModel):
-    """ Cardinality of a slot.
+    """Cardinality of a slot.
 
     See https://mermaid.js.org/syntax/entityRelationshipDiagram.html#relationship-syntax"""
+
     required: bool = True
     multivalued: bool = False
     is_left: bool = True
@@ -58,34 +54,37 @@ class Cardinality(pydantic.BaseModel):
         else:
             multivalued_char = "|"
         if self.is_left:
-            return f'{multivalued_char}{required_char}'
+            return f"{multivalued_char}{required_char}"
         else:
-            return f'{required_char}{multivalued_char}'
+            return f"{required_char}{multivalued_char}"
 
 
 class RelationshipType(pydantic.BaseModel):
-    """ Relationship type.
+    """Relationship type.
     See https://mermaid.js.org/syntax/entityRelationshipDiagram.html#relationship-syntax"""
+
     left_cardinality: Cardinality
     identifying: IdentifyingType = IdentifyingType.IDENTIFYING
     right_cardinality: Cardinality = None
 
     def __str__(self):
-        return f'{self.left_cardinality}{self.identifying}{self.right_cardinality}'
+        return f"{self.left_cardinality}{self.identifying}{self.right_cardinality}"
 
 
 class Entity(pydantic.BaseModel):
-    """ Entity in an ER diagram."""
+    """Entity in an ER diagram."""
+
     name: str
     attributes: List[Attribute] = []
 
     def __str__(self):
-        attrs = '\n'.join([str(a) for a in self.attributes])
-        return f'{self.name} {{\n{attrs}\n}}'
+        attrs = "\n".join([str(a) for a in self.attributes])
+        return f"{self.name} {{\n{attrs}\n}}"
 
 
 class Relationship(pydantic.BaseModel):
-    """ Relationship in an ER diagram."""
+    """Relationship in an ER diagram."""
+
     first_entity: str
     relationship_type: RelationshipType = None
     second_entity: str = None
@@ -97,13 +96,14 @@ class Relationship(pydantic.BaseModel):
 
 class ERDiagram(pydantic.BaseModel):
     """Represents an Diagram of Entities and Relationships"""
+
     entities: List[Entity] = []
     relationships: List[Relationship] = []
 
     def __str__(self):
-        ents = '\n'.join([str(e) for e in self.entities])
-        rels = '\n'.join([str(r) for r in self.relationships])
-        return f'erDiagram\n{ents}\n\n{rels}\n'
+        ents = "\n".join([str(e) for e in self.entities])
+        rels = "\n".join([str(r) for r in self.relationships])
+        return f"erDiagram\n{ents}\n\n{rels}\n"
 
 
 @dataclass
@@ -135,7 +135,6 @@ class ERDiagramGenerator(Generator):
     no_types_dir: bool = field(default_factory=lambda: False)
     use_slot_uris: bool = field(default_factory=lambda: False)
 
-
     def __post_init__(self):
         self.schemaview = SchemaView(self.schema)
         super().__post_init__()
@@ -159,10 +158,12 @@ class ERDiagramGenerator(Generator):
                 self.add_class(cn, diagram)
             return self.serialize_diagram(diagram)
 
-    def serialize_classes(self,
-                          class_names: List[Union[str, ClassDefinitionName]],
-                          follow_references=False,
-                          max_hops: int = None) -> MERMAID_SERIALIZATION:
+    def serialize_classes(
+        self,
+        class_names: List[Union[str, ClassDefinitionName]],
+        follow_references=False,
+        max_hops: int = None,
+    ) -> MERMAID_SERIALIZATION:
         """
         Serialize a list of classes as an ER Diagram.
 
@@ -193,7 +194,7 @@ class ERDiagramGenerator(Generator):
                 if rng in sv.all_classes():
                     if follow_references or sv.is_inlined(slot):
                         if rng not in visited:
-                            stack.append((rng, depth+1))
+                            stack.append((rng, depth + 1))
         return self.serialize_diagram(diagram)
 
     def serialize_diagram(self, diagram: ERDiagram) -> str:
@@ -204,8 +205,8 @@ class ERDiagramGenerator(Generator):
         :return:
         """
         er = str(diagram)
-        if self.format == 'markdown':
-            return f'```mermaid\n{er}\n```\n'
+        if self.format == "markdown":
+            return f"```mermaid\n{er}\n```\n"
         else:
             return er
 
@@ -242,17 +243,15 @@ class ERDiagramGenerator(Generator):
         sv = self.schemaview
         rel_type = RelationshipType(
             right_cardinality=Cardinality(
-                required=slot.required is True,
-                multivalued=slot.multivalued is True,
-                is_left=True
+                required=slot.required is True, multivalued=slot.multivalued is True, is_left=True
             ),
-            left_cardinality=Cardinality(is_left=False)
+            left_cardinality=Cardinality(is_left=False),
         )
         rel = Relationship(
             first_entity=entity.name,
             relationship_type=rel_type,
             second_entity=camelcase(sv.get_class(slot.range).name),
-            relationship_label=slot.name
+            relationship_label=slot.name,
         )
         diagram.relationships.append(rel)
 
@@ -266,28 +265,32 @@ class ERDiagramGenerator(Generator):
         """
         if self.exclude_attributes:
             return
-        sv = self.schemaview
         dt = slot.range
         if slot.multivalued:
             # NOTE: mermaid does not support []s or *s in attribute types
-            dt = f'{dt}List'
+            dt = f"{dt}List"
         attr = Attribute(name=underscore(slot.name), datatype=dt)
         entity.attributes.append(attr)
 
 
 @shared_arguments(ERDiagramGenerator)
-@click.option('--structural/--no-structural', default=True,
-              help='If True, then only the tree_root and entities reachable from the root are drawn')
-@click.option('--exclude-attributes/--no-exclude-attributes', default=False,
-              help='If True, do not include attributes in entities')
-@click.option('--follow-references/--no-follow-references', default=False,
-              help='If True, follow references even if not inlined')
-@click.option('--max-hops', default=None, type=click.INT,
-              help="Maximum number of hops")
-@click.option('--classes',
-              '-c',
-              multiple=True,
-              help="List of classes to serialize")
+@click.option(
+    "--structural/--no-structural",
+    default=True,
+    help="If True, then only the tree_root and entities reachable from the root are drawn",
+)
+@click.option(
+    "--exclude-attributes/--no-exclude-attributes",
+    default=False,
+    help="If True, do not include attributes in entities",
+)
+@click.option(
+    "--follow-references/--no-follow-references",
+    default=False,
+    help="If True, follow references even if not inlined",
+)
+@click.option("--max-hops", default=None, type=click.INT, help="Maximum number of hops")
+@click.option("--classes", "-c", multiple=True, help="List of classes to serialize")
 @click.version_option(__version__, "-V", "--version")
 @click.command()
 def cli(yamlfile, classes: List[str], max_hops: Optional[int], follow_references: bool, **args):
@@ -303,7 +306,9 @@ def cli(yamlfile, classes: List[str], max_hops: Optional[int], follow_references
         **args,
     )
     if classes:
-        print(gen.serialize_classes(classes, follow_references=follow_references, max_hops=max_hops))
+        print(
+            gen.serialize_classes(classes, follow_references=follow_references, max_hops=max_hops)
+        )
     else:
         print(gen.serialize())
 

linkml/generators/excelgen.py

@@ -1,19 +1,18 @@
-import os
 import logging
-
+import os
 from dataclasses import dataclass
 from typing import List
 
 import click
-
 from linkml_runtime.utils.schemaview import SchemaView
-from linkml.utils.generator import Generator, shared_arguments
-from linkml._version import __version__
-from linkml.utils.helpers import convert_to_snake_case
 from openpyxl import Workbook
-from openpyxl.worksheet.worksheet import Worksheet
-from openpyxl.worksheet.datavalidation import DataValidation
 from openpyxl.utils import get_column_letter
+from openpyxl.worksheet.datavalidation import DataValidation
+from openpyxl.worksheet.worksheet import Worksheet
+
+from linkml._version import __version__
+from linkml.utils.generator import Generator, shared_arguments
+from linkml.utils.helpers import convert_to_snake_case
 
 
 @dataclass
@@ -152,22 +151,17 @@ class ExcelGenerator(Generator):
         for cls_name, cls in sv.all_classes(imports=self.mergeimports).items():
             if not cls.mixin and not cls.abstract:
                 slots = [
-                    s.name
-                    for s in sv.class_induced_slots(cls_name, imports=self.mergeimports)
+                    s.name for s in sv.class_induced_slots(cls_name, imports=self.mergeimports)
                 ]
                 self.add_columns_to_worksheet(workbook, cls_name, slots)
 
-        enum_list = [
-            e_name for e_name, _ in sv.all_enums(imports=self.mergeimports).items()
-        ]
+        enum_list = [e_name for e_name, _ in sv.all_enums(imports=self.mergeimports).items()]
         for cls_name, cls in sv.all_classes(imports=self.mergeimports).items():
             if not cls.mixin and not cls.abstract:
                 for s in sv.class_induced_slots(cls_name, imports=self.mergeimports):
                     if s.range in enum_list:
                         pv_list = []
-                        for pv_name, _ in sv.get_enum(
-                            s.range
-                        ).permissible_values.items():
+                        for pv_name, _ in sv.get_enum(s.range).permissible_values.items():
                             pv_list.append(pv_name)
                         self.column_enum_validation(workbook, cls_name, s.name, pv_list)
         self.logger.info(f"The Excel workbook has been written to {self.output}")

linkml/generators/golanggen.py

@@ -1,23 +1,17 @@
 import logging
 import os
-from copy import deepcopy
 from dataclasses import dataclass
-from pathlib import Path
-from typing import (Callable, Dict, Iterator, List, Optional, Set, TextIO,
-                    Tuple, Union)
+from typing import List, Optional
 
 import click
-from jinja2 import Environment, FileSystemLoader, Template
-from linkml_runtime.dumpers import yaml_dumper
-from linkml_runtime.linkml_model.meta import (Annotation, ClassDefinition,
-                                              ClassDefinitionName, Definition,
-                                              DefinitionName, Element,
-                                              EnumDefinition, SchemaDefinition,
-                                              SlotDefinition,
-                                              SlotDefinitionName,
-                                              TypeDefinition)
+from jinja2 import Template
+from linkml_runtime.linkml_model.meta import (
+    ClassDefinition,
+    ClassDefinitionName,
+    Element,
+    SlotDefinition,
+)
 from linkml_runtime.utils.formatutils import camelcase, underscore
-from linkml_runtime.utils.schemaview import SchemaView
 
 from linkml._version import __version__
 from linkml.utils.generator import Generator, shared_arguments
@@ -82,7 +76,7 @@ type {{gen.name(c)}} struct {
 }
 
 {% endfor %}
-"""
+"""  # noqa: E101, W191
 
 
 @dataclass
@@ -103,9 +97,7 @@ class GolangGenerator(Generator):
         :return:
         """
         template_obj = Template(default_template)
-        out_str = template_obj.render(
-            gen=self, schema=self.schemaview.schema, view=self.schemaview
-        )
+        out_str = template_obj.render(gen=self, schema=self.schemaview.schema, view=self.schemaview)
         return out_str
 
     def name(self, element: Element) -> str:
@@ -148,9 +140,7 @@ class GolangGenerator(Generator):
         else:
             return None
 
-    def get_identifier_or_key_slot(
-        self, cn: ClassDefinitionName
-    ) -> Optional[SlotDefinition]:
+    def get_identifier_or_key_slot(self, cn: ClassDefinitionName) -> Optional[SlotDefinition]:
         sv = self.schemaview
         id_slot = sv.get_identifier_slot(cn)
         if id_slot:

linkml/generators/golrgen.py

@@ -8,11 +8,10 @@ See the golr-views directory in this repo for examples
 """
 import os
 from dataclasses import dataclass
-from typing import List, Optional, TextIO, Union
+from typing import List, Optional
 
 import click
-from linkml_runtime.linkml_model.meta import (ClassDefinition,
-                                              SchemaDefinition, SlotDefinition)
+from linkml_runtime.linkml_model.meta import ClassDefinition, SlotDefinition
 from linkml_runtime.utils.formatutils import underscore
 from linkml_runtime.utils.metamodelcore import empty_list
 from linkml_runtime.utils.yamlutils import YAMLRoot, as_yaml
@@ -43,7 +42,6 @@ class GOLRClass(YAMLRoot):
 
 @dataclass
 class GolrSchemaGenerator(Generator):
-
     # ClassVars
     generatorname = os.path.basename(__file__)
     generatorversion = "0.1.1"
@@ -57,7 +55,6 @@ class GolrSchemaGenerator(Generator):
     directory: str = None
     class_obj: Optional[GOLRClass] = None
 
-
     def generate_header(self):
         headers = [f"# metamodel_version: {self.schema.metamodel_version}"]
         if self.schema.version:
@@ -106,17 +103,11 @@ class GolrSchemaGenerator(Generator):
 
 @shared_arguments(GolrSchemaGenerator)
 @click.command()
-@click.option(
-    "--dir", "-d", default="golr-views", show_default=True, help="Output directory"
-)
+@click.option("--dir", "-d", default="golr-views", show_default=True, help="Output directory")
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, dir=None, **args):
     """Generate GOLR representation of a LinkML model"""
-    print(
-        GolrSchemaGenerator(yamlfile, directory=dir, **args).serialize(
-            directory=dir, **args
-        )
-    )
+    print(GolrSchemaGenerator(yamlfile, directory=dir, **args).serialize(directory=dir, **args))
 
 
 if __name__ == "__main__":

linkml/generators/graphqlgen.py

@@ -1,10 +1,8 @@
 import os
 from dataclasses import dataclass
-from typing import TextIO, Union
 
 import click
-from linkml_runtime.linkml_model.meta import (ClassDefinition,
-                                              SchemaDefinition, SlotDefinition)
+from linkml_runtime.linkml_model.meta import ClassDefinition, SlotDefinition
 from linkml_runtime.utils.formatutils import camelcase, lcamelcase
 
 from linkml._version import __version__
@@ -13,7 +11,6 @@ from linkml.utils.generator import Generator, shared_arguments
 
 @dataclass
 class GraphqlGenerator(Generator):
-
     # ClassVars
     generatorname = os.path.basename(__file__)
     generatorversion = "0.1.1"
@@ -33,14 +30,9 @@ class GraphqlGenerator(Generator):
             print(f"# version: {self.schema.version}")
 
     def visit_class(self, cls: ClassDefinition) -> bool:
-        etype = (
-            "interface" if (cls.abstract or cls.mixin) and not cls.mixins else "type"
-        )
+        etype = "interface" if (cls.abstract or cls.mixin) and not cls.mixins else "type"
         mixins = ", ".join([camelcase(mixin) for mixin in cls.mixins])
-        print(
-            f"{etype} {camelcase(cls.name)}"
-            + (f" implements {mixins}" if mixins else "")
-        )
+        print(f"{etype} {camelcase(cls.name)}" + (f" implements {mixins}" if mixins else ""))
         print("  {")
         return True
 

linkml/generators/javagen.py

@@ -1,13 +1,13 @@
+import importlib.util
 import os
-from dataclasses import field, dataclass
+from dataclasses import dataclass, field
 from typing import Optional
+
 import click
-import importlib.util
 from jinja2 import Environment, FileSystemLoader, Template
 from linkml_runtime.linkml_model.meta import TypeDefinition
 
 from linkml._version import __version__
-from linkml.generators import JAVA_GEN_VERSION
 from linkml.generators.oocodegen import OOCodeGenerator
 from linkml.utils.generator import shared_arguments
 
@@ -37,7 +37,7 @@ public{% if cls.abstract %} abstract{% endif %} class {{ cls.name }} {% if cls.i
   private {{f.range}} {{ f.name }};
 {%- endfor %}
 
-}"""
+}"""  # noqa: E501
 
 TYPEMAP = {
     "xsd:string": "String",
@@ -52,13 +52,8 @@ TYPEMAP = {
     "xsd:decimal": "BigDecimal",
 }
 
-TYPE_DEFAULTS = {
-    "boolean": "false",
-    "int": "0",
-    "float": "0f",
-    "double": "0d",
-    "String": '""'
-}
+TYPE_DEFAULTS = {"boolean": "false", "int": "0", "float": "0f", "double": "0d", "String": '""'}
+
 
 @dataclass
 class JavaGenerator(OOCodeGenerator):
@@ -73,7 +68,7 @@ class JavaGenerator(OOCodeGenerator):
 
     # ClassVars
     generatorname = os.path.basename(__file__)
-    generatorversion = JAVA_GEN_VERSION
+    generatorversion = "0.0.1"
     valid_formats = ["java"]
 
     # ObjectVars
@@ -143,9 +138,7 @@ class JavaGenerator(OOCodeGenerator):
     help="Output directory for individually generated class files",
 )
 @click.option("--package", help="Package name where relevant for generated class files")
-@click.option(
-    "--template-file", help="Optional jinja2 template to use for class generation"
-)
+@click.option("--template-file", help="Optional jinja2 template to use for class generation")
 @click.option(
     "--generate-records/--no-generate-records",
     default=False,

linkml/generators/jsonldcontextgen.py

@@ -5,15 +5,13 @@ Generate JSON-LD contexts
 import os
 import re
 from dataclasses import dataclass, field
-from typing import Optional, Set, TextIO, Union, Dict
+from typing import Dict, Optional, Set
 
 import click
 from jsonasobj2 import JsonObj, as_json
-from linkml_runtime.linkml_model.meta import (ClassDefinition, Definition,
-                                              Element, SchemaDefinition,
-                                              SlotDefinition)
+from linkml_runtime.linkml_model.meta import ClassDefinition, SlotDefinition
 from linkml_runtime.linkml_model.types import SHEX
-from linkml_runtime.utils.formatutils import be, camelcase, underscore
+from linkml_runtime.utils.formatutils import camelcase, underscore
 from rdflib import SKOS, XSD
 
 from linkml._version import __version__
@@ -32,7 +30,6 @@ ENUM_CONTEXT = {
 
 @dataclass
 class ContextGenerator(Generator):
-
     # ClassVars
     generatorname = os.path.basename(__file__)
     generatorversion = "0.1.1"
@@ -60,9 +57,7 @@ class ContextGenerator(Generator):
                 "Schema text must be supplied to context generator.  Preparsed schema will not work"
             )
 
-    def visit_schema(
-        self, base: Optional[str] = None, output: Optional[str] = None, **_
-    ):
+    def visit_schema(self, base: Optional[str] = None, output: Optional[str] = None, **_):
         # Add any explicitly declared prefixes
         for prefix in self.schema.prefixes.values():
             self.emit_prefixes.add(prefix.prefix_prefix)
@@ -104,20 +99,6 @@ class ContextGenerator(Generator):
             comments.description = "Auto generated by LinkML jsonld context generator"
             comments.generation_date = self.schema.generation_date
             comments.source = self.schema.source_file
-    #
-    #         comments = f"""Auto generated from {self.schema.source_file} by {self.generatorname} version: {self.generatorversion}"""
-    #         if self.schema.generation_date:
-    #             comments += f"""
-    #
-    # Schema: {self.schema.name}
-    # metamodel version: {self.schema.metamodel_version}
-    # model version: {self.schema.version if self.schema.version else None}
-    # """
-    #         comments += f"""
-    # id: {self.schema.id}
-    # description: {be(self.schema.description)}
-    # license: {be(self.schema.license)}
-    # """
             context.comments = comments
         context_content = {}
         if base:
@@ -155,15 +136,9 @@ class ContextGenerator(Generator):
         cn = camelcase(cls.name)
         self.add_mappings(cls)
         cls_uri_prefix, cls_uri_suffix = self.namespaces.prefix_suffix(cls.class_uri)
-        if (
-            not self.default_ns
-            or not cls_uri_prefix
-            or cls_uri_prefix != self.default_ns
-        ):
+        if not self.default_ns or not cls_uri_prefix or cls_uri_prefix != self.default_ns:
             class_def["@id"] = (
-                (cls_uri_prefix + ":" + cls_uri_suffix)
-                if cls_uri_prefix
-                else cls.class_uri
+                (cls_uri_prefix + ":" + cls_uri_suffix) if cls_uri_prefix else cls.class_uri
             )
             if cls_uri_prefix:
                 self.add_prefix(cls_uri_prefix)
@@ -198,11 +173,7 @@ class ContextGenerator(Generator):
                     else:
                         slot_def["@type"] = range_type.uri
                 slot_prefix = self.namespaces.prefix_for(slot.slot_uri)
-                if (
-                    not self.default_ns
-                    or not slot_prefix
-                    or slot_prefix != self.default_ns
-                ):
+                if not self.default_ns or not slot_prefix or slot_prefix != self.default_ns:
                     slot_def["@id"] = slot.slot_uri
                     if slot_prefix:
                         self.add_prefix(slot_prefix)

linkml/generators/jsonldgen.py

@@ -1,7 +1,6 @@
 """ Generate JSONld
 
 """
-import logging
 import os
 from copy import deepcopy
 from dataclasses import dataclass
@@ -9,14 +8,18 @@ from typing import Any, Optional
 
 import click
 from jsonasobj2 import as_json, items, loads
-from linkml_runtime.linkml_model.meta import (ClassDefinition,
-                                              ClassDefinitionName, ElementName,
-                                              SchemaDefinition, SlotDefinition,
-                                              SlotDefinitionName,
-                                              SubsetDefinition,
-                                              SubsetDefinitionName,
-                                              TypeDefinition,
-                                              TypeDefinitionName)
+from linkml_runtime.linkml_model.meta import (
+    ClassDefinition,
+    ClassDefinitionName,
+    ElementName,
+    SchemaDefinition,
+    SlotDefinition,
+    SlotDefinitionName,
+    SubsetDefinition,
+    SubsetDefinitionName,
+    TypeDefinition,
+    TypeDefinitionName,
+)
 from linkml_runtime.utils.formatutils import camelcase, underscore
 from linkml_runtime.utils.yamlutils import YAMLRoot
 
@@ -35,6 +38,7 @@ class JSONLDGenerator(Generator):
 
     Note: this is distinct from :ref:`ContextGenerator`, which generates a JSON-LD context
     """
+
     # ClassVars
     generatorname = os.path.basename(__file__)
     generatorversion = "0.0.2"
@@ -160,9 +164,7 @@ class JSONLDGenerator(Generator):
             ).serialize()
             add_prefixes_json = loads(add_prefixes)
             context = [METAMODEL_CONTEXT_URI, add_prefixes_json["@context"]]
-        elif isinstance(
-            context, str
-        ):  # Some of the older code doesn't do multiple contexts
+        elif isinstance(context, str):  # Some of the older code doesn't do multiple contexts
             context = [context]
         elif isinstance(context, tuple):
             context = list(context)