linkml 1.9.4rc2__py3-none-any.whl → 1.9.5rc2__py3-none-any.whl

linkml/generators/panderagen/slot_generator_mixin.py

@@ -1,31 +1,156 @@
 import logging
+from typing import Optional
 
-from linkml.generators.oocodegen import OOField
+from linkml_runtime.linkml_model.meta import ClassDefinitionName, SlotDefinition
+
+from linkml.utils.helpers import get_range_associated_slots
+
+from .dataframe_field import DataframeField
 
 logger = logging.getLogger(__file__)
 
 
 class SlotGeneratorMixin:
+    """
+    Prior to rendering the dataframe schema, this class provides
+    and adapter between the LinkML model and schema view
+    and the rendering engine.
+    """
+
     LINKML_ANY_CURIE = "linkml:Any"
+
+    # constants used to render the schema
+    # these will be moved to a dialect-specific place
     ANY_RANGE_STRING = "Object"
     CLASS_RANGE_STRING = "Struct"
+    SIMPLE_DICT_RANGE_STRING = "Struct"
     ENUM_RANGE_STRING = "Enum"
-    DEFAULT_RANGE_STRING = "str"
 
-    # to be implemented by the class
-    def make_multivalued(self, range: str):
-        raise NotImplementedError("please implement make multivalued in the class")
+    # association form flags used for rendering decisions
+    FORM_INLINED_DICT = "inlined_dict"
+    FORM_INLINED_LIST_DICT = "inlined_list_dict"
+    FORM_INLINED_COLLECTION_DICT = "inline_collection_dict"
+    FORM_INLINED_SIMPLE_DICT = "simple_dict"
+    FORM_MULTIVALUED_FOREIGN_KEY = "list_foreign_key"
+    FORM_FOREIGN_KEY = "foreign_key"
+    FORM_ERROR = "error"
+
+    # When nested inlining is done, the Pandera validator needs a specific range
+    INLINED_FORM_RANGE_PANDERA = {
+        FORM_INLINED_SIMPLE_DICT: SIMPLE_DICT_RANGE_STRING,
+        FORM_INLINED_LIST_DICT: CLASS_RANGE_STRING,
+        FORM_INLINED_COLLECTION_DICT: CLASS_RANGE_STRING,
+        FORM_INLINED_DICT: CLASS_RANGE_STRING,
+        FORM_ERROR: None,
+    }
+
+    def is_multivalued(self, slot):
+        return "multivalued" in slot and slot.multivalued is True
+
+    _INTERNAL_INLINED_FORM = {
+        # INLINED, INLINED_AS_LIST, MULTIVALUED,
+        (False, False, False): FORM_FOREIGN_KEY,
+        (False, False, True): FORM_MULTIVALUED_FOREIGN_KEY,
+        (False, True, False): FORM_INLINED_LIST_DICT,
+        (False, True, True): FORM_INLINED_LIST_DICT,
+        (True, False, False): FORM_INLINED_DICT,
+        (True, False, True): FORM_INLINED_COLLECTION_DICT,
+        (True, None, True): FORM_INLINED_DICT,
+        (True, True, False): FORM_INLINED_DICT,
+        (True, True, True): FORM_INLINED_LIST_DICT,
+    }
+
+    def get_identifier_or_key_slot(self, cn: ClassDefinitionName) -> Optional[SlotDefinition]:
+        sv = self.schemaview
+        id_slot = sv.get_identifier_slot(cn)
+        if id_slot:
+            return id_slot
+        else:
+            for s in sv.class_induced_slots(cn):
+                if s.key:
+                    return s
+            return None
+
+    def calculate_inlined_form(self, slot: SlotDefinition) -> str:
+        is_multivalued = self.is_multivalued(slot)
+        internal_inlined_form_key = ((slot.inlined is True), (slot.inlined_as_list is True), is_multivalued)
+        logger.info(f"Inlined form key: {internal_inlined_form_key}")
+        internal_inlined_form = self._INTERNAL_INLINED_FORM.get(
+            internal_inlined_form_key, SlotGeneratorMixin.FORM_ERROR
+        )
+
+        if internal_inlined_form == SlotGeneratorMixin.FORM_INLINED_COLLECTION_DICT:
+            if self.get_identifier_or_key_slot(slot.range) is None:
+                internal_inlined_form = SlotGeneratorMixin.FORM_INLINED_LIST_DICT
+
+        if self.calculate_simple_dict(slot) is not None:
+            return SlotGeneratorMixin.FORM_INLINED_SIMPLE_DICT
+
+        return internal_inlined_form
+
+    def calculate_simple_dict(self, slot: SlotDefinition):
+        """slot is the container for the simple dict slot"""
+
+        (_, range_simple_dict_value_slot, _) = get_range_associated_slots(self.schemaview, slot.range)
+
+        return range_simple_dict_value_slot
 
