utils-flask-sqlalchemy 0.4.5__tar.gz → 0.5.0__tar.gz

{utils_flask_sqlalchemy-0.4.5/src/utils_flask_sqlalchemy.egg-info → utils_flask_sqlalchemy-0.5.0}/PKG-INFO

@@ -1,16 +1,17 @@
 Metadata-Version: 2.4
 Name: utils-flask-sqlalchemy
-Version: 0.4.5
+Version: 0.5.0
 Summary: Python lib of tools for Flask and SQLAlchemy
-Home-page: https://github.com/PnX-SI/Utils-Flask-SQLAlchemy
-Maintainer: Parcs nationaux des Écrins et des Cévennes
-Maintainer-email: geonature@ecrins-parcnational.fr
+Maintainer-email: Parcs nationaux des Écrins et des Cévennes <geonature@ecrins-parcnational.fr>
+License: GNU Affero General Public License v3
+Project-URL: Homepage, https://github.com/PnX-SI/Utils-Flask-SQLAlchemy
 Classifier: Development Status :: 1 - Planning
 Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: GNU Affero General Public License v3
 Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: flask
@@ -18,7 +19,7 @@ Requires-Dist: flask-sqlalchemy
 Requires-Dist: flask-migrate
 Requires-Dist: marshmallow
 Requires-Dist: python-dateutil
-Requires-Dist: sqlalchemy<2
+Requires-Dist: sqlalchemy<3
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: geoalchemy2; extra == "tests"
@@ -26,16 +27,9 @@ Requires-Dist: shapely; extra == "tests"
 Requires-Dist: jsonschema; extra == "tests"
 Requires-Dist: flask-marshmallow; extra == "tests"
 Requires-Dist: marshmallow-sqlalchemy; extra == "tests"
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
+Requires-Dist: psycopg2-binary; extra == "tests"
+Requires-Dist: pytest-cov; extra == "tests"
 Dynamic: license-file
-Dynamic: maintainer
-Dynamic: maintainer-email
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: summary
 
 ## Librairie "outil" pour SQLAlchemy et Flask
 

utils_flask_sqlalchemy-0.5.0/VERSION

@@ -0,0 +1 @@
+0.5.0

utils_flask_sqlalchemy-0.5.0/pyproject.toml

@@ -0,0 +1,76 @@
+[build-system]
+requires = ["setuptools>=77.0.3", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "utils-flask-sqlalchemy"
+dynamic = ["version"]
+description = "Python lib of tools for Flask and SQLAlchemy"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "GNU Affero General Public License v3" }
+maintainers = [
+    { name = "Parcs nationaux des Écrins et des Cévennes", email = "geonature@ecrins-parcnational.fr" }
+]
+classifiers = [
+    "Development Status :: 1 - Planning",
+    "Intended Audience :: Developers",
+    "Natural Language :: English",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: GNU Affero General Public License v3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "flask",
+    "flask-sqlalchemy",
+    "flask-migrate",
+    "marshmallow",
+    "python-dateutil",
+    "sqlalchemy<3",
+]
+
+[project.optional-dependencies]
+tests = [
+    "pytest",
+    "geoalchemy2",
+    "shapely",
+    "jsonschema",
+    "flask-marshmallow",
+    "marshmallow-sqlalchemy",
+    "psycopg2-binary",
+    "pytest-cov"
+]
+
+[project.urls]
+Homepage = "https://github.com/PnX-SI/Utils-Flask-SQLAlchemy"
+
+[project.entry-points.alembic]
+migrations = "utils_flask_sqla.migrations:versions"
+
+[project.entry-points."pytest11"]
+sqla = "utils_flask_sqla.tests.plugin"
+
+[project.entry-points."flask.commands"]
+db = "utils_flask_sqla.commands:db_cli"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.dynamic]
+version = { file = "VERSION" }
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+testpaths = ["src"]
+markers = [
+    "postgresql: tests requiring a running PostgreSQL database (see TEST_PG_DATABASE_URI env var)",
+]
+
+[tool.coverage.run]
+omit = ["*/tests/*", "*/migrations/*"]
+
+[tool.black]
+line-length = 99

{utils_flask_sqlalchemy-0.4.5 → utils_flask_sqlalchemy-0.5.0}/src/utils_flask_sqla/commands.py

@@ -6,6 +6,7 @@ import json
 import click
 import flask_migrate
 from flask import current_app
