sqlacodegen 4.0.0rc2__tar.gz → 4.0.1__tar.gz

{sqlacodegen-4.0.0rc2 → sqlacodegen-4.0.1}/CHANGES.rst

@@ -1,10 +1,48 @@
 Version history
 ===============
 
+**4.0.1**
+
+- Fix enum column definitions to explicitly include schema and name if reflected
+  via SQLAlchemy's Metadata (pr by @sheinbergon)
+
+**4.0.0**
+
+- **BACKWARD INCOMPATIBLE** API changes (for those who customize code generation by
+  subclassing the existing generators):
+
+  * Added new optional keyword argument, ``explicit_foreign_keys`` to
+    ``DeclarativeGenerator``, to force foreign keys to be rendered as
+    ``ClassName.attribute_name`` string references
+  * Removed the ``render_relationship_args()`` method from the SQLModel generator
+  * Added two new methods for customizing relationship rendering in
+    ``DeclarativeGenerator``:
+
+    * ``render_relationship_annotation()``: returns the appropriate type annotation
+      (without the ``Mapped`` wrapper) for the relationship
+    * ``render_relationship_arguments()``: returns a dictionary of keyword arguments to
+      ``sqlalchemy.orm.relationship()``
+
+**4.0.0rc3**
+
+- **BACKWARD INCOMPATIBLE** Relationship names changed when multiple FKs or junction tables
+  connect to the same target table. Regenerating models will break existing code.
+- Added support for generating Python enum classes for ``ARRAY(Enum(...))`` columns
+  (e.g., PostgreSQL ``ARRAY(ENUM)``). Supports named/unnamed enums, shared enums across
+  columns, and multi-dimensional arrays. Respects ``--options nonativeenums``.
+  (PR by @sheinbergon)
+- Improved relationship naming: one-to-many uses FK column names (e.g.,
+  ``simple_items_parent_container``), many-to-many uses junction table names (e.g.,
+  ``students_enrollments``). Use ``--options nofknames`` to revert to old behavior. (PR by @sheinbergon)
+- Fixed ``Index`` kwargs (e.g. ``mysql_length``) being ignored during code generation
+  (PR by @luliangce)
+- Fixed the SQLModel generator not adding the ``foreign_keys`` parameters when
+  generating multiple relationships between the same two tables
+
 **4.0.0rc2**
 
- - Add ``values_callable`` lambda to generated native enums column definitions.
-   This allows for proper enum value insertion when working with ORM models (PR by @sheinbergon)
+- Add ``values_callable`` lambda to generated native enums column definitions.
+  This allows for proper enum value insertion when working with ORM models (PR by @sheinbergon)
 
 **4.0.0rc1**
 

{sqlacodegen-4.0.0rc2 → sqlacodegen-4.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlacodegen
-Version: 4.0.0rc2
+Version: 4.0.1
 Summary: Automatic model code generator for SQLAlchemy
 Author-email: Alex Grönholm <alex.gronholm@nextday.fi>
 Maintainer-email: Idan Sheinberg <ishinberg0@gmail.com>
@@ -159,6 +159,11 @@ values must be delimited by commas, e.g. ``--options noconstraints,nobidi``):
   * ``nobidi``: generate relationships in a unidirectional fashion, so only the
     many-to-one or first side of many-to-many relationships gets a relationship
     attribute, as on v2.X
+  * ``nofknames``: disable improved relationship naming when multiple FKs or
+    junction tables connect to the same target. By default, uses FK column names
+    for one-to-many (e.g., ``simple_items_parent_container``) and junction table
+    names for many-to-many (e.g., ``students_enrollments``). Reverts to
+    underscore suffixes (``simple_items_``, ``student_``).
 
 * ``dataclasses``
 
@@ -226,6 +231,14 @@ due to that ``_id`` suffix.
 For self referential relationships, the reverse side of the relationship will be named
 with the ``_reverse`` suffix appended to it.
 