-    def handle_none_slot(self, slot, range: str) -> str:
+    def handle_none_slot(self, slot) -> str:
         range = self.schema.default_range  # need to figure this out, set at the beginning?
         if range is None:
-            range = SlotGeneratorMixin.DEFAULT_RANGE_STRING
+            range = "str"
 
         return range
 
     def handle_class_slot(self, slot, range: str) -> str:
-        logger.warning(f"PanderaGen does not support class range slots. Using Struct {slot.name}")
-        return SlotGeneratorMixin.CLASS_RANGE_STRING
+        range_info = self.schemaview.all_classes().get(range)
+
+        if range_info["class_uri"] == SlotGeneratorMixin.LINKML_ANY_CURIE:
+            range = SlotGeneratorMixin.ANY_RANGE_STRING
+        else:
+            inlined_form = self.calculate_inlined_form(slot)
+
+            if inlined_form == SlotGeneratorMixin.FORM_INLINED_COLLECTION_DICT:
+                logger.warning(
+                    f"Slot {slot.name} uses inlined dictionary form,"
+                    "which may be less efficient than inlined as list form with the current implementation."
+                )
+            elif inlined_form == SlotGeneratorMixin.FORM_INLINED_SIMPLE_DICT:
+                logger.warning(
+                    f"Slot {slot.name} uses inlined simple dictionary form. Support is incomplete "
+                    "and performance is less efficient than inlined as list form with the current implementation."
+                )
+
+            if inlined_form in (SlotGeneratorMixin.FORM_MULTIVALUED_FOREIGN_KEY, SlotGeneratorMixin.FORM_FOREIGN_KEY):
+                logger.warning(f"Foreign key not implemented for slot {slot.name}")
+                range = f"ID_TYPES['{self.get_class_name(range)}']"
+            else:
+                # TODO: make these setters
+                slot.annotations["reference_class"] = self.get_class_name(range)
+                slot.annotations["inline_form"] = inlined_form
+
+                range = SlotGeneratorMixin.INLINED_FORM_RANGE_PANDERA[inlined_form]
+
+                if inlined_form == SlotGeneratorMixin.FORM_INLINED_SIMPLE_DICT:
+                    self.set_simple_dict_inline_details_annotation(slot)
+                elif inlined_form in [SlotGeneratorMixin.FORM_INLINED_LIST_DICT]:
+                    range = self.make_multivalued(range)
+
+        return range
+
+    def set_simple_dict_inline_details_annotation(self, slot):
+        """Extra metadata is to help with the simple dict case"""
+        (range_id_slot, range_simple_dict_value_slot, _) = get_range_associated_slots(  # range_required_slots,
+            self.schemaview, slot.range
+        )
+
+        simple_dict_id = range_id_slot.name
+        other_slot = range_simple_dict_value_slot.name
+        slot.annotations["inline_details"] = {"id": simple_dict_id, "other": other_slot}
+
+    def handle_non_inlined_class_slot(self, slot, range: str) -> str:
+        """non-inlined class slots have been temporarily removed but this will be needed to support them"""
+        return f"ID_TYPES['{self.get_class_name(range)}']"
 
     def handle_type_slot(self, slot, range: str) -> str:
         del slot  # unused for now
@@ -43,9 +168,10 @@ class SlotGeneratorMixin:
         return range
 
     def handle_multivalued_slot(self, slot, range: str) -> str:
-        if slot.multivalued:
-            if slot.inlined_as_list and range != SlotGeneratorMixin.CLASS_RANGE_STRING:
-                range = self.make_multivalued(range)
+        if (slot.inlined_as_list is True and self.is_multivalued(slot)) or (
+            slot.inlined is True and slot.inlined_as_list is True and self.is_multivalued(slot)
+        ):
+            range = self.make_multivalued(range)
 
         return range
 
