Merge branch 'master' into master

Author: sheinbergon

.gitignore

@@ -13,3 +13,4 @@
 dist
 build
 venv*
+docker-compose.yaml

.pre-commit-config.yaml

@@ -16,19 +16,19 @@ repos:
       - id: trailing-whitespace
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.11.11
+    rev: v0.12.5
     hooks:
       - id: ruff
         args: [--fix, --show-fixes]
       - id: ruff-format
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.15.0
+    rev: v1.17.0
     hooks:
       - id: mypy
         additional_dependencies:
           - pytest
-          - "sqlalchemy[mypy] < 2.0"
+          - "SQLAlchemy >= 2.0.29"
 
   - repo: https://github.com/pre-commit/pygrep-hooks
     rev: v1.10.0

CHANGES.rst

@@ -7,6 +7,13 @@ Version history
   the array elements
 - Added support for specifying engine arguments via ``--engine-arg``
   (PR by @LajosCseppento)
+- Fixed incorrect package name used in ``importlib.metadata.version`` for
+  ``sqlalchemy-citext``, resolving ``PackageNotFoundError`` (PR by @oaimtiaz)
+- Prevent double pluralization (PR by @dkratzert)
+- Fixes DOMAIN extending JSON/JSONB data types (PR by @sheinbergon)
+- Temporarily restrict SQLAlchemy version to 2.0.41 (PR by @sheinbergon)
+- Fixes ``add_import`` behavior when adding imports from sqlalchemy and overall better
+  alignment of import behavior(s) across generators
 
 **3.0.0**
 

pyproject.toml

@@ -10,12 +10,12 @@ name = "sqlacodegen"
 description = "Automatic model code generator for SQLAlchemy"
 readme = "README.rst"
 authors = [{name = "Alex Grönholm", email = "[email protected]"}]
+maintainers = [{name = "Idan Sheinberg", email = "[email protected]"}]
 keywords = ["sqlalchemy"]