+When multiple foreign keys or junction tables connect to the same target table,
+relationships use qualifiers for disambiguation. One-to-many relationships use FK
+column names (e.g., ``simple_items_parent_container``, ``simple_items_top_container``).
+Many-to-many relationships use junction table names (e.g., ``students_enrollments``,
+``students_waitlist``), except for self-referential cases which use FK column names
+(e.g., ``parent``, ``child``). The ``nofknames`` option reverts to underscore suffixes
+(``simple_items_``, ``student_``).
+
 Customizing code generation logic
 =================================
 

{sqlacodegen-4.0.0rc2 → sqlacodegen-4.0.1}/README.rst

@@ -122,6 +122,11 @@ values must be delimited by commas, e.g. ``--options noconstraints,nobidi``):
   * ``nobidi``: generate relationships in a unidirectional fashion, so only the
     many-to-one or first side of many-to-many relationships gets a relationship
     attribute, as on v2.X
+  * ``nofknames``: disable improved relationship naming when multiple FKs or
+    junction tables connect to the same target. By default, uses FK column names
+    for one-to-many (e.g., ``simple_items_parent_container``) and junction table
+    names for many-to-many (e.g., ``students_enrollments``). Reverts to
+    underscore suffixes (``simple_items_``, ``student_``).
 
 * ``dataclasses``
 
@@ -189,6 +194,14 @@ due to that ``_id`` suffix.
 For self referential relationships, the reverse side of the relationship will be named
 with the ``_reverse`` suffix appended to it.
 
+When multiple foreign keys or junction tables connect to the same target table,
+relationships use qualifiers for disambiguation. One-to-many relationships use FK
+column names (e.g., ``simple_items_parent_container``, ``simple_items_top_container``).
+Many-to-many relationships use junction table names (e.g., ``students_enrollments``,
+``students_waitlist``), except for self-referential cases which use FK column names
+(e.g., ``parent``, ``child``). The ``nofknames`` option reverts to underscore suffixes
+(``simple_items_``, ``student_``).
+
 Customizing code generation logic
 =================================
 

{sqlacodegen-4.0.0rc2 → sqlacodegen-4.0.1}/src/sqlacodegen/generators.py

@@ -5,7 +5,7 @@ import re
 import sys
 from abc import ABCMeta, abstractmethod
 from collections import defaultdict
-from collections.abc import Collection, Iterable, Sequence
+from collections.abc import Collection, Iterable, Mapping, Sequence
 from dataclasses import dataclass
 from importlib import import_module
 from inspect import Parameter
@@ -424,7 +424,10 @@ class TablesGenerator(CodeGenerator):
 
     def render_index(self, index: Index) -> str:
         extra_args = [repr(col.name) for col in index.columns]
-        kwargs = {}
+        kwargs = {
+            key: repr(value) if isinstance(value, str) else value
+            for key, value in sorted(index.kwargs.items(), key=lambda item: item[0])
+        }
         if index.unique:
             kwargs["unique"] = True
 
@@ -547,10 +550,38 @@ class TablesGenerator(CodeGenerator):
             ):
                 # Import SQLAlchemy Enum (will be handled in collect_imports)
                 self.add_import(Enum)
-                return f"Enum({enum_class_name}, values_callable=lambda cls: [member.value for member in cls])"
+                extra_kwargs = ""
+                if column_type.name is not None:
+                    extra_kwargs += f", name={column_type.name!r}"
+
+                if column_type.schema is not None:
+                    extra_kwargs += f", schema={column_type.schema!r}"
+
+                return f"Enum({enum_class_name}, values_callable=lambda cls: [member.value for member in cls]{extra_kwargs})"
 
         args = []
         kwargs: dict[str, Any] = {}
