linkml 1.8.5__py3-none-any.whl → 1.8.7__py3-none-any.whl

linkml/generators/mermaidclassdiagramgen.py

@@ -0,0 +1,133 @@
+import importlib
+import logging
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional
+
+import click
+from jinja2 import Environment, FileSystemLoader
+from linkml_runtime.linkml_model.meta import Element, SlotDefinition
+from linkml_runtime.utils.schemaview import SchemaView
+
+from linkml.generators.docgen import DocGenerator, customize_environment
+from linkml.utils.generator import Generator, shared_arguments
+
+
+@dataclass
+class MermaidClassDiagramGenerator(Generator):
+    """This generator creates Mermaid Class diagrams (https://mermaid.js.org/syntax/classDiagram.html)
+    for individual classes in a given LinkML schema and outputs them as Markdown files. It uses
+    a jinja template to render these class diagrams, which can be customized by the user and pointed
+    to using the `--template-file` option. If no template is provided, then the default template
+    file provided by LinkML and present at linkml/generators/docgen/class_diagram.md.jinja2 will be used.
+    The generator also has the option of specifying a certain set of classes for which you want the
+    class diagrams to be generated by using the `--classes` option.
+    """
+
+    generatorname = os.path.basename(__file__)
+    generatorversion = "0.0.1"
+    valid_formats = ["markdown"]
+    uses_schemaloader = False
+    requires_metamodel = False
+
+    directory: Optional[str] = None  # output directory with generated markdown files
+    template_file: Optional[str] = None  # custom/default jinja template for class diagrams
+    classes: List[str] = field(default_factory=list)  # optional subset of classes
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.logger = logging.getLogger(__name__)
+        self.schemaview = SchemaView(self.schema, merge_imports=self.mergeimports)
+
+        # set the output directory
+        self.output_directory = Path(self.directory)
+
+        # set the template file
+        if not self.template_file:
+            package_dir = os.path.dirname(importlib.util.find_spec("linkml").origin)
+            # Default location of the template file
+            self.template_file = os.path.join(package_dir, "generators", "docgen", "class_diagram.md.jinja2")
+
+    def generate_class_diagrams(self):
+        """Generate Mermaid class diagrams for the specified subset of classes
+        or all classes if none are specified.
+        """
+        self.output_directory.mkdir(parents=True, exist_ok=True)
+
+        template_folder = os.path.dirname(self.template_file)
+        template_name = os.path.basename(self.template_file)
+        loader = FileSystemLoader(template_folder)
+        env = Environment(loader=loader)
+        customize_environment(env)
+
+        template = env.get_template(template_name)
+
+        all_classes = self.schemaview.all_classes()
+
+        if self.classes:
+            class_items = [(cn, all_classes[cn]) for cn in self.classes if cn in all_classes]
+        else:
+            class_items = list(all_classes.items())
+
+        for cn, class_def in class_items:
+            self.logger.info(f"Generating Mermaid diagram for class: {cn}")
+            rendered = template.render(gen=self, element=class_def, schemaview=self.schemaview)
+            outfile = self.output_directory / f"{cn}.md"
+            with open(outfile, "w", encoding="utf-8") as f:
+                f.write(rendered)
+
+    def cardinality(self, slot: SlotDefinition) -> str:
+        """Reuses the cardinality logic from DocGenerator."""
+        return DocGenerator.cardinality(slot)
+
+    def mermaid_directive(self) -> str:
+        """Provides the code fence directive (e.g., `mermaid` or `{mermaid}`)."""
+        return "mermaid"
+
+    def name(self, element: Element) -> str:
+        """Returns the canonical name for an element."""
+        return element.name
+
+    def all_type_object_names(self):
+        return list(self.schemaview.all_types().keys())
+
+
+@shared_arguments(MermaidClassDiagramGenerator)
+@click.command()
+@click.option(
+    "--template-file",
+    "-t",
+    type=click.Path(exists=True),
+    default=None,
+    help="Path to Jinja template for class diagrams.",
+)
+@click.option(
+    "--directory",
+    "-d",
+    type=click.Path(),
+    required=True,
+    help="Folder in which to write the Markdown files.",
+)
+@click.option(
+    "--classes",
+    "-c",
+    multiple=True,
+    help="One or more classes in the schema for which to generate diagrams. "
+    "If omitted, diagrams for all classes are generated.",
+)
+@click.version_option(click.__version__, "-V", "--version")
+def cli(yamlfile, template_file, directory, classes, **args):
+    logging.basicConfig(level=logging.INFO)
+    gen = MermaidClassDiagramGenerator(
+        schema=yamlfile,
+        template_file=template_file,
+        directory=directory,
+        classes=list(classes),  # convert tuple to a list
+        **args,
+    )
+    gen.generate_class_diagrams()
+
+
+if __name__ == "__main__":
+    cli()

