sqlacodegen 3.2.0__tar.gz → 4.0.0rc2__tar.gz

sqlacodegen-4.0.0rc2/.github/FUNDING.yml

@@ -0,0 +1 @@
+tidelift: pypi/sqlacodegen

sqlacodegen-4.0.0rc2/.github/dependabot.yml

@@ -0,0 +1,13 @@
+# Keep GitHub Actions up to date with GitHub's Dependabot...
+# https://docs.github.com/en/code-security/dependabot/working-with-dependabot/keeping-your-actions-up-to-date-with-dependabot
+# https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#package-ecosystem
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: /
+    groups:
+      github-actions:
+        patterns:
+          - "*"  # Group all Actions updates into a single larger pull request
+    schedule:
+      interval: quarterly

{sqlacodegen-3.2.0 → sqlacodegen-4.0.0rc2}/.github/workflows/publish.yml

@@ -14,9 +14,9 @@ jobs:
     runs-on: ubuntu-latest
     environment: release
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Set up Python
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v6
       with:
         python-version: 3.x
     - name: Install dependencies
@@ -24,7 +24,7 @@ jobs:
     - name: Create packages
       run: python -m build
     - name: Archive packages
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v6
       with:
         name: dist
         path: dist
@@ -38,7 +38,10 @@ jobs:
       id-token: write
     steps:
     - name: Retrieve packages
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v7
+      with:
+        name: dist
+        path: dist
     - name: Upload packages
       uses: pypa/gh-action-pypi-publish@release/v1
 
@@ -49,7 +52,7 @@ jobs:
     permissions:
       contents: write
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - id: changelog
       uses: agronholm/release-notes@v1
       with:

{sqlacodegen-3.2.0 → sqlacodegen-4.0.0rc2}/.github/workflows/test.yml

@@ -13,16 +13,16 @@ jobs:
         python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v6
       with:
         python-version: ${{ matrix.python-version }}
         allow-prereleases: true
         cache: pip
         cache-dependency-path: pyproject.toml
     - name: Install dependencies
-      run: pip install -e .[test]
+      run: pip install --group test -e .[sqlmodel,citext,geoalchemy2,pgvector]
     - name: Test with pytest
       run: coverage run -m pytest
     - name: Upload Coverage

{sqlacodegen-3.2.0 → sqlacodegen-4.0.0rc2}/.pre-commit-config.yaml

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

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

@@ -1,6 +1,22 @@
 Version history
 ===============
 
+**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)
+
+**4.0.0rc1**
+
+- **BACKWARD INCOMPATIBLE** ``TablesGenerator.render_column_type()`` was changed to
+  receive the ``Column`` object instead of the column type object as its sole argument
+- Added Python enum generation for native database ENUM types (e.g., PostgreSQL / MySQL ENUM).
+  Retained synthetic Python enum generation from CHECK constraints with
+  IN clauses (e.g., ``column IN ('val1', 'val2', ...)``). Use ``--options nonativeenums`` to
+  disable enum generation for native database enums. Use ``--options nosyntheticenums`` to
+  disable enum generation for synthetic database enums (VARCHAR columns with check constraints).
+  (PR by @sheinbergon)
+
 **3.2.0**
 
 - Dropped support for Python 3.9

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlacodegen
-Version: 3.2.0
+Version: 4.0.0rc2
 Summary: Automatic model code generator for SQLAlchemy
 Author-email: Alex Grönholm <alex.gronholm@nextday.fi>
 Maintainer-email: Idan Sheinberg <ishinberg0@gmail.com>
@@ -25,12 +25,6 @@ Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: SQLAlchemy>=2.0.29
 Requires-Dist: inflect>=4.0.0
-Provides-Extra: test
-Requires-Dist: sqlacodegen[geoalchemy2,pgvector,sqlmodel]; extra == "test"
-Requires-Dist: pytest>=7.4; extra == "test"
-Requires-Dist: coverage>=7; extra == "test"
-Requires-Dist: psycopg[binary]; extra == "test"
-Requires-Dist: mysql-connector-python; extra == "test"
 Provides-Extra: sqlmodel
 Requires-Dist: sqlmodel>=0.0.22; extra == "sqlmodel"
 Provides-Extra: citext
