linkml 1.9.4rc1__py3-none-any.whl → 1.9.5__py3-none-any.whl

linkml/cli/main.py

@@ -7,6 +7,7 @@ Gathers all the other linkml click entrypoints and puts them under ``linkml`` :)
 import click
 
 from linkml._version import __version__
+from linkml.converter.cli import cli as linkml_convert
 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
@@ -32,6 +33,7 @@ from linkml.generators.protogen import cli as gen_proto
 from linkml.generators.pydanticgen import cli as gen_pydantic
 from linkml.generators.pythongen import cli as gen_python
 from linkml.generators.rdfgen import cli as gen_rdf
+from linkml.generators.rustgen.cli import cli as gen_rust
 from linkml.generators.shaclgen import cli as gen_shacl
 from linkml.generators.shexgen import cli as gen_shex
 from linkml.generators.sparqlgen import cli as gen_sparql
@@ -42,9 +44,9 @@ from linkml.generators.summarygen import cli as gen_summary
 from linkml.generators.terminusdbgen import cli as gen_terminusdb
 from linkml.generators.typescriptgen import cli as gen_typescript
 from linkml.generators.yamlgen import cli as gen_yaml
+from linkml.generators.yarrrmlgen import cli as gen_yarrrml
 from linkml.generators.yumlgen import cli as gen_yuml
 from linkml.linter.cli import main as linkml_lint
-from linkml.utils.converter import cli as linkml_convert
 from linkml.utils.execute_tutorial import cli as run_tutorial
 from linkml.utils.schema_fixer import main as linkml_schema_fixer
 from linkml.utils.sqlutils import main as linkml_sqldb
@@ -113,6 +115,7 @@ generate.add_command(gen_python, name="python")
 generate.add_command(gen_pydantic, name="pydantic")
 generate.add_command(gen_pandera, name="pandera")
 generate.add_command(gen_rdf, name="rdf")
+generate.add_command(gen_rust, name="rust")
 generate.add_command(gen_shex, name="shex")
 generate.add_command(gen_shacl, name="shacl")
 generate.add_command(gen_sparql, name="sparql")
@@ -129,6 +132,7 @@ 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")
+generate.add_command(gen_yarrrml, name="yarrrml")
 
 # Dev helpers
 dev.add_command(run_tutorial, name="tutorial")

linkml/generators/__init__.py

@@ -12,6 +12,7 @@ from linkml.generators.panderagen import PanderaGenerator
 from linkml.generators.pydanticgen import PydanticGenerator
 from linkml.generators.pythongen import PythonGenerator
 from linkml.generators.rdfgen import RDFGenerator
+from linkml.generators.rustgen import RustGenerator
 from linkml.generators.shaclgen import ShaclGenerator
 from linkml.generators.shexgen import ShExGenerator
 from linkml.generators.sqlalchemygen import SQLAlchemyGenerator