linkml/generators/owlgen.py

@@ -170,6 +170,9 @@ class OwlSchemaGenerator(Generator):
         default_factory=lambda: package_schemaview("linkml_runtime.linkml_model.meta")
     )
 
+    enum_iri_separator: str = "#"
+    """Separator for enum IRI. Can be overridden for example if your namespace IRI already contains a #"""
+
     def as_graph(self) -> Graph:
         """
         Generate an rdflib Graph from the LinkML schema.
@@ -705,18 +708,10 @@ class OwlSchemaGenerator(Generator):
                 owl_exprs.append(eq_uri)
         if element.equals_string_in:
             equals_string_in = element.equals_string_in
-            if is_literal is None:
-                logger.warning(f"ignoring equals_string={equals_string_in} as unable to tell if literal")
-            elif is_literal:
-                dt_exprs = [
-                    self._datatype_restriction(XSD.string, [self._facet(XSD.pattern, s)]) for s in equals_string_in
-                ]
-                union_expr = self._union_of(dt_exprs, owl_types={RDFS.Literal})
-                owl_exprs.append(union_expr)
-                owl_types.add(RDFS.Literal)
-            else:
-                eq_uris = [URIRef(self.schemaview.expand_curie(s)) for s in equals_string_in]
-                owl_exprs.append(self._union_of(eq_uris))
+            literals = [Literal(s) for s in equals_string_in]
+            one_of_expr = self._boolean_expression(literals, OWL.oneOf, owl_types={RDFS.Literal})
+            owl_exprs.append(one_of_expr)
+            owl_types.add(RDFS.Literal)
         for constraint_prop, constraint_val in constraints.items():
             if is_literal is not None and not is_literal:
                 # In LinkML, it is permissible to have a literal constraints on slots that refer to
@@ -1137,7 +1132,7 @@ class OwlSchemaGenerator(Generator):
 
     def _boolean_expression(
         self,
-        exprs: List[Union[BNode, URIRef]],
+        exprs: List[Union[BNode, URIRef, Literal]],
         predicate: URIRef,
         node: Optional[URIRef] = None,
         owl_types: Set[OWL_TYPE] = None,
@@ -1254,7 +1249,7 @@ class OwlSchemaGenerator(Generator):
         if pv.meaning:
             return URIRef(self.schemaview.expand_curie(pv.meaning))
         else:
-            return URIRef(enum_uri + "#" + pv.text.replace(" ", "+"))
+            return URIRef(enum_uri + self.enum_iri_separator + pv.text.replace(" ", "+"))
 
     def slot_owl_type(self, slot: SlotDefinition) -> URIRef:
         sv = self.schemaview
@@ -1353,6 +1348,13 @@ class OwlSchemaGenerator(Generator):
     show_default=True,
     help="Default OWL type for permissible values",
 )
+@click.option(
+    "--enum-iri-separator",
+    default="#",
+    is_flag=False,
+    show_default=True,
+    help="IRI separator for enums.",
+)
 @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

@@ -49,14 +49,13 @@ class PlantumlGenerator(Generator):
     classes: Set[ClassDefinitionName] = None
     directory: Optional[str] = None
     kroki_server: Optional[str] = "https://kroki.io"
-    load_image: bool = True
     tooltips_flag: bool = False
+    dry_run: bool = False
 
     def visit_schema(
         self,
         classes: Set[ClassDefinitionName] = None,
         directory: Optional[str] = None,
-        load_image: bool = True,
         **_,
     ) -> Optional[str]:
         if directory:
@@ -96,20 +95,21 @@ class PlantumlGenerator(Generator):
         b64_diagram = base64.urlsafe_b64encode(zlib.compress(plantuml_code.encode(), 9))
 
         plantuml_url = self.kroki_server + "/plantuml/svg/" + b64_diagram.decode()
+        if self.dry_run:
+            return plantuml_url
         if directory:
             file_suffix = ".svg" if self.format == "puml" or self.format == "puml" else "." + self.format
             self.output_file_name = os.path.join(
                 directory,
                 camelcase(sorted(classes)[0] if classes else self.schema.name) + file_suffix,
             )
-            if load_image:
-                resp = requests.get(plantuml_url, stream=True, timeout=REQUESTS_TIMEOUT)
-                if resp.ok:
-                    with open(self.output_file_name, "wb") as f:
-                        for chunk in resp.iter_content(chunk_size=2048):
-                            f.write(chunk)
-                else:
-                    self.logger.error(f"{resp.reason} accessing {plantuml_url}")
+            resp = requests.get(plantuml_url, stream=True, timeout=REQUESTS_TIMEOUT)
+            if resp.ok:
+                with open(self.output_file_name, "wb") as f:
+                    for chunk in resp.iter_content(chunk_size=2048):
+                        f.write(chunk)
+            else:
+                self.logger.error(f"{resp.reason} accessing {plantuml_url}")
         else:
             out = (
                 "@startuml\n"
@@ -352,6 +352,13 @@ class PlantumlGenerator(Generator):
     help="URL of the Kroki server to use for diagram drawing",
     default="https://kroki.io",
 )
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    default=False,
+    show_default=True,
+    help="Print out Kroki URL calls instead of sending the real requests",
+)
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, **args):
     """Generate a UML representation of a LinkML model"""

linkml/generators/pydanticgen/array.py

@@ -1,7 +1,15 @@
 import sys
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import TYPE_CHECKING, Any, ClassVar, Generic, Iterable, List, Optional, Type, TypeVar, Union, get_args
+from typing import (
+    ClassVar,
+    Iterable,
+    List,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+)
 
 from linkml_runtime.linkml_model import Element
 from linkml_runtime.linkml_model.meta import ArrayExpression, DimensionExpression
@@ -9,20 +17,15 @@ from pydantic import VERSION as PYDANTIC_VERSION
 
 from linkml.utils.deprecation import deprecation_warning
 
-if int(PYDANTIC_VERSION[0]) >= 2:
-    from pydantic_core import core_schema
-else:
+if int(PYDANTIC_VERSION[0]) < 2:
     # Support for having pydantic 1 installed in the same environment will be dropped in 1.9.0
     deprecation_warning("pydantic-v1")
 
-if TYPE_CHECKING:
-    from pydantic import GetCoreSchemaHandler
-    from pydantic_core import CoreSchema
-
-if sys.version_info.minor <= 8:
-    from typing_extensions import Annotated
+if sys.version_info.minor < 12:
+    from typing_extensions import TypeAliasType
 else:
-    from typing import Annotated
+    from typing import TypeAliasType
+
 
 from linkml.generators.pydanticgen.build import RangeResult
 from linkml.generators.pydanticgen.template import ConditionalImport, Import, Imports, ObjectImport
@@ -37,75 +40,32 @@ class ArrayRepresentation(Enum):
 _BOUNDED_ARRAY_FIELDS = ("exact_number_dimensions", "minimum_number_dimensions", "maximum_number_dimensions")
 
 _T = TypeVar("_T")
-_RecursiveListType = Iterable[Union[_T, Iterable["_RecursiveListType"]]]
-
-
-class AnyShapeArrayType(Generic[_T]):
-    @classmethod
-    def __get_pydantic_core_schema__(cls, source_type: Any, handler: "GetCoreSchemaHandler") -> "CoreSchema":
-        # double-nested parameterized types here
-        # source_type: List[Union[T,List[...]]]
-        item_type = (Any,) if get_args(get_args(source_type)[0])[0] is _T else get_args(get_args(source_type)[0])[:-1]
-
-        if len(item_type) == 1:
-            item_schema = handler.generate_schema(item_type[0])
-        else:
-            item_schema = core_schema.union_schema([handler.generate_schema(i) for i in item_type])
-
-        if all([getattr(i, "__module__", "") == "builtins" and i is not Any for i in item_type]):
-            item_schema["strict"] = True
-
-        # Before python 3.11, `Any` type was a special object without a __name__
-        item_name = "_".join(["Any" if i is Any else i.__name__ for i in item_type])
-
-        array_ref = f"any-shape-array-{item_name}"
-
-        schema = core_schema.definitions_schema(
-            core_schema.list_schema(core_schema.definition_reference_schema(array_ref)),
-            [
-                core_schema.union_schema(
-                    [
-                        core_schema.list_schema(core_schema.definition_reference_schema(array_ref)),
-                        item_schema,
-                    ],
-                    ref=array_ref,
-                )
-            ],
-        )
-
-        return schema
-
-
-AnyShapeArray = Annotated[_RecursiveListType, AnyShapeArrayType]
+AnyShapeArray = TypeAliasType("AnyShapeArray", Iterable[Union[_T, Iterable["AnyShapeArray[_T]"]]], type_params=(_T,))
 
 _AnyShapeArrayImports = (
     Imports()
     + Import(
         module="typing",
         objects=[
-            ObjectImport(name="Generic"),
             ObjectImport(name="Iterable"),
             ObjectImport(name="TypeVar"),
             ObjectImport(name="Union"),
-            ObjectImport(name="get_args"),
         ],
     )
     + ConditionalImport(
-        condition="sys.version_info.minor > 8",
+        condition="sys.version_info.minor >= 12",
         module="typing",
-        objects=[ObjectImport(name="Annotated")],
-        alternative=Import(module="typing_extensions", objects=[ObjectImport(name="Annotated")]),
+        objects=[ObjectImport(name="TypeAliasType")],
+        alternative=Import(module="typing_extensions", objects=[ObjectImport(name="TypeAliasType")]),
     )
-    + Import(module="pydantic", objects=[ObjectImport(name="GetCoreSchemaHandler")])
-    + Import(module="pydantic_core", objects=[ObjectImport(name="CoreSchema"), ObjectImport(name="core_schema")])
 )
 
 # annotated types are special and inspect.getsource() can't stringify them
 _AnyShapeArrayInjects = [
     '_T = TypeVar("_T")',
-    '_RecursiveListType = Iterable[Union[_T, Iterable["_RecursiveListType"]]]',
-    AnyShapeArrayType,
-    "AnyShapeArray = Annotated[_RecursiveListType, AnyShapeArrayType]",
+    """AnyShapeArray = TypeAliasType(
+    "AnyShapeArray", Iterable[Union[_T, Iterable["AnyShapeArray[_T]"]]], type_params=(_T,)
+)""",
 ]
 
 _ConListImports = Imports() + Import(module="pydantic", objects=[ObjectImport(name="conlist")])

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

@@ -1,4 +1,4 @@
-{{name}}: {{ range }} = Field({{ field }}
+{{name}}: {{ range }} = Field(default={{ field }}
 {%- if title != None %}, title="{{title}}"{% endif -%}
 {%- if description %}, description="""{{description}}"""{% endif -%}
 {%- if equals_number != None %}

linkml/generators/shacl/shacl_ifabsent_processor.py

@@ -62,7 +62,8 @@ class ShaclIfAbsentProcessor(IfAbsentProcessor):
         return Literal(f"{year}-{month}-{day}T{hour}:{minutes}:{seconds}", datatype=ShaclDataType.DATETIME.uri_ref)
 
     def map_uri_or_curie_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
-        raise NotImplementedError()
+        uri = URIRef(self.schema_view.expand_curie(default_value))
+        return Literal(uri, datatype=ShaclDataType.URI.uri_ref)
 
     def map_curie_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
         return Literal(default_value, datatype=ShaclDataType.CURIE.uri_ref)

linkml/generators/shaclgen.py

@@ -116,10 +116,20 @@ class ShaclGenerator(Generator):
                 order += 1
                 prop_pv_literal(SH.name, s.title)
                 prop_pv_literal(SH.description, s.description)
-                if not s.multivalued:
-                    prop_pv_literal(SH.maxCount, 1)
-                if s.required:
+                # minCount
+                if s.minimum_cardinality:
+                    prop_pv_literal(SH.minCount, s.minimum_cardinality)
+                elif s.exact_cardinality:
+                    prop_pv_literal(SH.minCount, s.exact_cardinality)
+                elif s.required:
                     prop_pv_literal(SH.minCount, 1)
+                # maxCount
+                if s.maximum_cardinality:
+                    prop_pv_literal(SH.maxCount, s.maximum_cardinality)
+                elif s.exact_cardinality:
+                    prop_pv_literal(SH.maxCount, s.exact_cardinality)
+                elif not s.multivalued:
+                    prop_pv_literal(SH.maxCount, 1)
                 prop_pv_literal(SH.minInclusive, s.minimum_value)
                 prop_pv_literal(SH.maxInclusive, s.maximum_value)
 
@@ -198,8 +208,6 @@ class ShaclGenerator(Generator):
                         add_simple_data_type(prop_pv, r)
                     if s.pattern:
                         prop_pv(SH.pattern, Literal(s.pattern))
-                    if s.annotations and self.include_annotations:
-                        self._add_annotations(prop_pv, s)
                     if s.equals_string:
                         # Map equal_string and equal_string_in to sh:in
                         self._and_equals_string(g, prop_pv, [s.equals_string])
@@ -207,6 +215,9 @@ class ShaclGenerator(Generator):
                         # Map equal_string and equal_string_in to sh:in
                         self._and_equals_string(g, prop_pv, s.equals_string_in)
 
+                if s.annotations and self.include_annotations:
+                    self._add_annotations(prop_pv, s)
+
                 default_value = ifabsent_processor.process_slot(s, c)
                 if default_value:
                     prop_pv(SH.defaultValue, default_value)

linkml/generators/shexgen.py

@@ -1,6 +1,4 @@
-"""Generate ShEx definition of a model
-
-"""
+"""Generate ShEx definition of a model"""
 
 import os
 import urllib.parse as urlparse

linkml/generators/summarygen.py

@@ -1,6 +1,4 @@
-"""Generate Summary Spreadsheets
-
-"""
+"""Generate Summary Spreadsheets"""
 
 import os
 from csv import DictWriter

linkml/generators/typescriptgen.py

@@ -280,7 +280,9 @@ def cli(yamlfile, gen_type_utils=False, include_induced_slots=False, output=None
     gen = TypescriptGenerator(
         yamlfile, gen_type_utils=gen_type_utils, include_induced_slots=include_induced_slots, **args
     )
-    gen.serialize(output=output)
+    serialized = gen.serialize(output=output)
+    if output is None:
+        print(serialized)
 
 
 if __name__ == "__main__":

linkml/generators/yamlgen.py

@@ -1,6 +1,4 @@
-"""Validate linkml input and optionally emit completely resolved biolink yaml output
-
-"""
+"""Validate linkml input and optionally emit completely resolved biolink yaml output"""
 
 import os
 from dataclasses import dataclass

linkml/linter/rules.py

@@ -134,7 +134,9 @@ class TreeRootClassRule(LinterRule):
             if self.config.validate_existing_class_name:
                 for tree_root in tree_roots:
                     if str(tree_root.name) != self.config.root_class_name:
-                        yield LinterProblem(message=f"Tree root class has name '{tree_root.name}'")
+                        yield LinterProblem(message=f"Tree root class has an invalid name '{tree_root.name}'")
+            if len(tree_roots) > 1:
+                yield LinterProblem("Schema has more than one class with `tree_root: true`")
         else:
             if fix:
                 container = ClassDefinition(self.config.root_class_name, tree_root=True)

linkml/transformers/logical_model_transformer.py

@@ -409,11 +409,13 @@ class LogicalModelTransformer(ModelTransformer):
         target_class_name: ClassDefinitionName,
         ancestors: List[ClassDefinitionName],
     ):
-        anc_classes = [self.schemaview.get_class(anc) for anc in ancestors]
+        anc_classes = [self.schemaview.get_class(ancestor) for ancestor in ancestors]
         attributes: Dict[SlotDefinitionName, SlotDefinition] = {}
-        for anc in anc_classes:
-            top_level_slots = [(s, target_schema.slots[s]) for s in anc.slots]
-            for slot_name, slot_expr in list(anc.attributes.items()) + list(anc.slot_usage.items()) + top_level_slots:
+        for ancestor_class in anc_classes:
+            top_level_slots = [(s, target_schema.slots[s]) for s in ancestor_class.slots]
+            for slot_name, slot_expr in (
+                list(ancestor_class.attributes.items()) + list(ancestor_class.slot_usage.items()) + top_level_slots
+            ):
                 if slot_name not in attributes:
                     attributes[slot_name] = SlotDefinition(slot_name)
                 sx = attributes[slot_name]
@@ -644,7 +646,7 @@ class LogicalModelTransformer(ModelTransformer):
         if slot_expression.all_of:
             exprs.append(logictools.And(*[self._as_logical_expression(subx) for subx in slot_expression.all_of]))
         if slot_expression.exactly_one_of:
-            # TODO: disjointness
+            # TODO: disjointedness
             exprs.append(logictools.Or(*[self._as_logical_expression(subx) for subx in slot_expression.exactly_one_of]))
         if slot_expression.none_of:
             exprs.append(

linkml/utils/converter.py

@@ -1,8 +1,10 @@
 import logging
 import os
+import pathlib
 import sys
 
 import click
+import yaml
 from linkml_runtime.linkml_model import Prefix
 from linkml_runtime.utils import inference_utils
 from linkml_runtime.utils.compile_python import compile_python
@@ -55,6 +57,7 @@ logger = logging.getLogger(__name__)
 @click.option("--index-slot", "-S", help="top level slot. Required for CSV dumping/loading")
 @click.option("--schema", "-s", help="Path to schema specified as LinkML yaml")
 @click.option("--prefix", "-P", multiple=True, help="Prefixmap base=URI pairs")
+@click.option("--prefix-file", help="Path to yaml file containing base=URI pairs")
 @click.option(
     "--validate/--no-validate",
     default=True,
@@ -79,6 +82,7 @@ def cli(
     input_format=None,
     output_format=None,
     prefix=None,
+    prefix_file=None,
     target_class_from_path=None,
     schema=None,
     validate=None,
@@ -99,6 +103,8 @@ def cli(
 
     For more information, see https://linkml.io/linkml/data/index.html
     """