+import sqlalchemy as sa
 from alembic.migration import MigrationContext
 from alembic.context import EnvironmentContext
 from alembic.script import ScriptDirectory
@@ -52,10 +53,10 @@ def box_drowing(up, down, left, right, bold=True):
 @click.option("--json", "json_output", is_flag=True, help="Output commands results as JSON.")
 @with_appcontext
 def exec(command, commit, json_output):
-    db = current_app.extensions["sqlalchemy"].db
+    db = current_app.extensions["sqlalchemy"]
     results = []
     for cmd in command:
-        results.append(db.session.execute(cmd))
+        results.append(db.session.execute(sa.text(cmd)))
     if commit:
         db.session.commit()
     if json_output:
@@ -86,7 +87,7 @@ def exec(command, commit, json_output):
 @with_appcontext
 def autoupgrade(directory, sql, tag, x_arg):
     """Upgrade all branches to head."""
-    db = current_app.extensions["sqlalchemy"].db
+    db = current_app.extensions["sqlalchemy"]
     migrate = current_app.extensions["migrate"].migrate
     config = migrate.get_config(directory, x_arg)
     script = ScriptDirectory.from_config(config)
@@ -117,7 +118,8 @@ def autoupgrade(directory, sql, tag, x_arg):
 @with_appcontext
 def status(directory, x_arg, show_dependencies, branches):
     """Show all revisions sorted by branches."""
-    db = current_app.extensions["sqlalchemy"].db
+    db = current_app.extensions["sqlalchemy"]
+
     migrate = current_app.extensions["migrate"].migrate
 
     config = migrate.get_config(directory, x_arg)

utils_flask_sqlalchemy-0.5.0/src/utils_flask_sqla/fulltext.py

@@ -0,0 +1,107 @@
+"""
+Helpers to build accent-insensitive PostgreSQL full text searches.
+
+They rely on the PostgreSQL ``unaccent`` extension (``CREATE EXTENSION unaccent``).
+
+Examples
+--------
+>>> query = fts_query("anny dup")
+>>> if query is not None:
+...     document = fts_document(User.nom_role, User.prenom_role)
+...     stmt = (
+...         select(User)
+...         .where(document.op("@@")(query))
+...         .order_by(ts_rank(document, query).desc())
+...     )
+"""
+
+import re
+
+import sqlalchemy as sa
+from sqlalchemy import func
+from sqlalchemy.dialects.postgresql import REGCONFIG
+
+__all__ = ["DEFAULT_FTS_CONFIG", "fts_document", "fts_query", "ts_rank"]
+
+DEFAULT_FTS_CONFIG = "french"
+
+
+def _regconfig(config):
+    return sa.cast(sa.literal(config), REGCONFIG)
+
+
+def fts_document(*columns, config=DEFAULT_FTS_CONFIG):
+    """
+    Build an accent-insensitive ``tsvector`` from text columns.
+
+    Punctuation separates words.
+
+    Parameters
+    ----------
+    *columns : sqlalchemy.sql.ColumnElement
+        Columns (or text expressions) concatenated into one document. NULLs are ignored.
+    config : str, default "french"
+        Name of the PostgreSQL text search configuration.
+
+    Returns
+    -------
+    sqlalchemy.sql.ColumnElement
+        The ``tsvector`` expression.
+    """
+    # punctuation is replaced by spaces: the PostgreSQL parser would read "CA-2020" as the words
+    # "ca" and "-2020" (a negative number), which a search for "2020" would not find
+    text = func.regexp_replace(
+        func.unaccent(func.concat_ws(" ", *columns)), r"[^[:alnum:]]+", " ", "g"
+    )
+    return func.to_tsvector(_regconfig(config), text)
+
+
+def fts_query(search, *, prefix=True, config=DEFAULT_FTS_CONFIG):
+    """
+    Build an accent-insensitive ``tsquery`` matching all the words of a text.
+
+    Only the words (letters and digits) of `search` are kept, so it is safe to give it as typed by
+    a user. Punctuation, such as the dashes of "CA-2020" or of an UUID, separates words, like in
+    `fts_document`.
+
+    Parameters
+    ----------
+    search : str or None
+        Text to search.
+    prefix : bool, default True
+        Match the last word as a prefix, so that results follow what is being typed: the other
+        words are complete, otherwise "ca-1" would match any text with a word beginning with
+        "ca" ("carte") and another one beginning with "1".
+    config : str, default "french"
+        Name of the PostgreSQL text search configuration.
+
+    Returns
+    -------
+    sqlalchemy.sql.ColumnElement or None
+        The ``tsquery`` expression, or None if `search` holds no word.
+    """
+    words = re.findall(r"[^\W_]+", search or "")
+    if not words:
+        return None
+    if prefix:
+        words[-1] += ":*"
+    return func.to_tsquery(_regconfig(config), func.unaccent(" & ".join(words)))
+
+
+def ts_rank(document, query):
+    """
+    Compute the relevance of a document for a query.
+
+    Parameters
+    ----------
+    document : sqlalchemy.sql.ColumnElement
+        The ``tsvector``, see `fts_document`.
+    query : sqlalchemy.sql.ColumnElement
+        The ``tsquery``, see `fts_query`.
+
+    Returns
+    -------
+    sqlalchemy.sql.ColumnElement
+        The rank expression, the higher the more relevant.
+    """
+    return func.ts_rank(document, query)