@@ -47,6 +41,9 @@ Dynamic: license-file
 .. image:: https://coveralls.io/repos/github/agronholm/sqlacodegen/badge.svg?branch=master
   :target: https://coveralls.io/github/agronholm/sqlacodegen?branch=master
   :alt: Code Coverage
+.. image:: https://tidelift.com/badges/package/pypi/sqlacodegen
+  :target: https://tidelift.com/subscription/pkg/pypi-sqlacodegen
+  :alt: Tidelift
 
 This is a tool that reads the structure of an existing database and generates the
 appropriate SQLAlchemy model code, using the declarative style if possible.
@@ -146,6 +143,8 @@ values must be delimited by commas, e.g. ``--options noconstraints,nobidi``):
   * ``noconstraints``: ignore constraints (foreign key, unique etc.)
   * ``nocomments``: ignore table/column comments
   * ``noindexes``: ignore indexes
+  * ``nonativeenums``: don't generate Python enum classes for native database ENUM types (e.g., PostgreSQL ENUM); use plain string mapping instead
+  * ``nosyntheticenums``: don't generate Python enum classes from CHECK constraints with IN clauses (e.g., ``column IN ('value1', 'value2', ...)``); preserves CHECK constraints as-is
   * ``noidsuffix``: prevent the special naming logic for single column many-to-one
     and one-to-one relationships (see `Relationship naming logic`_ for details)
   * ``include_dialect_options``: render a table' dialect options, such as ``starrocks_partition`` for StarRocks' specific options.
@@ -251,3 +250,11 @@ sqlalchemy_ room on Gitter.
 
 .. _sqlacodegen discussion forum: https://github.com/agronholm/sqlacodegen/discussions/categories/q-a
 .. _sqlalchemy: https://app.gitter.im/#/room/#sqlalchemy_community:gitter.im
+
+Security contact information
+============================
+
+To report a security vulnerability, please use the `Tidelift security contact`_.
+Tidelift will coordinate the fix and disclosure.
+
+.. _Tidelift security contact: https://tidelift.com/security

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

@@ -4,6 +4,9 @@
 .. image:: https://coveralls.io/repos/github/agronholm/sqlacodegen/badge.svg?branch=master
   :target: https://coveralls.io/github/agronholm/sqlacodegen?branch=master
   :alt: Code Coverage
+.. image:: https://tidelift.com/badges/package/pypi/sqlacodegen
+  :target: https://tidelift.com/subscription/pkg/pypi-sqlacodegen
+  :alt: Tidelift
 
 This is a tool that reads the structure of an existing database and generates the
 appropriate SQLAlchemy model code, using the declarative style if possible.
@@ -103,6 +106,8 @@ values must be delimited by commas, e.g. ``--options noconstraints,nobidi``):
   * ``noconstraints``: ignore constraints (foreign key, unique etc.)
   * ``nocomments``: ignore table/column comments
   * ``noindexes``: ignore indexes
+  * ``nonativeenums``: don't generate Python enum classes for native database ENUM types (e.g., PostgreSQL ENUM); use plain string mapping instead
+  * ``nosyntheticenums``: don't generate Python enum classes from CHECK constraints with IN clauses (e.g., ``column IN ('value1', 'value2', ...)``); preserves CHECK constraints as-is
   * ``noidsuffix``: prevent the special naming logic for single column many-to-one
     and one-to-one relationships (see `Relationship naming logic`_ for details)
   * ``include_dialect_options``: render a table' dialect options, such as ``starrocks_partition`` for StarRocks' specific options.
@@ -208,3 +213,11 @@ sqlalchemy_ room on Gitter.
 
 .. _sqlacodegen discussion forum: https://github.com/agronholm/sqlacodegen/discussions/categories/q-a
 .. _sqlalchemy: https://app.gitter.im/#/room/#sqlalchemy_community:gitter.im
+
+Security contact information
+============================
+
+To report a security vulnerability, please use the `Tidelift security contact`_.
+Tidelift will coordinate the fix and disclosure.
+
+.. _Tidelift security contact: https://tidelift.com/security

{sqlacodegen-3.2.0 → sqlacodegen-4.0.0rc2}/pyproject.toml

@@ -39,13 +39,6 @@ dynamic = ["version"]
 "Source Code" = "https://github.com/agronholm/sqlacodegen"
 
 [project.optional-dependencies]