+    if prefix and prefix_file is not None:
+        raise Exception("Either set prefix OR prefix_file, not both.")
     if prefix is None:
         prefix = []
     if module is None:
@@ -113,6 +119,17 @@ def cli(
         for p in prefix:
             base, uri = p.split("=")
             prefix_map[base] = uri
+    if prefix_file is not None:
+        prefix_path = pathlib.Path(prefix_file).resolve()
+        if not prefix_path.exists():
+            raise Exception(f"Path {prefix_file} to prefix map does not exists.")
+        with open(prefix_path, "r") as prefix_stream:
+            raw_prefix_map = yaml.safe_load(prefix_stream)
+        prefix_file_map = raw_prefix_map.get("prefixes", None)
+        if prefix_file_map is None:
+            raise Exception("Provided prefix file does not contain the prefixes key.")
+        prefix_map = prefix_file_map
+
     if schema is not None:
         sv = SchemaView(schema)
         if prefix_map:

linkml/utils/deprecation.py

@@ -222,6 +222,16 @@ DEPRECATIONS = (
         recommendation="Update dependent packages to use pydantic>=2",
         issue=1925,
     ),
+    Deprecation(
+        name="validators",
+        deprecated_in=SemVer.from_str("1.8.6"),
+        removed_in=SemVer.from_str("1.9.0"),
+        message=(
+            "linkml.validators and linkml.utils.validation are the older versions "
+            "of linkml.validator and have unmaintained, duplicated functionality"
+        ),
+        recommendation="Update to use linkml.validator",
+    ),
 )  # type: tuple[Deprecation, ...]
 
 EMITTED = set()  # type: set[str]

linkml/utils/generator.py

@@ -27,6 +27,7 @@ from typing import Callable, ClassVar, Dict, List, Mapping, Optional, Set, TextI
 
 import click
 from click import Argument, Command, Option
+from jsonasobj2 import JsonObj
 from linkml_runtime import SchemaView
 from linkml_runtime.linkml_model.meta import (
     ClassDefinition,
@@ -265,8 +266,16 @@ class Generator(metaclass=abc.ABCMeta):
     def _init_namespaces(self):
         if self.namespaces is None:
             self.namespaces = Namespaces()
-            for prefix in self.schema.prefixes.values():
-                self.namespaces[prefix.prefix_prefix] = prefix.prefix_reference
+            if isinstance(self.schema.prefixes, dict):
+                for key, value in self.schema.prefixes.items():
+                    self.namespaces[key] = value
+            elif isinstance(self.schema.prefixes, JsonObj):
+                prefixes = vars(self.schema.prefixes)
+                for key, value in prefixes.items():
+                    self.namespaces[key] = value
+            else:
+                for prefix in self.schema.prefixes.values():
+                    self.namespaces[prefix.prefix_prefix] = prefix.prefix_reference
 
     def serialize(self, **kwargs) -> str:
         """