{utils_flask_sqlalchemy-0.4.5 → utils_flask_sqlalchemy-0.5.0}/src/utils_flask_sqla/generic.py

@@ -107,10 +107,9 @@ class GenericTable:
 
         try:
             with db.engine.connect() as conn:
-                metadata = sa.MetaData(bind=conn)
                 self.tableDef = sa.Table(
                     tableName,
-                    metadata,
+                    db.metadata,
                     schema=schemaName,
                     autoload_with=conn,
                 )
@@ -279,7 +278,9 @@ class GenericQuery:
         nb_result_without_filter = q.count()
 
         q = self.raw_query(process_filter=True)
-        total_filtered = q.limit(None).count() if self.filters else nb_result_without_filter
+        total_filtered = (
+            q.limit(None).offset(None).count() if self.filters else nb_result_without_filter
+        )
 
         data = q.all()
 

utils_flask_sqlalchemy-0.5.0/src/utils_flask_sqla/migrations/versions/1d09a9b67970_add_functions_to_fetch_dependent_view_.py

@@ -0,0 +1,185 @@
+"""add functions to fetch dependent view and recreate them
+
+Revision ID: 1d09a9b67970
+Revises: ba207b468e31
+Create Date: 2026-08-12 11:12:11.614522
+
+"""
+
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision = "1d09a9b67970"
+down_revision = "ba207b468e31"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.execute(sa.text("""
+    
+    -- 1. Recursively find all views/matviews that (transitively) depend on
+    --    a given table or view, ordered deepest-dependent first.
+    
+    CREATE OR REPLACE FUNCTION public.pg_view_dependency_tree(p_schema text, p_relname text)
+    RETURNS TABLE(view_schema text, view_name text, view_kind text, depth int)
+    LANGUAGE sql
+    AS $$
+        WITH RECURSIVE deps AS (
+            SELECT
+                dependent_ns.nspname::text AS view_schema,
+                dependent_view.relname::text AS view_name,
+                dependent_view.relkind::text AS view_kind,
+                1 AS depth
+            FROM pg_depend
+            JOIN pg_rewrite ON pg_depend.objid = pg_rewrite.oid
+            JOIN pg_class dependent_view ON pg_rewrite.ev_class = dependent_view.oid
+            JOIN pg_class source_table ON pg_depend.refobjid = source_table.oid
+            JOIN pg_namespace dependent_ns ON dependent_view.relnamespace = dependent_ns.oid
+            JOIN pg_namespace source_ns ON source_table.relnamespace = source_ns.oid
+            WHERE source_table.relname = p_relname
+              AND source_ns.nspname = p_schema
+              AND dependent_view.relkind IN ('v', 'm')
+              AND dependent_view.oid <> source_table.oid
+    
+            UNION
+    
+            SELECT
+                dependent_ns.nspname::text,
+                dependent_view.relname::text,
+                dependent_view.relkind::text,
+                deps.depth + 1
+            FROM deps
+            JOIN pg_namespace source_ns ON source_ns.nspname = deps.view_schema
+            JOIN pg_class source_table
+                ON source_table.relname = deps.view_name
+               AND source_table.relnamespace = source_ns.oid
+            JOIN pg_depend ON pg_depend.refobjid = source_table.oid
+            JOIN pg_rewrite ON pg_depend.objid = pg_rewrite.oid
+            JOIN pg_class dependent_view ON pg_rewrite.ev_class = dependent_view.oid
+            JOIN pg_namespace dependent_ns ON dependent_view.relnamespace = dependent_ns.oid
+            WHERE dependent_view.relkind IN ('v', 'm')
+              AND dependent_view.oid <> source_table.oid
+        )
+        SELECT view_schema, view_name, view_kind, MAX(depth) AS depth
+        FROM deps
+        GROUP BY view_schema, view_name, view_kind
+        ORDER BY depth DESC;  -- most-dependent first (correct drop order)
+    $$;
+    
+    
+    -- 2. Capture full definitions (+ owner, + indexes for matviews) as jsonb,
+    --    in drop order.
+    CREATE OR REPLACE FUNCTION public.pg_capture_dependent_views(p_schema text, p_relname text)
+    RETURNS jsonb
+    LANGUAGE plpgsql
+    AS $$
+    DECLARE
+        result jsonb := '[]'::jsonb;
+        rec record;
+        v_def text;
+        v_owner text;
+        v_indexes jsonb;
+    BEGIN
+        FOR rec IN
+            SELECT * FROM public.pg_view_dependency_tree(p_schema, p_relname)
+        LOOP
+            SELECT pg_get_viewdef(format('%I.%I', rec.view_schema, rec.view_name)::regclass, true)
+            INTO v_def;
+    
+            SELECT pg_get_userbyid(c.relowner) INTO v_owner
+            FROM pg_class c
+            JOIN pg_namespace n ON c.relnamespace = n.oid
+            WHERE c.relname = rec.view_name AND n.nspname = rec.view_schema;
+    
+            v_indexes := '[]'::jsonb;
+            IF rec.view_kind = 'm' THEN
+                SELECT coalesce(jsonb_agg(indexdef), '[]'::jsonb) INTO v_indexes
+                FROM pg_indexes
+                WHERE schemaname = rec.view_schema AND tablename = rec.view_name;
+            END IF;
+    
+            result := result || jsonb_build_object(
+                'schema', rec.view_schema,
+                'name', rec.view_name,
+                'kind', rec.view_kind,
+                'definition', v_def,
+                'owner', v_owner,
+                'indexes', v_indexes
+            );
+        END LOOP;
+        RETURN result;
+    END;
+    $$;
+    
+    
+    -- 3. Drop the captured views (dependents first, order already correct
+    --    in the jsonb array). CASCADE is a safety net, not the primary
+    --    mechanism, since we already dropped dependents-first.
+    CREATE OR REPLACE FUNCTION public.pg_drop_dependent_views(p_views jsonb)
+    RETURNS void
+    LANGUAGE plpgsql
+    AS $$
+    DECLARE
+        rec jsonb;
+        obj_type text;
+    BEGIN
+        FOR rec IN SELECT * FROM jsonb_array_elements(p_views)
+        LOOP
+            obj_type := CASE WHEN rec->>'kind' = 'm' THEN 'MATERIALIZED VIEW' ELSE 'VIEW' END;
+            EXECUTE format('DROP %s IF EXISTS %I.%I CASCADE', obj_type, rec->>'schema', rec->>'name');
+        END LOOP;
+    END;
+    $$;
+    
+    
+    -- 4. Recreate the captured views in reverse order (dependencies before
+    --    dependents), reapply owner, indexes, and refresh matviews.
+    CREATE OR REPLACE FUNCTION public.pg_recreate_dependent_views(p_views jsonb)
+    RETURNS void
+    LANGUAGE plpgsql
+    AS $$
+    DECLARE
+        rec jsonb;
+        obj_type text;
+        idx text;
+        n int;
+        i int;
+    BEGIN
+        n := jsonb_array_length(p_views);
+        FOR i IN REVERSE (n - 1)..0 LOOP
+            rec := p_views -> i;
+            obj_type := CASE WHEN rec->>'kind' = 'm' THEN 'MATERIALIZED VIEW' ELSE 'VIEW' END;
+    
+            EXECUTE format('CREATE %s %I.%I AS %s',
+                            obj_type, rec->>'schema', rec->>'name', rec->>'definition');
+    
+            IF rec->>'owner' IS NOT NULL THEN
+                EXECUTE format('ALTER %s %I.%I OWNER TO %I',
+                                obj_type, rec->>'schema', rec->>'name', rec->>'owner');
+            END IF;
+    
+            IF jsonb_array_length(rec->'indexes') > 0 THEN
+                FOR idx IN SELECT jsonb_array_elements_text(rec->'indexes')
+                LOOP
+                    EXECUTE idx;
+                END LOOP;
+            END IF;
+    
+            IF rec->>'kind' = 'm' THEN
+                EXECUTE format('REFRESH MATERIALIZED VIEW %I.%I', rec->>'schema', rec->>'name');
+            END IF;
+        END LOOP;
+    END;
+    $$;
+        """))
+
+
+def downgrade():
+    op.execute(sa.text("""
+    DROP FUNCTION IF EXISTS public.pg_recreate_dependent_views(jsonb);
+    DROP FUNCTION IF EXISTS public.pg_drop_dependent_views(jsonb);
+    DROP FUNCTION IF EXISTS public.pg_capture_dependent_views(text, text);
+    DROP FUNCTION IF EXISTS public.pg_view_dependency_tree(text, text);
+        """))