@@ -49,6 +50,7 @@ __all__ = [
     "ContextGenerator",
     "JSONLDGenerator",
     "JsonSchemaGenerator",
+    "RustGenerator",
     "ShaclGenerator",
     "ShExGenerator",
     "SQLAlchemyGenerator",

linkml/generators/common/build.py

@@ -4,38 +4,23 @@ Models for intermediate build results
 (see PydanticGenerator for example implementation and use)
 """
 
-import dataclasses
-from typing import Annotated, Any, TypeVar
+from typing import Annotated, TypeVar
 
 from linkml_runtime.linkml_model import (
     ClassDefinition,
+    Definition,
     EnumDefinition,
     SchemaDefinition,
     SlotDefinition,
     TypeDefinition,
 )
-from pydantic import BaseModel, ConfigDict, GetCoreSchemaHandler
+from pydantic import BaseModel, ConfigDict, GetPydanticSchema
 from pydantic_core import core_schema
 
 T = TypeVar("T", bound="BuildResult", covariant=True)
+Tsv = TypeVar("Tsv", bound=Definition, covariant=True)
 
-
-@dataclasses.dataclass()
-class SkipValidation:
-    """
-    A version of :class:`pydantic.SkipValidation` that actually skips generating the
-    schema for the field entirely - useful for including types that don't need to be validated
-    like the metamodel dataclasses
-    """
-
-    def __class_getitem__(cls, item: Any) -> Any:
-        return Annotated[item, SkipValidation()]
-
-    @classmethod
-    def __get_pydantic_core_schema__(cls, source: Any, handler: GetCoreSchemaHandler) -> core_schema.CoreSchema:
-        return core_schema.any_schema()
-
-    __hash__ = object.__hash__
+SkipValidation = Annotated[Tsv, GetPydanticSchema(lambda tp, handler: core_schema.any_schema())]
 
 
 class BuildResult(BaseModel):

linkml/generators/common/template.py

@@ -4,11 +4,12 @@ Base classes for jinja template handling classes.
 See :mod:`.linkml.generators.pydanticgen.template` for example implementation
 """
 
+from collections.abc import Generator
 from copy import copy
 from typing import Any, ClassVar, Optional, Union
 
 from jinja2 import Environment
-from pydantic import BaseModel
+from pydantic import BaseModel, Field, field_validator
 
 
 class TemplateModel(BaseModel):
@@ -42,7 +43,7 @@ class TemplateModel(BaseModel):
             environment (:class:`jinja2.Environment`): Template environment - see :meth:`.environment`
         """
         if environment is None:
-            environment = TemplateModel.environment()
+            environment = type(self).environment()
 
         fields = {**self.model_fields, **self.model_computed_fields}
 
@@ -72,6 +73,291 @@ class TemplateModel(BaseModel):
         return ret
 
 
+class ObjectImport(BaseModel):
+    """
+    An object to be imported from within a module.
+
+    See :class:`.Import` for examples
+    """
+
+    name: str
+    alias: Optional[str] = None
+
+
+class Import(TemplateModel):
+    """
+    A module or module and classes to be imported.
+    """
+
+    module: str
+    alias: Optional[str] = None
+    objects: Optional[list[ObjectImport]] = None
+    is_schema: bool = False
+    """
+    Whether or not this ``Import`` is importing another schema imported by the main schema --
+    ie. that it is not expected to be provided by the environment, but imported locally from within the package.
+    Used primarily in split schema generation, see :func:`.pydanticgen.generate_split` for example usage.
+    """
+
+    def merge(self, other: "Import") -> list["Import"]:
+        """
+        Merge one import with another, see :meth:`.Imports` for an example.
+
+        * If module don't match, return both
+        * If one or the other are a :class:`.ConditionalImport`, return both
+        * If modules match, neither contain objects, but the other has an alias, return the other
+        * If modules match, one contains objects but the other doesn't, return both
+        * If modules match, both contain objects, merge the object lists, preferring objects with aliases
+        """
+        # return both if we are orthogonal
+        if self.module != other.module:
+            return [self, other]
+
+        # handle conditionals
+        if isinstance(self, ConditionalImport) and isinstance(other, ConditionalImport):
+            # If our condition is the same, return the newer version
+            if self.condition == other.condition:
+                return [other]
+        if isinstance(self, ConditionalImport) or isinstance(other, ConditionalImport):
+            # we don't have a good way of combining conditionals, just return both
+            return [self, other]
+
+        # handle module vs. object imports
+        elif other.objects is None and self.objects is None:
+            # both are modules, return the other only if it updates the alias
+            if other.alias:
+                return [other]
+            else:
+                return [self]
+        elif other.objects is not None and self.objects is not None:
+            # both are object imports, merge and return
+            alias = self.alias if other.alias is None else other.alias
+            # FIXME: super awkward implementation
+            # keep ours if it has an alias and the other doesn't,
+            # otherwise take the other's version
+            self_objs = {obj.name: obj for obj in self.objects}
+            other_objs = {
+                obj.name: obj for obj in other.objects if obj.name not in self_objs or self_objs[obj.name].alias is None
+            }
+            self_objs.update(other_objs)
+
+            return [
+                type(self)(
+                    module=self.module,
+                    alias=alias,
+                    objects=list(self_objs.values()),
+                    is_schema=self.is_schema or other.is_schema,
+                    **{
+                        k: getattr(other, k)
+                        for k in other.model_fields
+                        if k not in ("module", "alias", "objects", "is_schema")
+                    },
+                )
+            ]
+        else:
+            # one is a module, the other imports objects, keep both
+            return [self, other]
+
+    def sort(self) -> None:
+        """
+        Sort imported objects
+
+        * First by whether the first letter is capitalized or not,
+        * Then alphabetically (by object name rather than alias)
+        """
+        if self.objects:
+            self.objects = sorted(self.objects, key=lambda obj: (obj.name[0].islower(), obj.name))
+
+
+class ConditionalImport(Import):
+    """
+    Import that depends on some condition in the environment, common when
+    using backported features or straddling dependency versions.
+
+    Make sure that everything that is needed to evaluate the condition is imported
+    before this is added to the injected imports!
+    """
+
+    condition: str
+    alternative: Import
+
+    def sort(self) -> None:
+        """
+        :meth:`.Import.sort` called for self and :attr:`.alternative`
+        """
+        super().sort()
+        self.alternative.sort()
+
+
+class Imports(TemplateModel):
+    """
+    Container class for imports that can handle merging!
+
+    See :class:`.Import` and :class:`.ConditionalImport` for examples of declaring individual imports
+
+    Useful for generation, because each build stage will potentially generate
+    overlapping imports. This ensures that we can keep a collection of imports
+    without having many duplicates.
+
+    Defines methods for adding, iterating, and indexing from within the :attr:`Imports.imports` list.
+    """
+
+    imports: list[Union[Import, ConditionalImport]] = Field(default_factory=list)
+    render_sorted: bool = True
+    """When rendering, render in sorted groups"""
+
+    @classmethod
+    def _merge(
+        cls, imports: list[Union[Import, ConditionalImport]], other: Union[Import, "Imports", list[Import]]
+    ) -> list[Union[Import, ConditionalImport]]:
+        """
+        Add a new import to an existing imports list, handling deduplication and flattening.
+
+        Mutates and returns ``imports``
+
+        Generally will prefer the imports in ``other`` , updating those in ``imports``.
+        If ``other`` ...
+        - doesn't match any ``module`` in ``imports``, add it!
+        - matches a single ``module`` in imports, :meth:`.Import.merge` the object imports
+        - matches multiple ``module``s in imports, then there must have been another
+            :class:`.ConditionalImport` already present, so we :meth:`.Import.merge` the existing
+            :class:`.Import` if it is one, and if it's a :class:`.ConditionalImport` just YOLO
+            and append it since there isn't a principled way to merge them from strings.
+        - is :class:`.Imports`  or a list of :class:`.Import` s, call this recursively for each
+          item.
+
+        Since imports can be merged in an undefined order depending on the generator configuration,
+        default behavior for imports with matching ``module`` is to remove them and append to the
+        end of the imports list (rather than keeping it in the position of the existing
+        :class:`.Import` ). :class:`.ConditionalImports` make it possible to have namespace
+        conflicts, so in imperative import style we assume the most recently added :class:`.Import`
+        is the one that should prevail.
+        """
+        #
+        if isinstance(other, cls) or (isinstance(other, list) and all([isinstance(i, Import) for i in other])):
+            for i in other:
+                imports = cls._merge(imports, i)
+            return imports
+
+        existing = [i for i in imports if i.module == other.module]
+
+        # if we have nothing importing from this module yet, add it!
+        if len(existing) == 0:
+            imports.append(other)
+        elif len(existing) == 1:
+            imports.remove(existing[0])
+            imports.extend(existing[0].merge(other))
+        else:
+            # we have both a conditional and at least one nonconditional already.
+            # If this is another conditional, we just add it, otherwise, we merge it
+            # with the single nonconditional
+            if isinstance(other, ConditionalImport):
+                imports.append(other)
+            else:
+                for e in existing:
+                    if isinstance(e, Import):
+                        imports.remove(e)
+                        merged = e.merge(other)
+                        imports.extend(merged)
+                        break
+
+        # SPECIAL CASE - __future__ annotations must happen at the top of a file
+        # sort here outside of sort method because our imports are invalid without it,
+        # where calling ``sort`` should be optional.
+        imports = sorted(imports, key=lambda i: i.module == "__future__", reverse=True)
+        return imports
+
+    def __add__(self, other: Union[Import, "Imports", list[Import]]) -> "Imports":
+        imports = self.imports.copy()
+        imports = self._merge(imports, other)
+        return type(self).model_construct(
+            imports=imports, **{k: getattr(self, k, None) for k in self.model_fields if k != "imports"}
+        )
+
+    def __len__(self) -> int:
+        return len(self.imports)
+
+    def __iter__(self) -> Generator[Import, None, None]:
+        yield from self.imports
+
+    def __getitem__(self, item: Union[int, str]) -> Import:
+        if isinstance(item, int):
+            return self.imports[item]
+        elif isinstance(item, str):
+            # the name of the module
+            an_import = [i for i in self.imports if i.module == item]
+            if len(an_import) == 0:
+                raise KeyError(f"No import with module {item} was found.\nWe have: {self.imports}")
+            return an_import[0]
+        else:
+            raise TypeError(f"Can only index with an int or a string as the name of the module,\nGot: {type(item)}")
+
+    def __contains__(self, item: Union[Import, "Imports", list[Import]]) -> bool:
+        """
+        Check if all the objects are imported from the given module(s)
+
+        If the import is a bare module import (ie its :attr:`~.Import.objects` is ``None`` )
+        then we must also have a bare module import in this Imports (because even if
+        we import from the module, unless we import it specifically its name won't be
+        available in the namespace.
+
+        :attr:`.Import.alias` must always match for the same reason.
+        """
+        if isinstance(item, Imports):
+            return all([i in self for i in item.imports])
+        elif isinstance(item, list):
+            return all([i in self for i in item])
+        elif isinstance(item, Import):
+            try:
+                an_import = self[item.module]
+            except KeyError:
+                return False
+            if item.objects is None:
+                return an_import == item
+            else:
+                return all([obj in an_import.objects for obj in item.objects])
+        else:
+            raise TypeError(f"Imports only contains single Import objects or other Imports\nGot: {type(item)}")
+
+    @field_validator("imports", mode="after")
+    @classmethod
+    def imports_are_merged(
+        cls, imports: list[Union[Import, ConditionalImport]]
+    ) -> list[Union[Import, ConditionalImport]]:
+        """
+        When creating from a list of imports, construct model as if we have done so by iteratively
+        constructing with __add__ calls
+        """
+        merged_imports = []
+        for i in imports:
+            merged_imports = cls._merge(merged_imports, i)
+        return merged_imports
+
+    def sort(self) -> None:
+        """
+        Sort imports recursively, mimicking isort:
+
+        * First by :attr:`.Import.group` according to :attr:`.Imports.group_order`
+        * Then by whether the :class:`.Import` has any objects
+          (``import module`` comes before ``from module import name``)
+        * Then alphabetically by module name
+        """
+
+        def _sort_key(i: Import) -> tuple[int, str]:
+            return (int(i.objects is not None), i.module)
+
+        imports = sorted(self.imports, key=_sort_key)
+        for i in imports:
+            i.sort()
+        self.imports = imports
+
+    def render(self, environment: Optional[Environment] = None, black: bool = False) -> str:
+        if self.render_sorted:
+            self.sort()
+        rendered = super().render(environment=environment, black=black)
+        return rendered
+
+
 def _render(
     item: Union[TemplateModel, Any, list[Union[Any, TemplateModel]], dict[str, Union[Any, TemplateModel]]],
     environment: Environment,
@@ -83,7 +369,7 @@ def _render(
     elif isinstance(item, dict):
         return {k: _render(v, environment) for k, v in item.items()}
     elif isinstance(item, BaseModel):
-        fields = item.model_fields
+        fields = {**item.model_fields, **getattr(item, "model_computed_fields", {})}
         return {k: _render(getattr(item, k, None), environment) for k in fields.keys()}
     else:
         return item

linkml/generators/docgen.py

@@ -173,6 +173,9 @@ class DocGenerator(Generator):
     hierarchical_class_view: bool = False
     render_imports: bool = False
 
+    preserve_names: bool = False
+    """If true, preserve LinkML element names in docs instead of camelcase/underscore."""
+
     def __post_init__(self):
         dialect = self.dialect
         if dialect is not None:
@@ -193,6 +196,27 @@ class DocGenerator(Generator):
         self.logger = logging.getLogger(__name__)
         self.schemaview = SchemaView(self.schema, merge_imports=self.mergeimports)
 
+        # Override schemaview's get_mappings to use preserved URIs when needed
+        if self.preserve_names:
+            original_get_mappings = self.schemaview.get_mappings
+
+            def get_mappings_with_preserved_uris(element_name, **kwargs):
+                mappings = original_get_mappings(element_name, **kwargs)
+                if mappings and element_name:
+                    try:
+                        element = self.schemaview.get_element(element_name)
+                        if element:
+                            preserved_uri = self.uri(element, expand=True)
+                            # Fix self and native mappings to use preserved URI
+                            for key in ("self", "native"):
+                                if key in mappings:
+                                    mappings[key] = [preserved_uri]
+                    except Exception:
+                        pass
+                return mappings
+
+            self.schemaview.get_mappings = get_mappings_with_preserved_uris
+
     def serialize(self, directory: str = None) -> None:
         """
         Serialize a schema as a collection of documents
@@ -363,19 +387,21 @@ class DocGenerator(Generator):
         :return: slot name or numeric portion of CURIE prefixed
             slot_uri
         """
-        if type(element).class_name == "slot_definition":
+        if element is None:
+            return ""
+        if self.preserve_names:
+            return element.name
+        elif type(element).class_name == "slot_definition":
             if self.use_slot_uris:
                 curie = self.schemaview.get_uri(element)
                 if curie:
                     return curie.split(":")[1]
-
             return underscore(element.name)
         elif type(element).class_name == "class_definition":
             if self.use_class_uris:
                 curie = self.schemaview.get_uri(element)
                 if curie:
                     return curie.split(":")[1]
-
             return camelcase(element.name)
         else:
             return camelcase(element.name)
@@ -391,6 +417,13 @@ class DocGenerator(Generator):
             # Subsets have no uri attribute
             return self.name(element)
 
+        # Simple URI composition for preserved names
+        if self.preserve_names and not (self.use_class_uris or self.use_slot_uris):
+            base = self.schemaview.schema.id
+            if base and ("://" in base or base.startswith("http")):
+                sep = "" if base.endswith(("/", "#", "_", ":")) else "/"
+                return f"{base}{sep}{self.name(element)}"
+
         if self.subfolder_type_separation:
             return self.schemaview.get_uri(element, expand=expand, use_element_type=True)
 
@@ -442,6 +475,8 @@ class DocGenerator(Generator):
             return "NONE"
         if not isinstance(e, Definition):
             e = self.schemaview.get_element(e)
+            if e is None:
+                return "NONE"
         if self._is_external(e):
             return self.uri_link(e)
         elif isinstance(e, ClassDefinition):
@@ -454,12 +489,12 @@ class DocGenerator(Generator):
                         subfolder=subfolder + CLASS_SUBFOLDER if self.subfolder_type_separation else None,
                     )
             return self._markdown_link(
-                camelcase(e.name),
+                self.name(e),
                 subfolder=subfolder + CLASS_SUBFOLDER if self.subfolder_type_separation else None,
             )
         elif isinstance(e, EnumDefinition):
             return self._markdown_link(
-                camelcase(e.name),
+                self.name(e),
                 subfolder=subfolder + ENUM_SUBFOLDER if self.subfolder_type_separation else None,
             )
         elif isinstance(e, SlotDefinition):
@@ -472,17 +507,17 @@ class DocGenerator(Generator):
                         subfolder=subfolder + SLOT_SUBFOLDER if self.subfolder_type_separation else None,
                     )
             return self._markdown_link(
-                underscore(e.name),
+                self.name(e),
                 subfolder=subfolder + SLOT_SUBFOLDER if self.subfolder_type_separation else None,
             )
         elif isinstance(e, TypeDefinition):
             return self._markdown_link(
-                camelcase(e.name),
+                self.name(e),
                 subfolder=subfolder + TYPE_SUBFOLDER if self.subfolder_type_separation else None,
             )
         elif isinstance(e, SubsetDefinition):
             return self._markdown_link(
-                camelcase(e.name),
+                self.name(e),
                 subfolder=subfolder + SUBSET_SUBFOLDER if self.subfolder_type_separation else None,
             )
         else:
@@ -500,6 +535,8 @@ class DocGenerator(Generator):
         return self._is_external(t) and not self.schemaview.schema.id.startswith("https://w3id.org/linkml/")
 
     def _is_external(self, element: Element) -> bool:
+        if element is None:
+            return False
         if element.from_schema == "https://w3id.org/linkml/types" and not self.genmeta:
             return True
         else:
@@ -714,7 +751,7 @@ class DocGenerator(Generator):
         :return:
         """
         if self.diagram_type.value == DiagramType.er_diagram.value:
-            erdgen = ERDiagramGenerator(self.schemaview.schema, format="mermaid")
+            erdgen = ERDiagramGenerator(self.schemaview.schema, format="mermaid", preserve_names=self.preserve_names)
             if class_names:
                 return erdgen.serialize_classes(class_names, follow_references=True, max_hops=2)
             else:
@@ -722,7 +759,7 @@ class DocGenerator(Generator):
         elif self.diagram_type.value == DiagramType.mermaid_class_diagram.value:
             self.logger.info("This is currently handled in the jinja templates")
         elif self.diagram_type.value == DiagramType.plantuml_class_diagram.value:
-            plantumlgen = PlantumlGenerator(self.schema)
+            plantumlgen = PlantumlGenerator(self.schema, preserve_names=self.preserve_names)
             plantuml_diagram = plantumlgen.serialize(classes=class_names)
             self.logger.debug(f"Created PlantUML diagram for class: {class_names}")
             return plantuml_diagram
@@ -1138,6 +1175,12 @@ YAML, and including it when necessary but not by default (e.g. in documentation
 Whether to truncate long (potentially spanning multiple lines) descriptions of classes, slots, etc., in the docs.
 Set to true for truncated descriptions, and false to display full descriptions.""",
 )
+@click.option(
+    "--preserve-names/--normalize-names",
+    default=False,
+    show_default=True,
+    help="Preserve original LinkML names in documentation output (e.g., for page titles, links, and file names).",
+)
 @click.version_option(__version__, "-V", "--version")
 @click.command(name="doc")
 def cli(
@@ -1152,6 +1195,7 @@ def cli(
     subfolder_type_separation,
     render_imports,
     truncate_descriptions,
+    preserve_names,
     **args,
 ):
     """Generate documentation folder from a LinkML YAML schema
@@ -1185,6 +1229,7 @@ def cli(
         subfolder_type_separation=subfolder_type_separation,
         render_imports=render_imports,
         truncate_descriptions=truncate_descriptions,
+        preserve_names=preserve_names,
         **args,
     )
     print(gen.serialize())

linkml/generators/erdiagramgen.py

@@ -142,6 +142,9 @@ class ERDiagramGenerator(Generator):
     no_types_dir: bool = False
     use_slot_uris: bool = False
 
+    preserve_names: bool = False
+    """If true, preserve LinkML element names (classes/slots) in diagram labels."""
+
     def __post_init__(self):
         self.schemaview = SchemaView(self.schema)
         super().__post_init__()
@@ -232,7 +235,7 @@ class ERDiagramGenerator(Generator):
         cls = sv.get_class(class_name)
         if self.exclude_abstract_classes and cls.abstract:
             return
-        entity = Entity(name=camelcase(cls.name))
+        entity = Entity(name=cls.name if self.preserve_names else camelcase(cls.name))
         diagram.entities.append(entity)
         for slot in sv.class_induced_slots(class_name):
             if slot.range in targets:
@@ -250,7 +253,7 @@ class ERDiagramGenerator(Generator):
         cls = sv.get_class(class_name)
         if self.exclude_abstract_classes and cls.abstract:
             return
-        entity = Entity(name=camelcase(cls.name))
+        entity = Entity(name=cls.name if self.preserve_names else camelcase(cls.name))
         diagram.entities.append(entity)
         for slot in sv.class_induced_slots(class_name):
             # TODO: schemaview should infer this
@@ -280,7 +283,9 @@ class ERDiagramGenerator(Generator):
         rel = Relationship(
             first_entity=entity.name,
             relationship_type=rel_type,
-            second_entity=camelcase(sv.get_class(slot.range).name),
+            second_entity=(
+                sv.get_class(slot.range).name if self.preserve_names else camelcase(sv.get_class(slot.range).name)
+            ),
             relationship_label=slot.name,
         )
         diagram.relationships.append(rel)
@@ -299,7 +304,7 @@ class ERDiagramGenerator(Generator):
         if slot.multivalued:
             # NOTE: mermaid does not support []s or *s in attribute types
             dt = f"{dt}List"
-        attr = Attribute(name=underscore(slot.name), datatype=dt)
+        attr = Attribute(name=(slot.name if self.preserve_names else underscore(slot.name)), datatype=dt)
         entity.attributes.append(attr)
 
 
@@ -324,7 +329,6 @@ 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")