@@ -58,19 +184,20 @@ class SlotGeneratorMixin:
             safe_sn = self.get_slot_name(slot.alias)
 
         if range is None:
-            range = self.handle_none_slot(slot, range)
+            range = self.handle_none_slot(slot)
         elif range in self.schemaview.all_classes():
             range = self.handle_class_slot(slot, range)
         elif range in self.schemaview.all_types():
             range = self.handle_type_slot(slot, range)
+            if self.is_multivalued(slot):
+                range = self.make_multivalued(range)
         elif range in self.schemaview.all_enums():
             range = self.handle_enum_slot(slot, range)
+            range = self.handle_multivalued_slot(slot, range)
         else:
             raise Exception(f"Unknown range {range}")
 
-        range = self.handle_multivalued_slot(slot, range)
-
-        return OOField(
+        return DataframeField(
             name=safe_sn,
             source_slot=slot,
             range=range,

linkml/generators/panderagen/transforms/__init__.py

@@ -0,0 +1,19 @@
+"""Transform classes for LinkML Pandera validation.
+
+This module provides transform classes that convert LinkML inline formats
+into forms suitable for Polars DataFrame validation with Pandera models.
+"""
+
+from .collection_dict_model_transform import CollectionDictModelTransform
+from .list_dict_model_transform import ListDictModelTransform
+from .model_transform import ModelTransform
+from .nested_struct_model_transform import NestedStructModelTransform
+from .simple_dict_model_transform import SimpleDictModelTransform
+
+__all__ = [
+    "ModelTransform",
+    "SimpleDictModelTransform",
+    "CollectionDictModelTransform",
+    "ListDictModelTransform",
+    "NestedStructModelTransform",
+]

linkml/generators/panderagen/transforms/collection_dict_model_transform.py

@@ -0,0 +1,62 @@
+import polars as pl
+
+from .model_transform import ModelTransform
+
+
+class CollectionDictModelTransform(ModelTransform):
+    """This class assists in converting a LinkML 'collection dict' inline column
+    into a form that is better for representing in a PolaRS dataframe and
+    validating with a Pandera model.
+    """
+
+    def __init__(self, polars_schema, id_col):
+        self.polars_schema = polars_schema
+        """A polars schema representing a collection dict column"""
+
+        self.id_col = id_col
+        """The ID column in the sense of a LinkML inline collection dict"""
+
+    def transform(self, linkml_collection_dict):
+        """Converts a collection dict nested column to a list of dicts.
+        { 'A': {...}, 'B': {...}, ... } -> [{'id': 'A', ...}, {'id': 'B', ...}, ...]
+        """
+        return self._collection_dict_to_list_of_structs(linkml_collection_dict)
+
+    def _collection_dict_to_list_of_structs(self, linkml_collection_dict):
+        """Converts a collection dict nested column to a list of dicts.
+        { 'A': {...}, 'B': {...}, ... } -> [{'id': 'A', ...}, {'id': 'B', ...}, ...]
+
+        An inefficient conversion (relative to native PolaRS operations)
+        from a collection dict form to a dataframe struct column.
+
+        linkml_collection_dict : dict
+            A single row entry in a dataframe column (one cell), which itself is a dict.
+            The value entries are dicts that get the key added as an id field.
+        """
+        arr = []
+        for k, v in linkml_collection_dict.items():
+            if k not in v:
+                v[self.id_col] = k
+            arr.append(v)
+        return arr
+
+    @classmethod
+    def prepare_dataframe(cls, data, column_name, nested_cls):
+        """Returns just the collection dict column transformed to an inlined list form
+
+        note that this method uses collect and iter_rows so is very inefficient
+        """
+        id_column = nested_cls.get_id_column_name()
+        polars_schema = nested_cls.to_schema()
+
+        collection_dict_transformer = cls(polars_schema, id_column)
+
+        one_column_df = data.lazyframe.select(pl.col(column_name)).collect()
+
+        list_of_structs = [collection_dict_transformer.transform(e) for [e] in one_column_df.iter_rows()]
+
+        return pl.DataFrame(pl.Series(list_of_structs).alias(column_name))
+
+    def explode_unnest_dataframe(self, df, column_name):
+        """Filter, explode and unnest for collection dict."""
+        return df.lazy().filter(pl.col(column_name).list.len() > 0).explode(column_name).unnest(column_name).collect()

linkml/generators/panderagen/transforms/list_dict_model_transform.py

@@ -0,0 +1,66 @@
+import polars as pl
+
+from .model_transform import ModelTransform
+
+
+class ListDictModelTransform(ModelTransform):
+    """This class assists in converting a LinkML 'list dict' inline column
+    into a form that is better for representing in a PolaRS dataframe and
+    validating with a Pandera model.
+    """
+
+    def __init__(self, polars_schema):
+        self.polars_schema = polars_schema
+        """A polars schema representing a list dict column"""
+
+    def transform(self, linkml_list_dict):
+        """Transforms a list dict nested column.
+        This is a pass-through since list dicts are already in the correct format.
+        """
+        return linkml_list_dict
+
+    @classmethod
+    def unnest_list_struct(cls, column_name: str, df):
+        """Use this in a custom check. Pass the nested model as pandera_model."""
+
+        # fmt: off
+        unnested_column = (
+            df
+            .select(column_name)
+            .filter(pl.col(column_name).list.len() > 0) # see: https://github.com/pola-rs/polars/issues/14381
+            .explode(column_name)
+            .unnest(column_name)
+        )
+        # fmt: on
+
+        return unnested_column
+
+    @classmethod
+    def prepare_dataframe(cls, data, column_name, nested_cls):
+        """Returns just the list dict column transformed to an inlined list form
+
+        note that this method uses collect and iter_rows so is very inefficient
+        """
+        polars_schema = nested_cls.to_schema()
+
+        list_dict_transformer = cls(polars_schema)
+
+        one_column_df = data.lazyframe.select(pl.col(column_name)).collect()
+
+        list_of_structs = [list_dict_transformer.transform(e) for [e] in one_column_df.iter_rows()]
+
+        return pl.DataFrame(pl.Series(list_of_structs).alias(column_name))
+
+    def explode_unnest_dataframe(self, df, column_name, data=None):
+        """Filter, explode and unnest for list dict with struct fallback."""
+        try:
+            return (
+                df.lazy().filter(pl.col(column_name).list.len() > 0).explode(column_name).unnest(column_name).collect()
+            )
+        except (pl.exceptions.PanicException, Exception):
+            if data:
+                from .nested_struct_model_transform import NestedStructModelTransform
+
+                nested_transform = NestedStructModelTransform(self.polars_schema)
+                return nested_transform.explode_unnest_dataframe(data.lazyframe, column_name)
+            raise

linkml/generators/panderagen/transforms/model_transform.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+
+
+class ModelTransform(ABC):
+    @abstractmethod
+    def explode_unnest_dataframe(self, df, column_name):
+        """Abstract method for exploding and unnesting dataframes."""
+        pass

linkml/generators/panderagen/transforms/nested_struct_model_transform.py

@@ -0,0 +1,27 @@
+from .model_transform import ModelTransform
+
+
+class NestedStructModelTransform(ModelTransform):
+    """This class assists in converting a LinkML 'nested struct' inline column
+    into a form that is better for representing in a PolaRS dataframe and
+    validating with a Pandera model.
+    """
+
+    def __init__(self, polars_schema):
+        self.polars_schema = polars_schema
+        """A polars schema representing a nested struct column"""
+
+    def transform(self, linkml_nested_struct):
+        """Transforms a nested struct column.
+        This is a pass-through since nested structs are already in the correct format.
+        """
+        return linkml_nested_struct
+
+    def explode_unnest_dataframe(self, df, column_name):
+        """Unnest for nested struct."""
+        return df.lazy().select(column_name).unnest(column_name).collect()
+
+    @classmethod
+    def prepare_dataframe(cls, data, column_name, nested_cls):
+        """Returns the nested struct column as-is since no transformation needed"""
+        return data.lazyframe.collect()

linkml/generators/panderagen/transforms/simple_dict_model_transform.py

@@ -0,0 +1,86 @@
+import polars as pl
+
+from .model_transform import ModelTransform
+
+
+class SimpleDictModelTransform(ModelTransform):
+    """This class assists in converting a LinkML 'simple dict' inline column
+    into a form that is better for representing in a PolaRS dataframe and
+    validating with a Pandera model.
+    """
+
+    def __init__(self, polars_schema, id_col, other_col):
+        self.polars_schema = polars_schema
+        """A polars schema representing a simple dict column"""
+
+        self.id_col = id_col
+        """The ID column in the sense of a LinkML inline simple dict"""
+
+        self.other_col = other_col
+        """The 'other' column in the sense of a LinkML inline simple dict"""
+
+        self.id_col_type = None
+        self.other_col_type = None
+        self.polars_struct = self._build_polars_struct()
+        """A pl.Struct representing the schema of the other range."""
+
+    def _build_polars_struct_simple(self):
+        """Handles the two column (id, other) form of the simple dict"""
+        self.id_col_type = self.polars_schema.columns[self.id_col].dtype.type
+        self.other_col_type = self.polars_schema.columns[self.other_col].dtype.type
+
+        return pl.Struct({self.id_col: self.id_col_type, self.other_col: self.other_col_type})
+
+    def _build_polars_struct_complex(self):
+        """Handles the non-two-column simple dict cases."""
+        struct_items = {}
+        for k, v in self.polars_schema.columns.items():
+            if v.dtype.type == pl.Object:
+                v.dtype.type = pl.Struct
+            else:
+                struct_items[k] = v.dtype.type
+        return pl.Struct(struct_items)
+
+    def _build_polars_struct(self):
+        if len(self.polars_schema.columns.keys()) == 2:
+            return self._build_polars_struct_simple()
+        else:
+            return self._build_polars_struct_complex()
+
+    def transform(self, linkml_simple_dict):
+        """Converts a simple dict nested column to a list of dicts.
+        { 'A': 1, 'B': 2, ... } -> [{'id': 'other': 1}, {'id': 'B', 'other': 2}, ...]
+        """
+        return self._simple_dict_to_list_of_structs(linkml_simple_dict)
+
+    def _simple_dict_to_list_of_structs(self, linkml_simple_dict):
+        """Converts a simple dict nested column to a list of dicts.
+        { 'A': 1, 'B': 2, ... } -> [{'id': 'other': 1}, {'id': 'B', 'other': 2}, ...]
+
+        An inefficient conversion (relative to native PolaRS operations)
+        from a simple dict form to a dataframe struct column.
+
+        e : dict
+            e is a single row entry in a dataframe column (one cell), which itself is a dict.
+            The value entries of e may also be dicts.
+        """
+        arr = []
+        for id_value, range_value in linkml_simple_dict.items():
+            if isinstance(range_value, dict) and (set(range_value.keys()) <= set(self.polars_schema.columns.keys())):
+                range_dict = range_value
+                range_dict[self.id_col] = id_value
+                for column_key in self.polars_schema.columns.keys():
+                    if column_key not in range_dict:
+                        range_dict[column_key] = None
+            else:
+                range_dict = {self.id_col: id_value, self.other_col: range_value}
+            arr.append(range_dict)
+
+        return arr
+
+    def list_dtype(self):
+        return pl.List(self.polars_struct)
+
+    def explode_unnest_dataframe(self, df, column_name):
+        """Explode and unnest for simple dict."""
+        return df.lazy().explode(column_name).unnest(column_name).collect()

linkml/generators/plantumlgen.py

@@ -37,6 +37,7 @@ class PlantumlGenerator(Generator):
     generatorversion = "0.1.1"
     valid_formats = ["puml", "plantuml", "png", "pdf", "jpg", "json", "svg"]
     visit_all_class_slots = False
+    preserve_names: bool = False
 
     referenced: Optional[set[ClassDefinitionName]] = None  # List of classes that have to be emitted
     generated: Optional[set[ClassDefinitionName]] = None  # List of classes that have been emitted
@@ -99,10 +100,9 @@ class PlantumlGenerator(Generator):
             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,
-            )
+            schema_name = sorted(classes)[0] if classes else self.schema.name
+            filename = schema_name if self.preserve_names else camelcase(schema_name)
+            self.output_file_name = os.path.join(directory, filename + file_suffix)
             resp = requests.get(plantuml_url, stream=True, timeout=REQUESTS_TIMEOUT)
             if resp.ok:
                 with open(self.output_file_name, "wb") as f:
@@ -133,14 +133,14 @@ class PlantumlGenerator(Generator):
             for slot in self.filtered_cls_slots(cn, all_slots=True, filtr=lambda s: s.range not in self.schema.classes):
                 if True or cn in slot.domain_of:
                     mod = self.prop_modifier(cls, slot)
+                    slot_name = (
+                        self.aliased_slot_name(slot)
+                        if self.preserve_names
+                        else underscore(self.aliased_slot_name(slot))
+                    )
+                    range_name = slot.range if self.preserve_names else underscore(slot.range)
                     slot_defs.append(
-                        "    {field} "
-                        + underscore(self.aliased_slot_name(slot))
-                        + mod
-                        + " : "
-                        + underscore(slot.range)
-                        + " "
-                        + self.cardinality(slot)
+                        "    {field} " + slot_name + mod + " : " + range_name + " " + self.cardinality(slot)
                     )
             self.class_generated.add(cn)
         self.referenced.add(cn)
@@ -359,6 +359,12 @@ class PlantumlGenerator(Generator):
     show_default=True,
     help="Print out Kroki URL calls instead of sending the real requests",
 )