utils_flask_sqlalchemy-0.5.0/src/utils_flask_sqla/referential.py

@@ -0,0 +1,102 @@
+import csv
+import os
+
+from sqlalchemy import (
+    inspect as sa_inspect,
+    func,
+    exists,
+    select,
+    table as sa_table,
+    column as sa_column,
+)
+
+CSV_FIELDNAMES = [
+    "ref_table",
+    "table_name",
+    "schema",
+    "fk_column",
+    "fk_value",
+    "nb_affected_lines",
+]
+
+
+def get_referencing_tables(table_name, db, schema="", exclude_tables=[]):
+    """Trouve toutes les tables qui ont des FK pointant vers table_name,
+    en excluant les tables listées dans exclude_tables (même schéma)."""
+    exclude_tables = set(exclude_tables or [])
+    inspector = sa_inspect(db.session.connection())
+    referencing_tables = []
+
+    for other_schema in inspector.get_schema_names():
+        if other_schema in ("pg_catalog", "information_schema", "pg_toast"):
+            continue
+        try:
+            for other_table in inspector.get_table_names(schema=other_schema):
+                if other_table != table_name and other_table in exclude_tables:
+                    continue
+                for fk in inspector.get_foreign_keys(other_table, schema=other_schema):
+                    if fk["referred_table"] == f"{schema}.{table_name}" or (
+                        fk["referred_table"] == table_name
+                        and (fk.get("referred_schema") or schema) == schema
+                    ):
+                        referencing_tables.append(
+                            {
+                                "schema": other_schema,
+                                "table": other_table,
+                                "fk_column": fk["constrained_columns"][0],
+                                "ref_column": fk["referred_columns"][0],
+                            }
+                        )
+        except Exception as e:
+            print(f"Impossible d'inspecter le schéma {other_schema}: {e}")
+
+    return referencing_tables
+
+
+def collect_orphan_rows(ref_table, new_ref_table, pk_col, db, schema="", exclude_tables=None):
+    """
+    Retourne la liste des lignes orphelines pour une table du référentiel :
+    valeurs de pk_col présentes dans les tables référençantes mais absentes de new_ref_table.
+    """
+    referencing = get_referencing_tables(
+        ref_table, db, schema=schema, exclude_tables=exclude_tables
+    )
+    rows = []
+    for ref in referencing:
+        fk_col = ref["fk_column"]
+        src = sa_table(ref["table"], sa_column(fk_col), schema=ref["schema"])
+        ref_t = sa_table(new_ref_table, sa_column(pk_col), schema=schema)
+        subq = select(1).select_from(ref_t).where(ref_t.c[pk_col] == src.c[fk_col])
+        stmt = (
+            select(src.c[fk_col], func.count().label("nb_lines"))
+            .where(src.c[fk_col].isnot(None))
+            .where(~exists(subq))
+            .group_by(src.c[fk_col])
+            .order_by(src.c[fk_col])
+        )
+        for fk_value, nb_lines in db.session.execute(stmt).fetchall():
+            rows.append(
+                {
+                    "ref_table": ref_table,
+                    "table_name": ref["table"],
+                    "schema": ref["schema"],
+                    "fk_column": fk_col,
+                    "fk_value": fk_value,
+                    "nb_affected_lines": nb_lines,
+                }
+            )
+    return rows
+
+
+def export_orphans_to_csv(rows, output_path):
+    """Écrit la liste de lignes orphelines dans un CSV."""
+    if not rows:
+        return 0
+    dirname = os.path.dirname(output_path)
+    if dirname:
+        os.makedirs(dirname, exist_ok=True)
+    with open(output_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=CSV_FIELDNAMES)
+        writer.writeheader()
+        writer.writerows(rows)
+    return len(rows)