+
+        # Check if this is an ARRAY column with an Enum item type mapped to a Python enum class
+        if isinstance(column_type, ARRAY) and isinstance(column_type.item_type, Enum):
+            if enum_class_name := self.enum_classes.get(
+                (column.table.name, column.name)
+            ):
+                self.add_import(ARRAY)
+                self.add_import(Enum)
+                extra_kwargs = ""
+                if column_type.item_type.name is not None:
+                    extra_kwargs += f", name={column_type.item_type.name!r}"
+
+                if column_type.item_type.schema is not None:
+                    extra_kwargs += f", schema={column_type.item_type.schema!r}"
+
+                rendered_enum = f"Enum({enum_class_name}, values_callable=lambda cls: [member.value for member in cls]{extra_kwargs})"
+                if column_type.dimensions is not None:
+                    kwargs["dimensions"] = repr(column_type.dimensions)
+
+                return render_callable("ARRAY", rendered_enum, kwargs=kwargs)
+
         sig = inspect.signature(column_type.__class__.__init__)
         defaults = {param.name: param.default for param in sig.parameters.values()}
         missing = object()
@@ -806,6 +837,31 @@ class TablesGenerator(CodeGenerator):
 
     def fix_column_types(self, table: Table) -> None:
         """Adjust the reflected column types."""
+
+        def fix_enum_column(col_name: str, enum_type: Enum) -> None:
+            if (table.name, col_name) in self.enum_classes:
+                return
+
+            if enum_type.name:
+                existing_class = None
+                for (_, _), cls in self.enum_classes.items():
+                    if cls == self._enum_name_to_class_name(enum_type.name):
+                        existing_class = cls
+                        break
+
+                if existing_class:
+                    enum_class_name = existing_class
+                else:
+                    enum_class_name = self._enum_name_to_class_name(enum_type.name)
+                    if enum_class_name not in self.enum_values:
+                        self.enum_values[enum_class_name] = list(enum_type.enums)
+            else:
+                enum_class_name = self._create_enum_class(
+                    table.name, col_name, list(enum_type.enums)
+                )
+
+            self.enum_classes[(table.name, col_name)] = enum_class_name
+
         # Detect check constraints for boolean and enum columns
         for constraint in table.constraints.copy():
             if isinstance(constraint, CheckConstraint):
@@ -849,37 +905,16 @@ class TablesGenerator(CodeGenerator):
                 and isinstance(column.type, Enum)
                 and column.type.enums
             ):
-                if column.type.name:
-                    # Named enum - create shared enum class if not already created
-                    if (table.name, column.name) not in self.enum_classes:
-                        # Check if we've already created an enum for this name
-                        existing_class = None
-                        for (t, c), cls in self.enum_classes.items():
-                            if cls == self._enum_name_to_class_name(column.type.name):
-                                existing_class = cls
-                                break
-
-                        if existing_class:
-                            enum_class_name = existing_class
-                        else:
-                            # Create new enum class from the enum's name
-                            enum_class_name = self._enum_name_to_class_name(
-                                column.type.name
-                            )
-                            # Register the enum values if not already registered
-                            if enum_class_name not in self.enum_values:
-                                self.enum_values[enum_class_name] = list(
-                                    column.type.enums
-                                )
+                fix_enum_column(column.name, column.type)
 
-                        self.enum_classes[(table.name, column.name)] = enum_class_name
-                else:
-                    # Unnamed enum - create enum class per column
-                    if (table.name, column.name) not in self.enum_classes:
-                        enum_class_name = self._create_enum_class(
-                            table.name, column.name, list(column.type.enums)
-                        )
-                        self.enum_classes[(table.name, column.name)] = enum_class_name
+            # Handle ARRAY columns with Enum item types (e.g., PostgreSQL ARRAY(ENUM))
+            elif (
+                "nonativeenums" not in self.options
+                and isinstance(column.type, ARRAY)
+                and isinstance(column.type.item_type, Enum)
+                and column.type.item_type.enums
+            ):
+                fix_enum_column(column.name, column.type.item_type)
 
             if not self.keep_dialect_types:
                 try:
@@ -969,6 +1004,7 @@ class DeclarativeGenerator(TablesGenerator):
         "nojoined",
         "nobidi",
         "noidsuffix",
+        "nofknames",
     }
 
     def __init__(
@@ -979,10 +1015,12 @@ class DeclarativeGenerator(TablesGenerator):
         *,
         indentation: str = "    ",
         base_class_name: str = "Base",
+        explicit_foreign_keys: bool = False,
     ):
         super().__init__(metadata, bind, options, indentation=indentation)
         self.base_class_name: str = base_class_name
         self.inflect_engine = inflect.engine()
+        self.explicit_foreign_keys = explicit_foreign_keys
 
     def generate_base(self) -> None:
         self.base = Base(
@@ -1290,30 +1328,123 @@ class DeclarativeGenerator(TablesGenerator):
         global_names: set[str],
         local_names: set[str],
     ) -> None:
-        # Self referential reverse relationships
-        preferred_name: str
-        if (
-            relationship.type
-            in (RelationshipType.ONE_TO_MANY, RelationshipType.ONE_TO_ONE)
-            and relationship.source is relationship.target
-            and relationship.backref
-            and relationship.backref.name
-        ):
-            preferred_name = relationship.backref.name + "_reverse"
-        else:
-            preferred_name = relationship.target.table.name
+        def strip_id_suffix(name: str) -> str:
+            # Strip _id only if at the end or followed by underscore (e.g., "course_id" -> "course", "course_id_1" -> "course_1")
+            # But don't strip from "parent_id1" (where id is followed by a digit without underscore)
+            return re.sub(r"_id(?=_|$)", "", name)
+
+        def get_m2m_qualified_name(default_name: str) -> str:
+            """Generate qualified name for many-to-many relationship when multiple junction tables exist."""
+            # Check if there are multiple M2M relationships to the same target
+            target_m2m_relationships = [
+                r
+                for r in relationship.source.relationships
+                if r.target is relationship.target
+                and r.type == RelationshipType.MANY_TO_MANY
+            ]
+
+            # Only use junction-based naming when there are multiple M2M to same target
+            if len(target_m2m_relationships) > 1:
+                if relationship.source is relationship.target:
+                    # Self-referential: use FK column name from junction table
+                    # (e.g., "parent_id" -> "parent", "child_id" -> "child")
+                    if relationship.constraint:
+                        column_names = [c.name for c in relationship.constraint.columns]
+                        if len(column_names) == 1:
+                            fk_qualifier = strip_id_suffix(column_names[0])
+                        else:
+                            fk_qualifier = "_".join(
+                                strip_id_suffix(col_name) for col_name in column_names
+                            )
+                        return fk_qualifier
+                elif relationship.association_table:
+                    # Normal: use junction table name as qualifier
+                    junction_name = relationship.association_table.table.name
+                    fk_qualifier = strip_id_suffix(junction_name)
+                    return f"{relationship.target.table.name}_{fk_qualifier}"
+            else:
+                # Single M2M: use simple name from junction table FK column
+                # (e.g., "right_id" -> "right" instead of "right_table")
+                if relationship.constraint and "noidsuffix" not in self.options:
+                    column_names = [c.name for c in relationship.constraint.columns]
+                    if len(column_names) == 1:
+                        stripped_name = strip_id_suffix(column_names[0])
+                        if stripped_name != column_names[0]:
+                            return stripped_name
+
+            return default_name
+
+        def get_fk_qualified_name(constraint: ForeignKeyConstraint) -> str:
+            """Generate qualified name for one-to-many/one-to-one relationship using FK column names."""
+            column_names = [c.name for c in constraint.columns]
+
+            if len(column_names) == 1:
+                # Single column FK: strip _id suffix if present
+                fk_qualifier = strip_id_suffix(column_names[0])
+            else:
+                # Multi-column FK: concatenate all column names (strip _id from each)
+                fk_qualifier = "_".join(
+                    strip_id_suffix(col_name) for col_name in column_names
+                )
 
