linkml 1.8.5__tar.gz → 1.8.6__tar.gz

{linkml-1.8.5 → linkml-1.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml
-Version: 1.8.5
+Version: 1.8.6
 Summary: Linked Open Data Modeling Language
 Home-page: https://linkml.io/linkml/
 Keywords: schema,linked data,data modeling,rdf,owl,biolink
@@ -53,7 +53,7 @@ Requires-Dist: pyyaml
 Requires-Dist: rdflib (>=6.0.0)
 Requires-Dist: requests (>=2.22)
 Requires-Dist: sqlalchemy (>=1.4.31)
-Requires-Dist: typing-extensions (>=4.4.0) ; python_version < "3.9"
+Requires-Dist: typing-extensions (>=4.6.0) ; python_version < "3.12"
 Requires-Dist: watchdog (>=0.9.0)
 Project-URL: Documentation, https://linkml.io/linkml/
 Project-URL: Repository, https://github.com/linkml/linkml

{linkml-1.8.5 → linkml-1.8.6}/linkml/cli/main.py

@@ -8,6 +8,7 @@ import click
 
 from linkml._version import __version__
 from linkml.generators.csvgen import cli as gen_csv
+from linkml.generators.dbmlgen import cli as gen_dbml
 from linkml.generators.docgen import cli as gen_doc
 from linkml.generators.dotgen import cli as gen_graphviz
 from linkml.generators.erdiagramgen import cli as gen_erdiagram
@@ -125,6 +126,7 @@ generate.add_command(gen_project, name="project")
 generate.add_command(gen_excel, name="excel")
 generate.add_command(gen_sssom, name="sssom")
 generate.add_command(gen_linkml, name="linkml")
+generate.add_command(gen_dbml, name="dbml")
 
 # Dev helpers
 dev.add_command(run_tutorial, name="tutorial")

{linkml-1.8.5 → linkml-1.8.6}/linkml/generators/common/build.py

@@ -5,7 +5,6 @@ Models for intermediate build results
 """
 
 import dataclasses
-from abc import abstractmethod
 from typing import Any, TypeVar
 
 try:
@@ -57,11 +56,11 @@ class BuildResult(BaseModel):
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    @abstractmethod
     def merge(self, other: T) -> T:
         """
         Build results should have some means of merging results of a like kind
         """
+        raise NotImplementedError("This build result doesn't know how to merge!")
 
 
 class SchemaResult(BuildResult):

{linkml-1.8.5 → linkml-1.8.6}/linkml/generators/common/lifecycle.py

@@ -13,7 +13,7 @@ from linkml_runtime.linkml_model.meta import (
     TypeDefinition,
 )
 
-from linkml.generators.common.build import ClassResult, RangeResult, SchemaResult, SlotResult, TypeResult
+from linkml.generators.common.build import ClassResult, EnumResult, RangeResult, SchemaResult, SlotResult, TypeResult
 from linkml.generators.common.template import TemplateModel
 
 TSchema = TypeVar("TSchema", bound=SchemaResult)
@@ -21,7 +21,7 @@ TClass = TypeVar("TClass", bound=ClassResult)
 TSlot = TypeVar("TSlot", bound=SlotResult)
 TRange = TypeVar("TRange", bound=RangeResult)
 TType = TypeVar("TType", bound=TypeResult)
-TEnum = TypeVar("TEnum", bound=EnumDefinition)
+TEnum = TypeVar("TEnum", bound=EnumResult)
 TTemplate = TypeVar("TTemplate", bound=TemplateModel)
 
 
@@ -93,6 +93,22 @@ class LifecycleMixin:
     def after_generate_slots(self, slot: Iterable[TSlot], sv: SchemaView) -> Iterable[TSlot]:
         return slot
 
+    def before_generate_class_slot(self, slot: SlotDefinition, cls: ClassDefinition, sv: SchemaView) -> SlotDefinition:
+        return slot
+
+    def after_generate_class_slot(self, slot: TSlot, cls: ClassDefinition, sv: SchemaView) -> TSlot:
+        return slot
+
+    def before_generate_class_slots(
+        self, slot: Iterable[SlotDefinition], cls: ClassDefinition, sv: SchemaView
+    ) -> Iterable[SlotDefinition]:
+        return slot
+
+    def after_generate_class_slots(
+        self, slot: Iterable[TSlot], cls: ClassDefinition, sv: SchemaView
+    ) -> Iterable[TSlot]:
+        return slot
+
     def before_generate_type(self, typ: TypeDefinition, sv: SchemaView) -> TypeDefinition:
         return typ
 

linkml-1.8.6/linkml/generators/dbmlgen.py

@@ -0,0 +1,173 @@
+import logging
+
+import click
+from linkml_runtime.utils.formatutils import camelcase, underscore
+from linkml_runtime.utils.schemaview import SchemaView
+
+from linkml.utils.generator import Generator
+
+
+def _map_range_to_dbml_type(range_name: str) -> str:
+    """
+    Map LinkML range types to DBML types.
+
+    :param range_name: LinkML range name
+    :return: Corresponding DBML type
+    """
+    type_mapping = {
+        "string": "varchar",
+        "integer": "int",
+        "float": "float",
+        "boolean": "boolean",
+        "date": "date",
+        "datetime": "datetime",
+    }
+    return type_mapping.get(range_name, "varchar")  # Default to varchar
+
+
+class DBMLGenerator(Generator):
+    """
+    A generator for converting a LinkML schema into DBML (Database Markup Language).
+    """
+
+    generatorname = "dbmlgen"
+    generatorversion = "0.2.0"
+    valid_formats = ["dbml"]
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        self.logger = logging.getLogger(__name__)
+        self.schemaview = SchemaView(self.schema)
+
+    def serialize(self) -> str:
+        """
+        Generate DBML representation of the LinkML schema.
+
+        :return: DBML as a string
+        """
+        dbml_lines = [
+            "// DBML generated from LinkML schema\n",
+            f"Project {{\n  name: '{self.schemaview.schema.name}'\n}}\n",
+        ]
+
+        for class_name, class_def in self.schemaview.all_classes().items():
+            dbml_lines.append(self._generate_table(class_name, class_def))
+
+        # Generate relationships if applicable
+        relationships = self._generate_relationships()
+        if relationships:
+            dbml_lines.append(relationships)
+
+        return "\n".join(dbml_lines)
+
+    def _generate_table(self, class_name: str, class_def) -> str:
+        """
+        Generate the DBML for a single class (table).
+
+        :param class_name: Name of the class
+        :param class_def: ClassDefinition object
+        :return: DBML representation of the class
+        """
+        dbml = [f"Table {camelcase(class_name)} {{"]
+
+        for slot_name in self.schemaview.class_induced_slots(class_name):
+            slot = self.schemaview.get_slot(slot_name.name)
+            dbml.append(self._generate_column(slot))
+
+        dbml.append("}\n")
+        return "\n".join(dbml)
+
+    def _generate_column(self, slot) -> str:
+        """
+        Generate the DBML for a single slot (column).
+
+        :param slot: SlotDefinition object
+        :return: DBML representation of the column
+        """
+        column_name = slot.name
+        data_type = _map_range_to_dbml_type(slot.range or "string")
+        constraints = []
+        constraints_str = ""
+
+        if slot.required:
+            constraints.append("not null")
+        if slot.identifier:
+            constraints.append("primary key")
+
+        if constraints:
+            constraints_str = f"{', '.join(constraints)}"
+            constraints_str = "[" + constraints_str + "]"
+
+        return f"  {underscore(column_name)} {data_type} {constraints_str}".strip()
+
+    def _generate_relationships(self) -> str:
+        """
+        Generate DBML relationships based on slot ranges referencing other classes.
+
+        :return: DBML representation of relationships
+        """
+        relationships = []
+        for class_name, class_def in self.schemaview.all_classes().items():
+            for slot_name in self.schemaview.class_induced_slots(class_name):
+                slot = self.schemaview.get_slot(slot_name.name)
+
+                # Check if the slot references another class
+                if slot.range in self.schemaview.all_classes():
+
+                    # Find the identifier slot of the referenced class
+                    identifier_slot_name = next(
+                        (
+                            slot_name.name
+                            for slot_name in self.schemaview.class_induced_slots(slot.range)
+                            if self.schemaview.get_slot(slot_name.name).identifier
+                        ),
+                        None,
+                    )
+
+                    if identifier_slot_name is None:
+                        raise ValueError(f"Referenced class '{slot.range}' does not have an identifier slot.")
+
+                    # Generate the DBML relationship
+                    relationships.append(
+                        f"Ref: {camelcase(class_name)}.{underscore(slot.name)} > "
+                        f"{camelcase(slot.range)}.{underscore(identifier_slot_name)}"
+                    )
+        return "\n".join(relationships)
+
+
+# CLI Definition
+@click.command()
+@click.option(
+    "--schema",
+    "-s",
+    required=True,
+    type=click.Path(exists=True, dir_okay=False, file_okay=True),
+    help="Path to the LinkML schema YAML file",
+)
+@click.option(
+    "--output",
+    "-o",
+    required=False,
+    type=click.Path(dir_okay=False, writable=True),
+    help="Path to save the generated DBML file. If not specified, DBML will be printed to stdout.",
+)
+def cli(schema, output):
+    """
+    CLI for LinkML to DBML generator.
+    """
+    generator = DBMLGenerator(schema)
+
+    # Generate the DBML
+    dbml_output = generator.serialize()
+
+    # Save to file or print to stdout
+    if output:
+        with open(output, "w", encoding="utf-8") as f:
+            f.write(dbml_output)
+        click.echo(f"DBML has been saved to {output}")
+    else:
+        click.echo(dbml_output)
+
+
+if __name__ == "__main__":
+    cli()

{linkml-1.8.5 → linkml-1.8.6}/linkml/generators/erdiagramgen.py

@@ -308,6 +308,7 @@ class ERDiagramGenerator(Generator):
     default=False,
     help="If True, follow references even if not inlined",
 )
+@click.option("--format", "-f", default="markdown", type=click.Choice(ERDiagramGenerator.valid_formats))
 @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("--include-upstream", is_flag=True, help="Include upstream classes")

{linkml-1.8.5 → linkml-1.8.6}/linkml/generators/jsonldcontextgen.py

@@ -146,7 +146,13 @@ class ContextGenerator(Generator):
             slot_def = {}
             if not slot.usage_slot_name:
                 any_of_ranges = [any_of_el.range for any_of_el in slot.any_of]
-                if slot.range in self.schema.classes or any(rng in self.schema.classes for rng in any_of_ranges):
+                if slot.range in self.schema.classes:
+                    range_class_uri = self.schema.classes[slot.range].class_uri
+                    if range_class_uri and slot.inlined:
+                        slot_def["@type"] = range_class_uri
+                    else:
+                        slot_def["@type"] = "@id"
+                elif any(rng in self.schema.classes for rng in any_of_ranges):
                     slot_def["@type"] = "@id"
                 elif slot.range in self.schema.enums:
                     slot_def["@context"] = ENUM_CONTEXT

{linkml-1.8.5 → linkml-1.8.6}/linkml/generators/jsonschemagen.py

@@ -21,8 +21,11 @@ from linkml_runtime.linkml_model.meta import (
 from linkml_runtime.utils.formatutils import be, camelcase, underscore
 
 from linkml._version import __version__
+from linkml.generators.common import build
+from linkml.generators.common.lifecycle import LifecycleMixin
 from linkml.generators.common.type_designators import get_type_designator_value
 from linkml.utils.generator import Generator, shared_arguments
+from linkml.utils.helpers import get_range_associated_slots
 
 logger = logging.getLogger(__name__)
 
@@ -177,8 +180,32 @@ class JsonSchema(dict):
         return JsonSchema(schema)
 
 
+class SchemaResult(build.SchemaResult):
+    """Top-level result of building a json schema"""
+
+    schema_: JsonSchema
+
+
+class EnumResult(build.EnumResult):
+    """A single built enum"""
+
+    schema_: JsonSchema
+
+
+class ClassResult(build.ClassResult):
+    """A single built class"""
+
+    schema_: JsonSchema
+
+
+class SlotResult(build.SlotResult):
+    """A slot within the context of a class"""
+
+    schema_: JsonSchema
+
+
 @dataclass
-class JsonSchemaGenerator(Generator):
+class JsonSchemaGenerator(Generator, LifecycleMixin):
     """
     Generates JSONSchema documents from a LinkML SchemaDefinition
 
@@ -187,6 +214,21 @@ class JsonSchemaGenerator(Generator):
     - Composition not yet implemented
     - Enumerations treated as strings
     - Foreign key references are treated as semantics-free strings
+
+    This generator implements the following :class:`.LifecycleMixin` methods:
+
+    * :meth:`.LifecycleMixin.before_generate_schema`
+    * :meth:`.LifecycleMixin.after_generate_schema`
+    * :meth:`.LifecycleMixin.before_generate_classes`
+    * :meth:`.LifecycleMixin.before_generate_enums`
+    * :meth:`.LifecycleMixin.before_generate_class_slots`
+    * :meth:`.LifecycleMixin.before_generate_class`
+    * :meth:`.LifecycleMixin.after_generate_class`
+    * :meth:`.LifecycleMixin.before_generate_class_slot`
+    * :meth:`.LifecycleMixin.after_generate_class_slot`
+    * :meth:`.LifecycleMixin.before_generate_enum`
+    * :meth:`.LifecycleMixin.after_generate_enum`
+
     """
 
     # ClassVars
@@ -233,7 +275,7 @@ class JsonSchemaGenerator(Generator):
             if self.schemaview.get_class(self.top_class) is None:
                 logger.warning(f"No class in schema named {self.top_class}")
 
-    def start_schema(self, inline: bool = False) -> JsonSchema:
+    def start_schema(self, inline: bool = False):
         self.inline = inline
 
         self.top_level_schema = JsonSchema(
@@ -249,6 +291,8 @@ class JsonSchemaGenerator(Generator):
         )
 
     def handle_class(self, cls: ClassDefinition) -> None:
+        cls = self.before_generate_class(cls, self.schemaview)
+
         if cls.mixin or cls.abstract:
             return
 
@@ -268,7 +312,10 @@ class JsonSchemaGenerator(Generator):
         if self.title_from == "title" and cls.title:
             class_subschema["title"] = cls.title
 
-        for slot_definition in self.schemaview.class_induced_slots(cls.name):
+        class_slots = self.before_generate_class_slots(
+            self.schemaview.class_induced_slots(cls.name), cls, self.schemaview
+        )
+        for slot_definition in class_slots:
             self.handle_class_slot(subschema=class_subschema, cls=cls, slot=slot_definition)
 
         rule_subschemas = []
@@ -318,6 +365,10 @@ class JsonSchemaGenerator(Generator):
                 class_subschema["allOf"] = []
             class_subschema["allOf"].extend(rule_subschemas)
 
+        class_subschema = self.after_generate_class(
+            ClassResult.model_construct(schema_=class_subschema, source=cls), self.schemaview
+        ).schema_
+
         self.top_level_schema.add_def(cls.name, class_subschema)
 
         if (self.top_class is not None and camelcase(self.top_class) == camelcase(cls.name)) or (
@@ -375,6 +426,7 @@ class JsonSchemaGenerator(Generator):
     def handle_enum(self, enum: EnumDefinition) -> None:
         # TODO: this only works with explicitly permitted values. It will need to be extended to
         # support other pv_formula
+        enum = self.before_generate_enum(enum, self.schemaview)
 
         def extract_permissible_text(pv):
             if isinstance(pv, str):
@@ -398,6 +450,10 @@ class JsonSchemaGenerator(Generator):
 
         if permissible_values_texts:
             enum_schema["enum"] = permissible_values_texts
+
+        enum_schema = self.after_generate_enum(
+            EnumResult.model_construct(schema_=enum_schema, source=enum), self.schemaview
+        ).schema_
         self.top_level_schema.add_def(enum.name, enum_schema)
 
     def get_type_info_for_slot_subschema(
@@ -490,7 +546,7 @@ class JsonSchemaGenerator(Generator):
                         range_id_slot,
                         range_simple_dict_value_slot,
                         range_required_slots,
-                    ) = self._get_range_associated_slots(slot)
+                    ) = get_range_associated_slots(self.schemaview, slot.range)
                     # if the range class has an ID and the slot is not inlined as a list, then we need to consider
                     # various inlined as dict formats
                     if range_id_slot is not None and not slot.inlined_as_list:
@@ -596,6 +652,7 @@ class JsonSchemaGenerator(Generator):
         return prop
 
     def handle_class_slot(self, subschema: JsonSchema, cls: ClassDefinition, slot: SlotDefinition) -> None:
+        slot = self.before_generate_class_slot(slot, cls, self.schemaview)
         class_id_slot = self.schemaview.get_identifier_slot(cls.name, use_key=True)
         value_required = (
             slot.required or slot == class_id_slot or slot.value_presence == PresenceEnum(PresenceEnum.PRESENT)
@@ -604,6 +661,9 @@ class JsonSchemaGenerator(Generator):
 
         aliased_slot_name = self.aliased_slot_name(slot)
         prop = self.get_subschema_for_slot(slot, include_null=self.include_null)
+        prop = self.after_generate_class_slot(
+            SlotResult.model_construct(schema_=prop, source=slot), cls, self.schemaview
+        ).schema_
         subschema.add_property(
             aliased_slot_name, prop, value_required=value_required, value_disallowed=value_disallowed
         )
@@ -613,65 +673,25 @@ class JsonSchemaGenerator(Generator):
             prop["enum"] = [type_value]
 
     def generate(self) -> JsonSchema:
+        self.schema = self.before_generate_schema(self.schema, self.schemaview)
         self.start_schema()
-        for enum_definition in self.schemaview.all_enums().values():
+
+        all_enums = self.before_generate_enums(self.schemaview.all_enums().values(), self.schemaview)
+        for enum_definition in all_enums:
             self.handle_enum(enum_definition)
 
-        for class_definition in self.schemaview.all_classes().values():
+        all_classes = self.before_generate_classes(self.schemaview.all_classes().values(), self.schemaview)
+        for class_definition in all_classes:
             self.handle_class(class_definition)
 
+        self.top_level_schema = self.after_generate_schema(
+            SchemaResult.model_construct(schema_=self.top_level_schema, source=self.schema), self.schemaview
+        ).schema_
         return self.top_level_schema
 
     def serialize(self, **kwargs) -> str:
         return self.generate().to_json(sort_keys=True, indent=self.indent if self.indent > 0 else None)
 
-    def _get_range_associated_slots(
-        self, slot: SlotDefinition
-    ) -> Tuple[Union[SlotDefinition, None], Union[SlotDefinition, None], Union[List[SlotDefinition], None]]:
-        range_class = self.schemaview.get_class(slot.range)
-        if range_class is None:
-            return None, None, None
-
-        range_class_id_slot = self.schemaview.get_identifier_slot(range_class.name, use_key=True)
-        if range_class_id_slot is None:
-            return None, None, None
-
-        non_id_slots = [
-            s for s in self.schemaview.class_induced_slots(range_class.name) if s.name != range_class_id_slot.name
-        ]
-        non_id_required_slots = [s for s in non_id_slots if s.required]
-
-        # Some lists of objects can be serialized as SimpleDicts.
-        # A SimpleDict is serialized as simple key-value pairs where the value is atomic.
-        # The key must be declared as a key, and the value must satisfy one of the following conditions:
-        # 1. The value slot is the only other slot in the object other than the key
-        # 2. The value slot is explicitly annotated as a simple_dict_value
-        # 3. The value slot is the only non-key that is required
-        # See also: https://github.com/linkml/linkml/issues/1250
-        range_simple_dict_value_slot = None
-        if len(non_id_slots) == 1:
-            range_simple_dict_value_slot = non_id_slots[0]
-        elif len(non_id_slots) > 1:
-            candidate_non_id_slots = []
-            for non_id_slot in non_id_slots:
-                if isinstance(non_id_slot.annotations, dict):
-                    is_simple_dict_value = non_id_slot.annotations.get("simple_dict_value", False)
-                else:
-                    is_simple_dict_value = getattr(non_id_slot.annotations, "simple_dict_value", False)
-                if is_simple_dict_value:
-                    candidate_non_id_slots.append(non_id_slot)
-            if len(candidate_non_id_slots) == 1:
-                range_simple_dict_value_slot = candidate_non_id_slots[0]
-            else:
-                candidate_non_id_slots = []
-                for non_id_slot in non_id_slots:
-                    if non_id_slot.required:
-                        candidate_non_id_slots.append(non_id_slot)
-                if len(candidate_non_id_slots) == 1:
-                    range_simple_dict_value_slot = candidate_non_id_slots[0]
-
-        return range_class_id_slot, range_simple_dict_value_slot, non_id_required_slots
-
 
 @shared_arguments(JsonSchemaGenerator)
 @click.command(name="json-schema")

{linkml-1.8.5 → linkml-1.8.6}/linkml/generators/linkmlgen.py

@@ -78,6 +78,12 @@ class LinkmlGenerator(Generator):
 
 
 @shared_arguments(LinkmlGenerator)
+@click.option(
+    "--materialize/--no-materialize",
+    default=True,
+    show_default=True,
+    help="Materialize both, induced slots as attributes and structured patterns as patterns",
+)
 @click.option(
     "--materialize-attributes/--no-materialize-attributes",
     default=True,
@@ -86,7 +92,7 @@ class LinkmlGenerator(Generator):
 )
 @click.option(
     "--materialize-patterns/--no-materialize-patterns",
-    default=False,
+    default=True,
     show_default=True,
     help="Materialize structured patterns as patterns",
 )
@@ -100,11 +106,17 @@ class LinkmlGenerator(Generator):
 @click.command(name="linkml")
 def cli(
     yamlfile,
+    materialize: bool,
     materialize_attributes: bool,
     materialize_patterns: bool,
     output: FILE_TYPE = None,
     **kwargs,
 ):
+    # You can use the `--materialize` / `--no-materialize` for control
+    # over both attribute and pattern materialization.
+    materialize_attributes = bool(materialize)
+    materialize_patterns = bool(materialize)
+
     gen = LinkmlGenerator(
         yamlfile,
         materialize_attributes=materialize_attributes,

{linkml-1.8.5 → linkml-1.8.6}/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.
@@ -1254,7 +1257,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 +1356,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-1.8.5 → linkml-1.8.6}/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"""