utils_flask_sqlalchemy-0.5.0/src/utils_flask_sqla/revision.py

@@ -0,0 +1,51 @@
+from contextlib import contextmanager
+from sqlalchemy import text
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy import bindparam
+
+
+@contextmanager
+def alter_table_with_dependent_views(conn, schema, table_name):
+    """
+    Python wrapper that allows to modify a table/view with dependent views (and their dependant views).
+
+    **Example**
+
+    >>> with alter_table_with_dependent_views(conn,"gn_synthese","synthese"):
+    >>>     op.execute("ALTER gn_synthese.synthese DROP COLUMN id_individual")
+
+    Parameters
+    ----------
+    conn: any
+        SQLAlchemy connection to your database
+    schema: str
+        name of the schema of the table
+    table_name: str
+        name of the table in your schema
+
+    Notes
+    -----
+    This function relies on the existence of sql functions (`public.pg_capture_dependent_views`,
+    `public.pg_drop_dependent_views`, `public.pg_recreate_dependent_views`) in your database !
+    Make sure the revision 1d09a9b67970 is applied on your database !
+    In an Alembic revision, you can enforce this by adding `depends_on = ("1d09a9b67970",)`
+    """
+    captured = conn.execute(
+        text("SELECT public.pg_capture_dependent_views(:s, :t)"),
+        {"s": schema, "t": table_name},
+    ).scalar()
+
+    conn.execute(
+        text("SELECT public.pg_drop_dependent_views(:v)").bindparams(bindparam("v", type_=JSONB)),
+        {"v": captured},
+    )
+
+    try:
+        yield
+    finally:
+        conn.execute(
+            text("SELECT public.pg_recreate_dependent_views(:v)").bindparams(
+                bindparam("v", type_=JSONB)
+            ),
+            {"v": captured},
+        )