-            # If there's a constraint with a single column that ends with "_id", use the
-            # preceding part as the relationship name
-            if relationship.constraint and "noidsuffix" not in self.options:
+            # For self-referential relationships, don't prepend the table name
+            if relationship.source is relationship.target:
+                return fk_qualifier
+            else:
+                return f"{relationship.target.table.name}_{fk_qualifier}"
+
+        def resolve_preferred_name() -> str:
+            resolved_name = relationship.target.table.name
+
+            # For reverse relationships with multiple FKs to the same table, use the FK
+            # column name to create a more descriptive relationship name
+            # For M2M relationships with multiple junction tables, use the junction table name
+            use_fk_based_naming = "nofknames" not in self.options and (
+                (
+                    relationship.constraint
+                    and relationship.type
+                    in (RelationshipType.ONE_TO_MANY, RelationshipType.ONE_TO_ONE)
+                    and relationship.foreign_keys
+                )
+                or (
+                    relationship.type == RelationshipType.MANY_TO_MANY
+                    and relationship.association_table
+                )
+            )
+
+            if use_fk_based_naming:
+                if relationship.type == RelationshipType.MANY_TO_MANY:
+                    resolved_name = get_m2m_qualified_name(resolved_name)
+                elif relationship.constraint:
+                    resolved_name = get_fk_qualified_name(relationship.constraint)
+
+            # If there's a constraint with a single column that contains "_id", use the
+            # stripped version as the relationship name
+            elif relationship.constraint and "noidsuffix" not in self.options:
                 is_source = relationship.source.table is relationship.constraint.table
                 if is_source or relationship.type not in (
                     RelationshipType.ONE_TO_ONE,
                     RelationshipType.ONE_TO_MANY,
                 ):
                     column_names = [c.name for c in relationship.constraint.columns]
-                    if len(column_names) == 1 and column_names[0].endswith("_id"):
-                        preferred_name = column_names[0][:-3]
+                    if len(column_names) == 1:
+                        stripped_name = strip_id_suffix(column_names[0])
+                        # Only use the stripped name if it actually changed (had _id in it)
+                        if stripped_name != column_names[0]:
+                            resolved_name = stripped_name
+                    else:
+                        # For composite FKs, check if there are multiple FKs to the same target
+                        target_relationships = [
+                            r
+                            for r in relationship.source.relationships
+                            if r.target is relationship.target
+                            and r.type == relationship.type
+                        ]
+                        if len(target_relationships) > 1:
+                            # Multiple FKs to same table - use concatenated column names
+                            resolved_name = "_".join(
+                                strip_id_suffix(col_name) for col_name in column_names
+                            )
 
             if "use_inflect" in self.options:
                 inflected_name: str | Literal[False]
@@ -1321,12 +1452,25 @@ class DeclarativeGenerator(TablesGenerator):
                     RelationshipType.ONE_TO_MANY,
                     RelationshipType.MANY_TO_MANY,
                 ):
-                    if not self.inflect_engine.singular_noun(preferred_name):
-                        preferred_name = self.inflect_engine.plural_noun(preferred_name)
+                    if not self.inflect_engine.singular_noun(resolved_name):
+                        resolved_name = self.inflect_engine.plural_noun(resolved_name)
                 else:
-                    inflected_name = self.inflect_engine.singular_noun(preferred_name)
+                    inflected_name = self.inflect_engine.singular_noun(resolved_name)
                     if inflected_name:
-                        preferred_name = inflected_name
+                        resolved_name = inflected_name
+
+            return resolved_name
+
+        if (
+            relationship.type
+            in (RelationshipType.ONE_TO_MANY, RelationshipType.ONE_TO_ONE)
+            and relationship.source is relationship.target
+            and relationship.backref
+            and relationship.backref.name
+        ):
+            preferred_name = relationship.backref.name + "_reverse"
+        else:
+            preferred_name = resolve_preferred_name()
 
         relationship.name = self.find_free_name(
             preferred_name, global_names, local_names
@@ -1498,6 +1642,33 @@ class DeclarativeGenerator(TablesGenerator):
         return f"{column_attr.name}: Mapped[{rendered_column_python_type}] = {rendered_column}"
 
     def render_relationship(self, relationship: RelationshipAttribute) -> str:
+        kwargs = self.render_relationship_arguments(relationship)
+        annotation = self.render_relationship_annotation(relationship)
+        rendered_relationship = render_callable(
+            "relationship", repr(relationship.target.name), kwargs=kwargs
+        )
+        return f"{relationship.name}: Mapped[{annotation}] = {rendered_relationship}"
+
+    def render_relationship_annotation(
+        self, relationship: RelationshipAttribute
+    ) -> str:
+        match relationship.type:
+            case RelationshipType.ONE_TO_MANY:
+                return f"list[{relationship.target.name!r}]"
+            case RelationshipType.ONE_TO_ONE | RelationshipType.MANY_TO_ONE:
+                if relationship.constraint and any(
+                    col.nullable for col in relationship.constraint.columns
+                ):
+                    self.add_literal_import("typing", "Optional")
+                    return f"Optional[{relationship.target.name!r}]"
+                else:
+                    return f"'{relationship.target.name}'"
+            case RelationshipType.MANY_TO_MANY:
+                return f"list[{relationship.target.name!r}]"
+
+    def render_relationship_arguments(
+        self, relationship: RelationshipAttribute
+    ) -> Mapping[str, Any]:
         def render_column_attrs(column_attrs: list[ColumnAttribute]) -> str:
             rendered = []
             for attr in column_attrs:
@@ -1513,7 +1684,7 @@ class DeclarativeGenerator(TablesGenerator):
             render_as_string = False
             # Assume that column_attrs are all in relationship.source or none
             for attr in column_attrs:
-                if attr.model is relationship.source:
+                if not self.explicit_foreign_keys and attr.model is relationship.source:
                     rendered.append(attr.name)
                 else:
                     rendered.append(f"{attr.model.name}.{attr.name}")
@@ -1569,33 +1740,7 @@ class DeclarativeGenerator(TablesGenerator):
         if relationship.backref:
             kwargs["back_populates"] = repr(relationship.backref.name)
 
-        rendered_relationship = render_callable(
-            "relationship", repr(relationship.target.name), kwargs=kwargs
-        )
-
-        relationship_type: str
-        if relationship.type == RelationshipType.ONE_TO_MANY:
-            relationship_type = f"list['{relationship.target.name}']"
-        elif relationship.type in (
-            RelationshipType.ONE_TO_ONE,
-            RelationshipType.MANY_TO_ONE,
-        ):
-            relationship_type = f"'{relationship.target.name}'"
-            if relationship.constraint and any(
-                col.nullable for col in relationship.constraint.columns
-            ):
-                self.add_literal_import("typing", "Optional")
-                relationship_type = f"Optional[{relationship_type}]"
-        elif relationship.type == RelationshipType.MANY_TO_MANY:
-            relationship_type = f"list['{relationship.target.name}']"
-        else:
-            self.add_literal_import("typing", "Any")
-            relationship_type = "Any"
-
-        return (
-            f"{relationship.name}: Mapped[{relationship_type}] "
-            f"= {rendered_relationship}"
-        )
+        return kwargs
 
 
 class DataclassGenerator(DeclarativeGenerator):
@@ -1650,6 +1795,7 @@ class SQLModelGenerator(DeclarativeGenerator):
             options,
             indentation=indentation,
             base_class_name=base_class_name,
+            explicit_foreign_keys=True,
         )
 
     @property
@@ -1730,34 +1876,26 @@ class SQLModelGenerator(DeclarativeGenerator):
         return f"{column_attr.name}: {rendered_column_python_type} = {rendered_field}"
 
     def render_relationship(self, relationship: RelationshipAttribute) -> str:
-        rendered = super().render_relationship(relationship).partition(" = ")[2]
-        args = self.render_relationship_args(rendered)
-        kwargs: dict[str, Any] = {}
-        annotation = repr(relationship.target.name)
+        kwargs = self.render_relationship_arguments(relationship)
+        annotation = self.render_relationship_annotation(relationship)
+
+        native_kwargs: dict[str, Any] = {}
+        non_native_kwargs: dict[str, Any] = {}
+        for key, value in kwargs.items():
+            # The following keyword arguments are natively supported in Relationship
+            if key in ("back_populates", "cascade_delete", "passive_deletes"):
+                native_kwargs[key] = value
+            else:
+                non_native_kwargs[key] = value
 
-        if relationship.type in (
-            RelationshipType.ONE_TO_MANY,
-            RelationshipType.MANY_TO_MANY,
-        ):
-            annotation = f"list[{annotation}]"
-        else:
-            self.add_literal_import("typing", "Optional")
-            annotation = f"Optional[{annotation}]"
+        if non_native_kwargs:
+            native_kwargs["sa_relationship_kwargs"] = (
+                "{"
+                + ", ".join(
+                    f"{key!r}: {value}" for key, value in non_native_kwargs.items()
+                )
+                + "}"
+            )
 
-        rendered_field = render_callable("Relationship", *args, kwargs=kwargs)
+        rendered_field = render_callable("Relationship", kwargs=native_kwargs)
         return f"{relationship.name}: {annotation} = {rendered_field}"
-
-    def render_relationship_args(self, arguments: str) -> list[str]:
-        argument_list = arguments.split(",")
-        # delete ')' and ' ' from args
-        argument_list[-1] = argument_list[-1][:-1]
-        argument_list = [argument[1:] for argument in argument_list]
-
-        rendered_args: list[str] = []
-        for arg in argument_list:
-            if "back_populates" in arg:
-                rendered_args.append(arg)
-            if "uselist=False" in arg:
-                rendered_args.append("sa_relationship_kwargs={'uselist': False}")
-
-        return rendered_args

{sqlacodegen-4.0.0rc2 → sqlacodegen-4.0.1}/src/sqlacodegen.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlacodegen
-Version: 4.0.0rc2
+Version: 4.0.1
 Summary: Automatic model code generator for SQLAlchemy
 Author-email: Alex Grönholm <alex.gronholm@nextday.fi>
 Maintainer-email: Idan Sheinberg <ishinberg0@gmail.com>
@@ -159,6 +159,11 @@ values must be delimited by commas, e.g. ``--options noconstraints,nobidi``):
   * ``nobidi``: generate relationships in a unidirectional fashion, so only the
     many-to-one or first side of many-to-many relationships gets a relationship
     attribute, as on v2.X
+  * ``nofknames``: disable improved relationship naming when multiple FKs or
+    junction tables connect to the same target. By default, uses FK column names
+    for one-to-many (e.g., ``simple_items_parent_container``) and junction table
+    names for many-to-many (e.g., ``students_enrollments``). Reverts to
+    underscore suffixes (``simple_items_``, ``student_``).
 
 * ``dataclasses``
 
@@ -226,6 +231,14 @@ due to that ``_id`` suffix.
 For self referential relationships, the reverse side of the relationship will be named
 with the ``_reverse`` suffix appended to it.
 
+When multiple foreign keys or junction tables connect to the same target table,
+relationships use qualifiers for disambiguation. One-to-many relationships use FK
+column names (e.g., ``simple_items_parent_container``, ``simple_items_top_container``).
+Many-to-many relationships use junction table names (e.g., ``students_enrollments``,
+``students_waitlist``), except for self-referential cases which use FK column names
+(e.g., ``parent``, ``child``). The ``nofknames`` option reverts to underscore suffixes
+(``simple_items_``, ``student_``).
+
 Customizing code generation logic
 =================================