-license = {text = "MIT"}
+license = "MIT"
 classifiers = [
     "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
     "Environment :: Console",
     "Topic :: Database",
     "Topic :: Software Development :: Code Generators",
@@ -29,9 +29,10 @@ classifiers = [
 ]
 requires-python = ">=3.9"
 dependencies = [
-    "SQLAlchemy >= 2.0.23",
+    "SQLAlchemy >= 2.0.29,<2.0.42",
     "inflect >= 4.0.0",
     "importlib_metadata; python_version < '3.10'",
+    "stdlib-list; python_version < '3.10'"
 ]
 dynamic = ["version"]
 
@@ -80,6 +81,7 @@ extend-select = [
 
 [tool.mypy]
 strict = true
+disable_error_code = "no-untyped-call"
 
 [tool.pytest.ini_options]
 addopts = "-rsfE --tb=short"

src/sqlacodegen/cli.py

@@ -105,7 +105,7 @@ def main() -> None:
         return
 
     if citext:
-        print(f"Using sqlalchemy-citext {version('citext')}")
+        print(f"Using sqlalchemy-citext {version('sqlalchemy-citext')}")
 
     if geoalchemy2:
         print(f"Using geoalchemy2 {version('geoalchemy2')}")

src/sqlacodegen/generators.py

@@ -13,7 +13,7 @@
 from keyword import iskeyword
 from pprint import pformat
 from textwrap import indent
-from typing import Any, ClassVar
+from typing import Any, ClassVar, Literal, cast
 
 import inflect
 import sqlalchemy
@@ -38,7 +38,7 @@
     TypeDecorator,
     UniqueConstraint,
 )
-from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.dialects.postgresql import DOMAIN, JSON, JSONB
 from sqlalchemy.engine import Connection, Engine
 from sqlalchemy.exc import CompileError
 from sqlalchemy.sql.elements import TextClause
@@ -59,6 +59,7 @@
     get_common_fk_constraints,
     get_compiled_expression,
     get_constraint_sort_key,
+    get_stdlib_module_names,
     qualified_table_name,
     render_callable,
     uses_default_name,
@@ -119,9 +120,7 @@ def generate(self) -> str:
 @dataclass(eq=False)
 class TablesGenerator(CodeGenerator):
     valid_options: ClassVar[set[str]] = {"noindexes", "noconstraints", "nocomments"}
-    builtin_module_names: ClassVar[set[str]] = set(sys.builtin_module_names) | {
-        "dataclasses"
-    }
+    stdlib_module_names: ClassVar[set[str]] = get_stdlib_module_names()
 
     def __init__(
         self,
@@ -222,12 +221,14 @@ def collect_imports_for_column(self, column: Column[Any]) -> None:
 
         if isinstance(column.type, ARRAY):
             self.add_import(column.type.item_type.__class__)
-        elif isinstance(column.type, JSONB):
+        elif isinstance(column.type, (JSONB, JSON)):
             if (
                 not isinstance(column.type.astext_type, Text)
                 or column.type.astext_type.length is not None
             ):
                 self.add_import(column.type.astext_type)
+        elif isinstance(column.type, DOMAIN):
+            self.add_import(column.type.data_type.__class__)
 
         if column.default:
             self.add_import(column.default)
@@ -274,7 +275,7 @@ def add_import(self, obj: Any) -> None:
 
             if type_.__name__ in dialect_pkg.__all__:
                 pkgname = dialect_pkgname
-        elif type_.__name__ in dir(sqlalchemy):
+        elif type_ is getattr(sqlalchemy, type_.__name__, None):
             pkgname = "sqlalchemy"
         else:
             pkgname = type_.__module__
@@ -298,21 +299,26 @@ def group_imports(self) -> list[list[str]]:
         stdlib_imports: list[str] = []
         thirdparty_imports: list[str] = []
 
-        for package in sorted(self.imports):
-            imports = ", ".join(sorted(self.imports[package]))
+        def get_collection(package: str) -> list[str]:
             collection = thirdparty_imports
             if package == "__future__":
                 collection = future_imports
-            elif package in self.builtin_module_names:
+            elif package in self.stdlib_module_names:
                 collection = stdlib_imports
             elif package in sys.modules:
                 if "site-packages" not in (sys.modules[package].__file__ or ""):
                     collection = stdlib_imports
+            return collection
+
+        for package in sorted(self.imports):
+            imports = ", ".join(sorted(self.imports[package]))
 
+            collection = get_collection(package)
             collection.append(f"from {package} import {imports}")
 
         for module in sorted(self.module_imports):
-            thirdparty_imports.append(f"import {module}")
+            collection = get_collection(module)
+            collection.append(f"import {module}")
 
         return [
             group
@@ -375,7 +381,7 @@ def render_table(self, table: Table) -> str:
 
             args.append(self.render_constraint(constraint))
 
-        for index in sorted(table.indexes, key=lambda i: i.name):
+        for index in sorted(table.indexes, key=lambda i: cast(str, i.name)):
             # One-column indexes should be rendered as index=True on columns
             if len(index.columns) > 1 or not uses_default_name(index):
                 args.append(self.render_index(index))
@@ -467,7 +473,7 @@ def render_column(
 
         if isinstance(column.server_default, DefaultClause):
             kwargs["server_default"] = render_callable(
-                "text", repr(column.server_default.arg.text)
+                "text", repr(cast(TextClause, column.server_default.arg).text)
             )
         elif isinstance(column.server_default, Computed):
             expression = str(column.server_default.sqltext)
@@ -497,7 +503,7 @@ def render_column_callable(self, is_table: bool, *args: Any, **kwargs: Any) -> s
         else:
             return render_callable("mapped_column", *args, kwargs=kwargs)
 
-    def render_column_type(self, coltype: object) -> str:
+    def render_column_type(self, coltype: TypeEngine[Any]) -> str:
         args = []
         kwargs: dict[str, Any] = {}
         sig = inspect.signature(coltype.__class__.__init__)
@@ -513,13 +519,30 @@ def render_column_type(self, coltype: object) -> str:
                 continue
 
             value = getattr(coltype, param.name, missing)
+
+            if isinstance(value, (JSONB, JSON)):
+                # Remove astext_type if it's the default
+                if (
+                    isinstance(value.astext_type, Text)
+                    and value.astext_type.length is None
+                ):
+                    value.astext_type = None  # type: ignore[assignment]
+                else:
+                    self.add_import(Text)
+
             default = defaults.get(param.name, missing)
+            if isinstance(value, TextClause):
+                self.add_literal_import("sqlalchemy", "text")
+                rendered_value = render_callable("text", repr(value.text))
+            else:
+                rendered_value = repr(value)
+
             if value is missing or value == default:
                 use_kwargs = True
             elif use_kwargs:
-                kwargs[param.name] = repr(value)
+                kwargs[param.name] = rendered_value
             else:
-                args.append(repr(value))
+                args.append(rendered_value)
 
         vararg = next(
             (
@@ -539,7 +562,7 @@ def render_column_type(self, coltype: object) -> str:
                 if (value := getattr(coltype, colname)) is not None:
                     kwargs[colname] = repr(value)
 
-        if isinstance(coltype, JSONB):
+        if isinstance(coltype, (JSONB, JSON)):
             # Remove astext_type if it's the default
             if (
                 isinstance(coltype.astext_type, Text)
@@ -1073,13 +1096,13 @@ def generate_relationship_name(
                         preferred_name = column_names[0][:-3]
 
             if "use_inflect" in self.options:
+                inflected_name: str | Literal[False]
                 if relationship.type in (
                     RelationshipType.ONE_TO_MANY,
                     RelationshipType.MANY_TO_MANY,
                 ):
-                    inflected_name = self.inflect_engine.plural_noun(preferred_name)
-                    if inflected_name:
-                        preferred_name = inflected_name
+                    if not self.inflect_engine.singular_noun(preferred_name):
+                        preferred_name = self.inflect_engine.plural_noun(preferred_name)
                 else:
                     inflected_name = self.inflect_engine.singular_noun(preferred_name)
                     if inflected_name:
@@ -1168,7 +1191,7 @@ def render_table_args(self, table: Table) -> str:
             args.append(self.render_constraint(constraint))
 
         # Render indexes
-        for index in sorted(table.indexes, key=lambda i: i.name):
+        for index in sorted(table.indexes, key=lambda i: cast(str, i.name)):
             if len(index.columns) > 1 or not uses_default_name(index):
                 args.append(self.render_index(index))
 
@@ -1194,10 +1217,7 @@ def render_table_args(self, table: Table) -> str:
         else:
             return ""
 
-    def render_column_attribute(self, column_attr: ColumnAttribute) -> str:
-        column = column_attr.column
-        rendered_column = self.render_column(column, column_attr.name != column.name)
-
+    def render_column_python_type(self, column: Column[Any]) -> str:
         def get_type_qualifiers() -> tuple[str, TypeEngine[Any], str]:
             column_type = column.type
             pre: list[str] = []
@@ -1217,7 +1237,11 @@ def get_type_qualifiers() -> tuple[str, TypeEngine[Any], str]:
             return "".join(pre), column_type, "]" * post_size
 
         def render_python_type(column_type: TypeEngine[Any]) -> str:
-            python_type = column_type.python_type
+            if isinstance(column_type, DOMAIN):
+                python_type = column_type.data_type.python_type
+            else:
+                python_type = column_type.python_type
+
             python_type_name = python_type.__name__
             python_type_module = python_type.__module__
             if python_type_module == "builtins":
@@ -1232,7 +1256,14 @@ def render_python_type(column_type: TypeEngine[Any]) -> str:
 
         pre, col_type, post = get_type_qualifiers()
         column_python_type = f"{pre}{render_python_type(col_type)}{post}"
-        return f"{column_attr.name}: Mapped[{column_python_type}] = {rendered_column}"
+        return column_python_type
+
+    def render_column_attribute(self, column_attr: ColumnAttribute) -> str:
+        column = column_attr.column
+        rendered_column = self.render_column(column, column_attr.name != column.name)
+        rendered_column_python_type = self.render_column_python_type(column)
+
+        return f"{column_attr.name}: Mapped[{rendered_column_python_type}] = {rendered_column}"
 
     def render_relationship(self, relationship: RelationshipAttribute) -> str:
         def render_column_attrs(column_attrs: list[ColumnAttribute]) -> str:
@@ -1422,15 +1453,6 @@ def collect_imports_for_model(self, model: Model) -> None:
             if model.relationships:
                 self.add_literal_import("sqlmodel", "Relationship")
 
-    def collect_imports_for_column(self, column: Column[Any]) -> None:
-        super().collect_imports_for_column(column)
-        try:
-            python_type = column.type.python_type
-        except NotImplementedError:
-            self.add_literal_import("typing", "Any")
-        else:
-            self.add_import(python_type)
-
     def render_module_variables(self, models: list[Model]) -> str:
         declarations: list[str] = []
         if any(not isinstance(model, ModelClass) for model in models):
@@ -1463,25 +1485,17 @@ def render_class_variables(self, model: ModelClass) -> str:
 
     def render_column_attribute(self, column_attr: ColumnAttribute) -> str:
         column = column_attr.column
-        try:
-            python_type = column.type.python_type
-        except NotImplementedError:
-            python_type_name = "Any"
-        else:
-            python_type_name = python_type.__name__
+        rendered_column = self.render_column(column, True)
+        rendered_column_python_type = self.render_column_python_type(column)
 
         kwargs: dict[str, Any] = {}
-        if (
-            column.autoincrement and column.name in column.table.primary_key
-        ) or column.nullable:
-            self.add_literal_import("typing", "Optional")
+        if column.nullable:
             kwargs["default"] = None
-            python_type_name = f"Optional[{python_type_name}]"
-
-        rendered_column = self.render_column(column, True)
         kwargs["sa_column"] = f"{rendered_column}"
+
         rendered_field = render_callable("Field", kwargs=kwargs)
-        return f"{column_attr.name}: {python_type_name} = {rendered_field}"
+
+        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]