+@click.option(
+    "--preserve-names/--normalize-names",
+    default=False,
+    show_default=True,
+    help="Preserve original LinkML names in PlantUML diagram output (e.g., for class names, slot names, file names).",
+)
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, **args):
     """Generate a UML representation of a LinkML model"""

linkml/generators/pydanticgen/pydanticgen.py

@@ -1,4 +1,5 @@
 import inspect
+import keyword
 import logging
 import os
 import re
@@ -94,7 +95,10 @@ DEFAULT_IMPORTS = (
             ObjectImport(name="ConfigDict"),
             ObjectImport(name="Field"),
             ObjectImport(name="RootModel"),
+            ObjectImport(name="SerializationInfo"),
+            ObjectImport(name="SerializerFunctionWrapHandler"),
             ObjectImport(name="field_validator"),
+            ObjectImport(name="model_serializer"),
         ],
     )
 )
@@ -143,6 +147,41 @@ DefinitionType = TypeVar("DefinitionType", bound=Union[SchemaDefinition, ClassDe
 TemplateType = TypeVar("TemplateType", bound=Union[PydanticModule, PydanticClass, PydanticAttribute])
 
 
+def make_valid_python_identifier(name: str) -> str:
+    """
+    Convert a string to a valid Python identifier.
+
+    This is used when slot names contain characters that are not valid in Python
+    identifiers (e.g., '@id', '@type'). The original name can be preserved using
+    Pydantic field aliases.
+
+    Args:
+        name: The original name that may contain invalid characters
+
+    Returns:
+        A valid Python identifier that doesn't start with underscore (Pydantic restriction)
+    """
+    # Replace invalid characters with underscores
+    identifier = re.sub(r"[^a-zA-Z0-9_]", "_", name)
+
+    # Remove leading underscores (Pydantic doesn't allow field names starting with _)
+    identifier = identifier.lstrip("_")
+
+    # Ensure it doesn't start with a number
+    if identifier and identifier[0].isdigit():
+        identifier = f"field_{identifier}"
+
+    # Ensure it's not a keyword
+    if keyword.iskeyword(identifier):
+        identifier = f"{identifier}_"
+
+    # Ensure it's not empty
+    if not identifier:
+        identifier = "field"
+
+    return identifier
+
+
 @dataclass
 class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
     """
@@ -461,7 +500,19 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
             if getattr(slot, k, None) is not None
         }
         slot_alias = slot.alias if slot.alias else slot.name
-        slot_args["name"] = underscore(slot_alias)
+
+        # Create a valid Python identifier for the field name
+        python_field_name = make_valid_python_identifier(underscore(slot_alias))
+        slot_args["name"] = python_field_name
+
+        # If the original name is different from the Python identifier, set an alias
+        if slot_alias != python_field_name:
+            slot_args["alias"] = slot_alias
+        else:
+            # Remove any existing alias if the names are the same
+            if "alias" in slot_args:
+                del slot_args["alias"]
+
         slot_args["description"] = slot.description.replace('"', '\\"') if slot.description is not None else None
         predef = self.predefined_slot_values.get(camelcase(cls.name), {}).get(slot.name, None)
         if predef is not None:
@@ -1241,7 +1292,7 @@ def cli(
         metadata_mode=meta,
         **args,
     )
-    print(gen.serialize())
+    print(gen.serialize(), end="")
 
 
 if __name__ == "__main__":