-test = [
-    "sqlacodegen[sqlmodel,pgvector,geoalchemy2]",
-    "pytest >= 7.4",
-    "coverage >= 7",
-    "psycopg[binary]",
-    "mysql-connector-python",
-]
 sqlmodel = ["sqlmodel >= 0.0.22"]
 citext = ["sqlalchemy-citext >= 1.7.0"]
 geoalchemy2 = ["geoalchemy2 >= 0.17.0"]
@@ -60,6 +53,14 @@ sqlmodels = "sqlacodegen.generators:SQLModelGenerator"
 [project.scripts]
 sqlacodegen = "sqlacodegen.cli:main"
 
+[dependency-groups]
+test = [
+    "pytest >= 7.4",
+    "coverage >= 7",
+    "psycopg[binary]",
+    "mysql-connector-python",
+]
+
 [tool.setuptools_scm]
 version_scheme = "post-release"
 local_scheme = "dirty-tag"
@@ -99,4 +100,5 @@ skip_missing_interpreters = true
 [tool.tox.env_run_base]
 package = "editable"
 commands = [["python", "-m", "pytest", { replace = "posargs", extend = true }]]
-extras = ["test"]
+dependency_groups = ["test"]
+extras = ["sqlmodel", "citext", "geoalchemy2", "pgvector"]

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

@@ -123,6 +123,8 @@ class TablesGenerator(CodeGenerator):
         "noindexes",
         "noconstraints",
         "nocomments",
+        "nonativeenums",
+        "nosyntheticenums",
         "include_dialect_options",
         "keep_dialect_types",
     }
@@ -148,6 +150,11 @@ class TablesGenerator(CodeGenerator):
         # Keep dialect-specific types instead of adapting to generic SQLAlchemy types
         self.keep_dialect_types: bool = "keep_dialect_types" in self.options
 
+        # Track Python enum classes: maps (table_name, column_name) -> enum_class_name
+        self.enum_classes: dict[tuple[str, str], str] = {}
+        # Track enum values: maps enum_class_name -> list of values
+        self.enum_values: dict[str, list[str]] = {}
+
     @property
     def views_supported(self) -> bool:
         return True
@@ -192,19 +199,22 @@ class TablesGenerator(CodeGenerator):
         models: list[Model] = self.generate_models()
 
         # Render module level variables
-        variables = self.render_module_variables(models)
-        if variables:
+        if variables := self.render_module_variables(models):
             sections.append(variables + "\n")
 
+        # Render enum classes
+        if enum_classes := self.render_enum_classes():
+            sections.append(enum_classes + "\n")
+
         # Render models
-        rendered_models = self.render_models(models)
-        if rendered_models:
+        if rendered_models := self.render_models(models):
             sections.append(rendered_models)
 
         # Render collected imports
         groups = self.group_imports()
-        imports = "\n\n".join("\n".join(line for line in group) for group in groups)
-        if imports:
+        if imports := "\n\n".join(
+            "\n".join(line for line in group) for group in groups
+        ):
             sections.insert(0, imports)
 
         return "\n\n".join(sections) + "\n"
@@ -467,7 +477,7 @@ class TablesGenerator(CodeGenerator):
         # Render the column type if there are no foreign keys on it or any of them
         # points back to itself
         if not dedicated_fks or any(fk.column is column for fk in dedicated_fks):
-            args.append(self.render_column_type(column.type))
+            args.append(self.render_column_type(column))
 
         for fk in dedicated_fks:
             args.append(self.render_constraint(fk))
@@ -528,10 +538,20 @@ class TablesGenerator(CodeGenerator):
         else:
             return render_callable("mapped_column", *args, kwargs=kwargs)
 
-    def render_column_type(self, coltype: TypeEngine[Any]) -> str:
+    def render_column_type(self, column: Column[Any]) -> str:
+        column_type = column.type
+        # Check if this is an enum column with a Python enum class
+        if isinstance(column_type, Enum) and column is not None:
+            if enum_class_name := self.enum_classes.get(
+                (column.table.name, column.name)
+            ):
+                # 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])"
+
         args = []
         kwargs: dict[str, Any] = {}