{utils_flask_sqlalchemy-0.4.5 → utils_flask_sqlalchemy-0.5.0}/src/utils_flask_sqla/schema.py

@@ -1,7 +1,6 @@
 from marshmallow.fields import Nested
 from marshmallow_sqlalchemy.fields import RelatedList, Related
-
-# from flask_marshmallow.fields import RelatedList
+from sqlalchemy.orm import ColumnProperty
 
 
 class SmartRelationshipsMixin:
@@ -54,12 +53,12 @@ class SmartRelationshipsMixin:
                 nested_fields.add(name)
             elif field.metadata.get("exclude", False):
                 excluded_fields.add(name)
-            elif (
-                hasattr(self.opts, "model")
-                and hasattr(self.opts.model.__mapper__.column_attrs, name)
-                and getattr(self.opts.model.__mapper__.column_attrs, name).deferred
-            ):
-                excluded_fields.add(name)
+            elif hasattr(self.opts, "model") and hasattr(self.opts.model.__mapper__.attrs, name):
+                column_prop = getattr(self.opts.model.__mapper__.attrs, name)
+                if isinstance(column_prop, ColumnProperty) and column_prop.deferred is True:
+                    excluded_fields.add(name)
+                else:
+                    included_fields.add(name)
             else:
                 included_fields.add(name)
 

{utils_flask_sqlalchemy-0.4.5 → utils_flask_sqlalchemy-0.5.0}/src/utils_flask_sqla/serializers.py

@@ -11,7 +11,8 @@ from uuid import UUID
 
 from sqlalchemy.orm import ColumnProperty
 from sqlalchemy import inspect
-from sqlalchemy.ext.hybrid import hybrid_property, HYBRID_PROPERTY
+from sqlalchemy.ext.hybrid import hybrid_property
+from sqlalchemy.ext.hybrid import HybridExtensionType
 from sqlalchemy.types import DateTime, Date, Time
 from sqlalchemy.dialects.postgresql.base import UUID
 
@@ -28,6 +29,8 @@ SERIALIZERS = {
     "numeric": lambda x: str(x) if x else None,
 }
 
+HYBRID_PROPERTY = HybridExtensionType.HYBRID_PROPERTY
+
 
 def get_serializer(col):
     if isinstance(col, ColumnProperty):