Passing __dict__ into dict

[pamelafox]

I have this line of code:

body = dict(model_class.__dict__)

Running mypy results in this error:

src/flask_sqlalchemy/extension.py:543: error: Argument 1 to "dict" has incompatible type
"Union[Dict[str, Any], Callable[[type], MappingProxyType[str, Any]]]"; expected "SupportsKeysAndGetItem[str, Any]" 
[arg-type]
                body = dict(model_class.__dict__)
                            ^~~~~~~~~~~~~~~~~~~~
Found 1 error in 1 file (checked 25 source files)

Functionally, it seems to work to convert the mappingproxy into a dict. How could I make typing happy?

[TeamSpen210]

What exactly is the type of model_class? Add reveal_type(model_class) on the line before. We probably want to check what exactly is the definition for __dict__, it seems this might be a metaclass issue. Since __dict__ is one thing on the instance, but something unrelated on the class.

[pamelafox]

Revealed type is "Type[_FSA_MC`-1]", and _FSA_MC is a custom typevar-

_FSA_MC = t.TypeVar(
    "_FSA_MC",
    bound=t.Union[
        Model,
        sa_orm.DeclarativeMeta,
        sa_orm.DeclarativeBase,
        sa_orm.DeclarativeBaseNoMeta,
    ],
)

You can see it in context here:
https://github.com/pallets-eco/flask-sqlalchemy/pull/1215/files#diff-bc2a74295364ce4cb56f3892dea01d85406592b5a2e19b84bb548ffd06e29065

__dict__ is CPython's standard attribute for class objects, and its revealed type is "Union[builtins.dict[builtins.str, Any], def (self: builtins.type) -> types.MappingProxyType[builtins.str, Any]]"

Python docs for MappingProxyType: https://docs.python.org/3/library/types.html#types.MappingProxyType

[Daverball]

It looks like at least one of the types in the union is not like the others and does something more wacky with __dict__, which is not that surprising with ORMs, in SQLAlchemy there's usually a Mapper between the Model and the more primitive schema constructs such as sqla.Table, which does have some implications about where class-level data is stored.

You can try out each of the base classes, to see which ones requires you to call __dict__ with a type first to get a read-only mapping back.

[Daverball]

Actually it looks like def (self: builtins.type) -> types.MappingProxyType[builtins.str, Any] is what __dict__ looks like on type. Which makes sense, it's a metaclass, the __dict__ depends on which specific class you use the metaclass with.

So the problem is that this TypeVar is a union of type | object which will result in type[type | object] so you end up with metaclasses in the type union, which seems odd, it's rare that you can use the two interchangeably.

[Daverball]

Since you're always using type[_FSA_MC] you should probably change it to:

_FSA_MCT = t.TypeVar(
    "_FSA_MCT",
    bound=t.Union[
        t.Type[Model],
        t.Type[sa_orm.DeclarativeBase],
        t.Type[sa_orm.DeclarativeBaseNoMeta],
        sa_orm.DeclarativeMeta,
    ],
)

And change all the annotations to use _FSA_MCT, rather than type[_FSA_MC]. If there are any functions that accept any instance that's derived from a class that uses DeclarativeMeta, you probably won't get around changing _FSA_MC to an unbounded TypeVar, or to one that's bound to a Protocol which contains properties that all models should have, if you want to support any custom base class that uses the metaclass.

[pamelafox]

Thank you so much! I've made the change here:
pallets-eco/flask-sqlalchemy@fe9e4de
I did have to add an ignore on a later line that tries to assign the _FSA_MCT parameter to a variable with Type[_FSAModel] (derived from DeclarativeMeta) but that can be removed in future versions when we no longer support the metaclass.