sqlacodegen 4.0.2__tar.gz → 4.0.4__tar.gz

{sqlacodegen-4.0.2 → sqlacodegen-4.0.4}/.github/workflows/publish.yml

@@ -24,7 +24,7 @@ jobs:
     - name: Create packages
       run: python -m build
     - name: Archive packages
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: dist
         path: dist
@@ -38,7 +38,7 @@ jobs:
       id-token: write
     steps:
     - name: Retrieve packages
-      uses: actions/download-artifact@v7
+      uses: actions/download-artifact@v8
       with:
         name: dist
         path: dist

{sqlacodegen-4.0.2 → sqlacodegen-4.0.4}/.pre-commit-config.yaml

@@ -16,14 +16,14 @@ repos:
       - id: trailing-whitespace
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.14.10
+    rev: v0.15.9
     hooks:
       - id: ruff
         args: [--fix, --show-fixes]
       - id: ruff-format
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.19.1
+    rev: v1.20.0
     hooks:
       - id: mypy
         additional_dependencies:

{sqlacodegen-4.0.2 → sqlacodegen-4.0.4}/CHANGES.rst

@@ -1,6 +1,22 @@
 Version history
 ===============
 
+**4.0.4*
+
+- Added autoincrement to primary key columns to prevent missing field errors.
+  (`#473 <https://github.com/agronholm/sqlacodegen/issues/473>`_; PR by @jtmonroe)
+- Preserve dialect-specific ``ARRAY`` types (e.g. ``postgresql.ARRAY``) instead
+  of adapting them to the generic ``sqlalchemy.ARRAY``. The generic type does
+  not implement operators like ``.contains()``, so adapting silently broke
+  PostgreSQL array queries on generated models.
+  (`#441 <https://github.com/agronholm/sqlacodegen/issues/441>`_)
+
+**4.0.3**
+
+- Improved rendering of ``Identity`` server defaults by explicitly rendering
+  non-default parameters; ``Decimal`` values (as returned by some databases) are
+  now cast to ``int`` (PR by @NotCarlosSerrano)
+
 **4.0.2**
 
 - Fixed rendering of inherited keyword arguments for dialect-specific types that use

{sqlacodegen-4.0.2 → sqlacodegen-4.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlacodegen
-Version: 4.0.2
+Version: 4.0.4
 Summary: Automatic model code generator for SQLAlchemy
 Author-email: Alex Grönholm <alex.gronholm@nextday.fi>
 Maintainer-email: Idan Sheinberg <ishinberg0@gmail.com>

{sqlacodegen-4.0.2 → sqlacodegen-4.0.4}/src/sqlacodegen/generators.py

@@ -7,6 +7,7 @@ from abc import ABCMeta, abstractmethod
 from collections import defaultdict
 from collections.abc import Collection, Iterable, Mapping, Sequence
 from dataclasses import dataclass
+from decimal import Decimal
 from importlib import import_module
 from inspect import Parameter
 from itertools import count
@@ -470,6 +471,9 @@ class TablesGenerator(CodeGenerator):
             )
             or column.primary_key
         )
+        is_autoincrement = (
+            isinstance(column.autoincrement, bool) and column.autoincrement
+        )
         has_index = any(
             set(i.columns) == {column} and uses_default_name(i)
             for i in column.table.indexes
@@ -493,6 +497,8 @@ class TablesGenerator(CodeGenerator):
             kwargs["key"] = column.key
         if is_primary:
             kwargs["primary_key"] = True
+        if is_autoincrement and is_primary:
+            kwargs["autoincrement"] = True
         if not column.nullable and not column.primary_key:
             kwargs["nullable"] = False
         if column.nullable and is_part_of_composite_pk:
@@ -521,7 +527,29 @@ class TablesGenerator(CodeGenerator):
                 render_callable("Computed", repr(expression), kwargs=computed_kwargs)
             )
         elif isinstance(column.server_default, Identity):
-            args.append(repr(column.server_default))
+            identity = column.server_default
+            identity_kwargs: dict[str, Any] = {}
+
+            for name, param in inspect.signature(Identity).parameters.items():
+                if name == "self" or param.kind in (
+                    Parameter.VAR_POSITIONAL,
+                    Parameter.VAR_KEYWORD,
+                ):
+                    continue
+
+                value = getattr(identity, name, None)
+                if value is None:
+                    continue
+
+                if isinstance(value, Decimal):
+                    value = int(value)
+
+                if param.default is not Parameter.empty and value == param.default:
+                    continue
+
+                identity_kwargs[name] = value
+
+            args.append(render_callable("Identity", kwargs=identity_kwargs))
         elif column.server_default:
             kwargs["server_default"] = repr(column.server_default)
 
@@ -1008,6 +1036,12 @@ class TablesGenerator(CodeGenerator):
                         column.server_default = None
 
     def get_adapted_type(self, coltype: Any) -> Any:
+        # Keep dialect-specific ARRAY subclasses; the generic sqlalchemy.ARRAY
+        # is missing operators like .contains() (GH-441).
+        if isinstance(coltype, ARRAY) and type(coltype) is not ARRAY:
+            coltype.item_type = self.get_adapted_type(coltype.item_type)
+            return coltype
+
         compiled_type = coltype.compile(self.bind.engine.dialect)
         for supercls in coltype.__class__.__mro__:
             if not supercls.__name__.startswith("_") and hasattr(

{sqlacodegen-4.0.2 → sqlacodegen-4.0.4}/src/sqlacodegen.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlacodegen
-Version: 4.0.2
+Version: 4.0.4
 Summary: Automatic model code generator for SQLAlchemy
 Author-email: Alex Grönholm <alex.gronholm@nextday.fi>
 Maintainer-email: Idan Sheinberg <ishinberg0@gmail.com>

{sqlacodegen-4.0.2 → sqlacodegen-4.0.4}/tests/test_generator_declarative.py

@@ -1497,6 +1497,32 @@ class SimpleItems(Base):
     )
 
 
+def test_composite_autoincrement_pk(generator: CodeGenerator) -> None:
+    Table(
+        "simple_autoincrement_items",
+        generator.metadata,
+        Column("id1", INTEGER, primary_key=True, autoincrement=True),
+        Column("id2", INTEGER, primary_key=True),
+    )
+    validate_code(
+        generator.generate(),
+        """\
+from sqlalchemy import Integer
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+class Base(DeclarativeBase):
+    pass
+
+
+class SimpleAutoincrementItems(Base):
+    __tablename__ = 'simple_autoincrement_items'
+
+    id1: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    id2: Mapped[int] = mapped_column(Integer, primary_key=True)
+        """,
+    )
+
+
 def test_joined_inheritance(generator: CodeGenerator) -> None:
     Table(
         "simple_sub_items",

{sqlacodegen-4.0.2 → sqlacodegen-4.0.4}/tests/test_generator_tables.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from decimal import Decimal
 from textwrap import dedent
 
 import pytest
@@ -129,7 +130,8 @@ def test_arrays(generator: CodeGenerator) -> None:
     validate_code(
         generator.generate(),
         """\
-        from sqlalchemy import ARRAY, Column, Double, Integer, MetaData, Table
+        from sqlalchemy import Column, Double, Integer, MetaData, Table
+        from sqlalchemy.dialects.postgresql import ARRAY
 
         metadata = MetaData()
 
@@ -143,6 +145,36 @@ def test_arrays(generator: CodeGenerator) -> None:
     )
 
 
+@pytest.mark.parametrize("engine", ["postgresql"], indirect=["engine"])
+def test_array_preserves_dialect_for_runtime_operators(
+    generator: CodeGenerator,
+) -> None:
+    """Regression test for GH-441."""
+    Table(
+        "simple_items",
+        generator.metadata,
+        Column("id", postgresql.TEXT, primary_key=True),
+        Column("tags", postgresql.ARRAY(postgresql.TEXT)),
+    )
+
+    validate_code(
+        generator.generate(),
+        """\
+        from sqlalchemy import Column, MetaData, Table, Text
+        from sqlalchemy.dialects.postgresql import ARRAY
+
+        metadata = MetaData()
+
+
+        t_simple_items = Table(
+            'simple_items', metadata,
+            Column('id', Text, primary_key=True),
+            Column('tags', ARRAY(Text()))
+        )
+        """,
+    )
+
+
 @pytest.mark.parametrize("engine", ["postgresql"], indirect=["engine"])
 def test_jsonb(generator: CodeGenerator) -> None:
     Table(
@@ -1217,6 +1249,40 @@ def test_identity_column(generator: CodeGenerator) -> None:
     )
 
 
+def test_identity_column_decimal_values(generator: CodeGenerator) -> None:
+    # MSSQL reflects Identity column parameters (start, increment) as Decimal
+    # values instead of integers. This test ensures those are serialized correctly.
+    identity = Identity(start=1, increment=2)
+    # Simulate database reflection returning Decimal values (as MSSQL does)
+    identity.start = Decimal("1")  # type: ignore[assignment]
+    identity.increment = Decimal("2")  # type: ignore[assignment]
+    Table(
+        "simple_items",
+        generator.metadata,
+        Column(
+            "id",
+            INTEGER,
+            primary_key=True,
+            server_default=identity,
+        ),
+    )
+
+    validate_code(
+        generator.generate(),
+        """\
+        from sqlalchemy import Column, Identity, Integer, MetaData, Table
+
+        metadata = MetaData()
+
+
+        t_simple_items = Table(
+            'simple_items', metadata,
+            Column('id', Integer, Identity(start=1, increment=2), primary_key=True)
+        )
+        """,
+    )
+
+
 def test_multiline_column_comment(generator: CodeGenerator) -> None:
     Table(
         "simple_items",