Returns None if Model is abstract

Using mypy's argument parser, raise `SystemExit` to fail hard if validation fails. Considering that the plugin's startup duration is around doubl

Get a model type that can be used to represent an annotated model

Attempt to replace a label with a modified version. If there are no lazy strings for labels, remove the lazy string type, and vice-versa.

Substitutes a specified type variable within a Mypy type expression with an actual type. This function is recursive, and it operates on vari

Attempt to replace a label with a modified version. If the value is of any type, then attempt to use the base type of the choices type.

Get a type of __get__ for this specific Django field.

Add implicit generics to classes that are defined without generic. When ``bind_explicit_args`` is True, also reparametrize partially or

Type-checks positional and keyword arguments for Model methods like __init__(), create(), and acreate().

Check that ``field_name`` is a concrete, non-primary-key field of ``model_cls``. Mirrors Django's ``Options._non_pk_concrete_field_names``: the s

Derive annotated field names from a QuerySet type. Sources: - args[0].extra_attrs: from .annotate() calls - args[1].extra_attrs:

Extract annotation field types from an annotated model's TypedDict type argument.

Derive selected field names from a QuerySet type. Sources: - values(): encoded in the row TypedDict keys - values_list(named=Tru

True if ``arg`` is the ``Any`` mypy substitutes for an unparametrized generic.

Resolve the expected type for a lookup class (used both for regular fields and annotated fields) Args: ctx lookup_cls

Helper to specialize a string argument to a Literal[str] type. This allows the plugin to extract the actual string value for further process

Check if adding `attr_name` would conflict with existing symbols on `model`. Args: - model: The Django model being analyzed

Check if a lookup string resolve to something that can be prefetched

Extract manager and queryset TypeInfo from a from_queryset call.

Creates a generic manager that subclasses both 'ManyRelatedManager' and the default manager of the given model. These are normally us

Get a type of __set__ for this specific Django field.

Get a primary key instance of provided model's type info. If primary key can't be resolved, return a default declaration.

Add methods from the QuerySet class to the manager.

Mirror `Aggregate.default_alias`: ``<source_expression>__<aggregate_name_lower>``. Django generates a default alias only for aggregates with a si

When the queryset's model type arg is a TypeVar bounded by a Model, return the upper bound.

Attempts to resolve a single enum type from a union of enum literals. If this cannot be resolved, the original is returned.

Symbols in `django.contrib.auth.forms` are very hard to patch automatically because we end up importing the User model and it crashes if `dja

Get valid field choices for select_related lookups. Based on Django's SQLCompiler.get_related_selections._get_field_choices method.

Determines whether the provided 'type_info', is a generically parameterized subclass of models.QuerySet[T], with exactly one type variabl

Infer the model Instance from `Prefetch(queryset=...)`

Check whether a choices type has lazy strings for labels. This is used to determine whether a choices type uses lazy strings or non-lazy str