-        sig = inspect.signature(coltype.__class__.__init__)
+        sig = inspect.signature(column_type.__class__.__init__)
         defaults = {param.name: param.default for param in sig.parameters.values()}
         missing = object()
         use_kwargs = False
@@ -543,7 +563,7 @@ class TablesGenerator(CodeGenerator):
                 use_kwargs = True
                 continue
 
-            value = getattr(coltype, param.name, missing)
+            value = getattr(column_type, param.name, missing)
 
             if isinstance(value, (JSONB, JSON)):
                 # Remove astext_type if it's the default
@@ -577,28 +597,28 @@ class TablesGenerator(CodeGenerator):
             ),
             None,
         )
-        if vararg and hasattr(coltype, vararg):
-            varargs_repr = [repr(arg) for arg in getattr(coltype, vararg)]
+        if vararg and hasattr(column_type, vararg):
+            varargs_repr = [repr(arg) for arg in getattr(column_type, vararg)]
             args.extend(varargs_repr)
 
         # These arguments cannot be autodetected from the Enum initializer
-        if isinstance(coltype, Enum):
+        if isinstance(column_type, Enum):
             for colname in "name", "schema":
-                if (value := getattr(coltype, colname)) is not None:
+                if (value := getattr(column_type, colname)) is not None:
                     kwargs[colname] = repr(value)
 
-        if isinstance(coltype, (JSONB, JSON)):
+        if isinstance(column_type, (JSONB, JSON)):
             # Remove astext_type if it's the default
             if (
-                isinstance(coltype.astext_type, Text)
-                and coltype.astext_type.length is None
+                isinstance(column_type.astext_type, Text)
+                and column_type.astext_type.length is None
             ):
                 del kwargs["astext_type"]
 
         if args or kwargs:
-            return render_callable(coltype.__class__.__name__, *args, kwargs=kwargs)
+            return render_callable(column_type.__class__.__name__, *args, kwargs=kwargs)
         else:
-            return coltype.__class__.__name__
+            return column_type.__class__.__name__
 
     def render_constraint(self, constraint: Constraint | ForeignKey) -> str:
         def add_fk_options(*opts: Any) -> None:
@@ -709,6 +729,81 @@ class TablesGenerator(CodeGenerator):
 
         return name
 
+    def _enum_name_to_class_name(self, enum_name: str) -> str:
+        """Convert a database enum name to a Python class name (PascalCase)."""
+        return "".join(part.capitalize() for part in enum_name.split("_") if part)
+
+    def _create_enum_class(
+        self, table_name: str, column_name: str, values: list[str]
+    ) -> str:
+        """
+        Create a Python enum class name and register it.
+
+        Returns the enum class name to use in generated code.
+        """
+        # Generate enum class name from table and column names
+        # Convert to PascalCase: user_status -> UserStatus
+        base_name = "".join(
+            part.capitalize()
+            for part in table_name.split("_") + column_name.split("_")
+            if part
+        )
+
+        # Ensure uniqueness
+        enum_class_name = base_name
+        for counter in count(1):
+            if enum_class_name not in self.enum_values:
+                break
+
+            # Check if it's the same enum (same values)
+            if self.enum_values[enum_class_name] == values:
+                # Reuse existing enum class
+                return enum_class_name
+
+            enum_class_name = f"{base_name}{counter}"
+
+        # Register the new enum class
+        self.enum_values[enum_class_name] = values
+        return enum_class_name
+
+    def render_enum_classes(self) -> str:
+        """Render Python enum class definitions."""
+        if not self.enum_values:
+            return ""
+
+        self.add_module_import("enum")
+
+        enum_defs = []
+        for enum_class_name, values in sorted(self.enum_values.items()):
+            # Create enum members with valid Python identifiers
+            members = []
+            for value in values:
+                # Unescape SQL escape sequences (e.g., \' -> ')
+                # The value from the CHECK constraint has SQL escaping
+                unescaped_value = value.replace("\\'", "'").replace("\\\\", "\\")
+
+                # Create a valid identifier from the enum value
+                member_name = _re_invalid_identifier.sub("_", unescaped_value).upper()
+                if not member_name:
+                    member_name = "EMPTY"
+                elif member_name[0].isdigit():
+                    member_name = "_" + member_name
+                elif iskeyword(member_name):
+                    member_name += "_"
+                #
+                # # Re-escape for Python string literal
+                # python_escaped = unescaped_value.replace("\\", "\\\\").replace(
+                #     "'", "\\'"
+                # )
+                members.append(f"    {member_name} = {unescaped_value!r}")
+
+            enum_def = f"class {enum_class_name}(str, enum.Enum):\n" + "\n".join(
+                members
+            )
+            enum_defs.append(enum_def)
+
+        return "\n\n\n".join(enum_defs)
+
     def fix_column_types(self, table: Table) -> None:
         """Adjust the reflected column types."""
         # Detect check constraints for boolean and enum columns
@@ -718,34 +813,74 @@ class TablesGenerator(CodeGenerator):
 
                 # Turn any integer-like column with a CheckConstraint like
                 # "column IN (0, 1)" into a Boolean
-                match = _re_boolean_check_constraint.match(sqltext)
-                if match:
-                    colname_match = _re_column_name.match(match.group(1))
-                    if colname_match:
+                if match := _re_boolean_check_constraint.match(sqltext):
+                    if colname_match := _re_column_name.match(match.group(1)):
                         colname = colname_match.group(3)
                         table.constraints.remove(constraint)
                         table.c[colname].type = Boolean()
                         continue
 
-                # Turn any string-type column with a CheckConstraint like
-                # "column IN (...)" into an Enum
-                match = _re_enum_check_constraint.match(sqltext)
-                if match:
-                    colname_match = _re_column_name.match(match.group(1))
-                    if colname_match:
-                        colname = colname_match.group(3)
-                        items = match.group(2)
-                        if isinstance(table.c[colname].type, String):
-                            table.constraints.remove(constraint)
-                            if not isinstance(table.c[colname].type, Enum):
-                                options = _re_enum_item.findall(items)
-                                table.c[colname].type = Enum(
-                                    *options, native_enum=False
+                # Turn VARCHAR columns with CHECK constraints like "column IN ('a', 'b')"
+                # into synthetic Enum types with Python enum classes
+                if (
+                    "nosyntheticenums" not in self.options
+                    and (match := _re_enum_check_constraint.match(sqltext))
+                    and (colname_match := _re_column_name.match(match.group(1)))
+                ):
+                    colname = colname_match.group(3)
+                    items = match.group(2)
+                    if isinstance(table.c[colname].type, String) and not isinstance(
+                        table.c[colname].type, Enum
+                    ):
+                        options = _re_enum_item.findall(items)
+                        # Create Python enum class
+                        enum_class_name = self._create_enum_class(
+                            table.name, colname, options
+                        )
+                        self.enum_classes[(table.name, colname)] = enum_class_name
+                        # Convert to Enum type but KEEP the constraint
+                        table.c[colname].type = Enum(*options, native_enum=False)
+                        continue
+
+        for column in table.c:
+            # Handle native database Enum types (e.g., PostgreSQL ENUM)
+            if (
+                "nonativeenums" not in self.options
+                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
                                 )
 
-                            continue
+                        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
 
-        for column in table.c:
             if not self.keep_dialect_types:
                 try:
                     column.type = self.get_adapted_type(column.type)
@@ -1326,6 +1461,14 @@ class DeclarativeGenerator(TablesGenerator):
             return "".join(pre), column_type, "]" * post_size
 
         def render_python_type(column_type: TypeEngine[Any]) -> str:
+            # Check if this is an enum column with a Python enum class
+            if isinstance(column_type, Enum):
+                table_name = column.table.name
+                column_name = column.name
+                if (table_name, column_name) in self.enum_classes:
+                    enum_class_name = self.enum_classes[(table_name, column_name)]
+                    return enum_class_name
+
             if isinstance(column_type, DOMAIN):
                 column_type = column_type.data_type
 

{sqlacodegen-3.2.0 → sqlacodegen-4.0.0rc2}/src/sqlacodegen/utils.py

@@ -210,10 +210,4 @@ def decode_postgresql_sequence(clause: TextClause) -> tuple[str | None, str | No
 
 
 def get_stdlib_module_names() -> set[str]:
-    major, minor = sys.version_info.major, sys.version_info.minor
-    if (major, minor) > (3, 9):
-        return set(sys.builtin_module_names) | set(sys.stdlib_module_names)
-    else:
-        from stdlib_list import stdlib_list
-
-        return set(sys.builtin_module_names) | set(stdlib_list(f"{major}.{minor}"))
+    return set(sys.builtin_module_names) | set(sys.stdlib_module_names)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlacodegen
-Version: 3.2.0
+Version: 4.0.0rc2
 Summary: Automatic model code generator for SQLAlchemy
 Author-email: Alex Grönholm <alex.gronholm@nextday.fi>
 Maintainer-email: Idan Sheinberg <ishinberg0@gmail.com>
@@ -25,12 +25,6 @@ Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: SQLAlchemy>=2.0.29
 Requires-Dist: inflect>=4.0.0
-Provides-Extra: test
-Requires-Dist: sqlacodegen[geoalchemy2,pgvector,sqlmodel]; extra == "test"
-Requires-Dist: pytest>=7.4; extra == "test"
-Requires-Dist: coverage>=7; extra == "test"
-Requires-Dist: psycopg[binary]; extra == "test"
-Requires-Dist: mysql-connector-python; extra == "test"
 Provides-Extra: sqlmodel
 Requires-Dist: sqlmodel>=0.0.22; extra == "sqlmodel"
 Provides-Extra: citext
@@ -47,6 +41,9 @@ Dynamic: license-file
 .. image:: https://coveralls.io/repos/github/agronholm/sqlacodegen/badge.svg?branch=master
   :target: https://coveralls.io/github/agronholm/sqlacodegen?branch=master
   :alt: Code Coverage
+.. image:: https://tidelift.com/badges/package/pypi/sqlacodegen
+  :target: https://tidelift.com/subscription/pkg/pypi-sqlacodegen
+  :alt: Tidelift
 
 This is a tool that reads the structure of an existing database and generates the
 appropriate SQLAlchemy model code, using the declarative style if possible.
@@ -146,6 +143,8 @@ values must be delimited by commas, e.g. ``--options noconstraints,nobidi``):
   * ``noconstraints``: ignore constraints (foreign key, unique etc.)
   * ``nocomments``: ignore table/column comments
   * ``noindexes``: ignore indexes
+  * ``nonativeenums``: don't generate Python enum classes for native database ENUM types (e.g., PostgreSQL ENUM); use plain string mapping instead
+  * ``nosyntheticenums``: don't generate Python enum classes from CHECK constraints with IN clauses (e.g., ``column IN ('value1', 'value2', ...)``); preserves CHECK constraints as-is
   * ``noidsuffix``: prevent the special naming logic for single column many-to-one
     and one-to-one relationships (see `Relationship naming logic`_ for details)
   * ``include_dialect_options``: render a table' dialect options, such as ``starrocks_partition`` for StarRocks' specific options.
@@ -251,3 +250,11 @@ sqlalchemy_ room on Gitter.
 
 .. _sqlacodegen discussion forum: https://github.com/agronholm/sqlacodegen/discussions/categories/q-a
 .. _sqlalchemy: https://app.gitter.im/#/room/#sqlalchemy_community:gitter.im
+
+Security contact information
+============================
+
+To report a security vulnerability, please use the `Tidelift security contact`_.
+Tidelift will coordinate the fix and disclosure.
+
+.. _Tidelift security contact: https://tidelift.com/security

{sqlacodegen-3.2.0 → sqlacodegen-4.0.0rc2}/src/sqlacodegen.egg-info/SOURCES.txt

@@ -5,6 +5,8 @@ CONTRIBUTING.rst
 LICENSE
 README.rst
 pyproject.toml
+.github/FUNDING.yml
+.github/dependabot.yml
 .github/pull_request_template.md
 .github/ISSUE_TEMPLATE/bug_report.yaml
 .github/ISSUE_TEMPLATE/config.yml

{sqlacodegen-3.2.0 → sqlacodegen-4.0.0rc2}/src/sqlacodegen.egg-info/requires.txt

@@ -12,10 +12,3 @@ pgvector>=0.2.4
 
 [sqlmodel]
 sqlmodel>=0.0.22
-
-[test]
-sqlacodegen[geoalchemy2,pgvector,sqlmodel]
-pytest>=7.4
-coverage>=7
-psycopg[binary]
-mysql-connector-python