add BaseManager.create() typechecking

Author: mkurnikov

django-stubs/contrib/admin/models.pyi

@@ -11,7 +11,7 @@ CHANGE: int
 DELETION: int
 ACTION_FLAG_CHOICES: Any
 
-class LogEntryManager(models.Manager):
+class LogEntryManager(models.Manager["LogEntry"]):
     def log_action(
         self,
         user_id: int,

django-stubs/contrib/auth/models.pyi

@@ -16,7 +16,7 @@ class Permission(models.Model):
     content_type_id: int
     name: models.CharField = ...
     content_type: models.ForeignKey[ContentType] = ...
-    codename: str = ...
+    codename: models.CharField = ...
     def natural_key(self) -> Tuple[str, str, str]: ...
 
 class GroupManager(models.Manager):

django-stubs/contrib/redirects/models.pyi

@@ -1,10 +1,6 @@
-from typing import Any, Optional
-
 from django.db import models
 
 class Redirect(models.Model):
-    id: None
-    site_id: int
-    site: Any = ...
-    old_path: str = ...
-    new_path: str = ...
+    site: models.ForeignKey = ...
+    old_path: models.CharField = ...
+    new_path: models.CharField = ...

django-stubs/contrib/sessions/backends/db.pyi

@@ -1,13 +1,14 @@
-from typing import Any, Dict, Optional, Type, Union
+from typing import Dict, Optional, Type, Union
 
 from django.contrib.sessions.backends.base import SessionBase
 from django.contrib.sessions.base_session import AbstractBaseSession
 from django.contrib.sessions.models import Session
+from django.core.signing import Serializer
 from django.db.models.base import Model
 
 class SessionStore(SessionBase):
     accessed: bool
-    serializer: Type[django.core.signing.JSONSerializer]
+    serializer: Type[Serializer]
     def __init__(self, session_key: Optional[str] = ...) -> None: ...
     @classmethod
     def get_model_class(cls) -> Type[Session]: ...

django-stubs/db/models/base.pyi

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Optional, Set, Tuple, TypeVar, Union, ClassVar, Sequence
+from typing import Any, Dict, List, Optional, Set, Tuple, TypeVar, Union, ClassVar, Sequence, Generic
 
 from django.db.models.manager import Manager
 
@@ -10,9 +10,9 @@ class Model(metaclass=ModelBase):
     class DoesNotExist(Exception): ...
     class Meta: ...
     _meta: Any
+    _default_manager: Manager[Model]
     pk: Any = ...
-    objects: Manager[Model]
-    def __init__(self, *args, **kwargs) -> None: ...
+    def __init__(self: _Self, *args, **kwargs) -> None: ...
     def delete(self, using: Any = ..., keep_parents: bool = ...) -> Tuple[int, Dict[str, int]]: ...
     def full_clean(self, exclude: Optional[List[str]] = ..., validate_unique: bool = ...) -> None: ...
     def clean_fields(self, exclude: List[str] = ...) -> None: ...

django-stubs/db/models/fields/__init__.pyi

@@ -1,6 +1,6 @@
 import uuid
 from datetime import date, time, datetime, timedelta
-from typing import Any, Optional, Tuple, Iterable, Callable, Dict, Union, Type, TypeVar
+from typing import Any, Optional, Tuple, Iterable, Callable, Dict, Union, Type, TypeVar, Generic
 import decimal
 
 from typing_extensions import Literal
@@ -14,7 +14,7 @@ from django.forms import Widget, Field as FormField
 from .mixins import NOT_PROVIDED as NOT_PROVIDED
 
 _Choice = Tuple[Any, Any]
-_ChoiceNamedGroup = Union[Tuple[str, Iterable[_Choice]], Tuple[str, Any]]
+_ChoiceNamedGroup = Tuple[str, Iterable[_Choice]]
 _FieldChoices = Iterable[Union[_Choice, _ChoiceNamedGroup]]
 
 _ValidatorCallable = Callable[..., None]
@@ -76,7 +76,7 @@ class SmallIntegerField(IntegerField): ...
 class BigIntegerField(IntegerField): ...
 
 class FloatField(Field):
-    def __set__(self, instance, value: Union[float, int, Combinable]) -> float: ...
+    def __set__(self, instance, value: Union[float, int, str, Combinable]) -> float: ...
     def __get__(self, instance, owner) -> float: ...
 
 class DecimalField(Field):
@@ -102,7 +102,7 @@ class DecimalField(Field):
         validators: Iterable[_ValidatorCallable] = ...,
         error_messages: Optional[_ErrorMessagesToOverride] = ...,
     ): ...
-    def __set__(self, instance, value: Union[str, Combinable]) -> decimal.Decimal: ...
+    def __set__(self, instance, value: Union[str, float, decimal.Decimal, Combinable]) -> decimal.Decimal: ...
     def __get__(self, instance, owner) -> decimal.Decimal: ...
 
 class AutoField(Field):
@@ -167,15 +167,15 @@ class EmailField(CharField): ...
 class URLField(CharField): ...
 
 class TextField(Field):
-    def __set__(self, instance, value: str) -> None: ...
+    def __set__(self, instance, value: Union[str, Combinable]) -> None: ...
     def __get__(self, instance, owner) -> str: ...
 
 class BooleanField(Field):
-    def __set__(self, instance, value: bool) -> None: ...
+    def __set__(self, instance, value: Union[bool, Combinable]) -> None: ...
     def __get__(self, instance, owner) -> bool: ...
 
 class NullBooleanField(Field):
-    def __set__(self, instance, value: Optional[bool]) -> None: ...
+    def __set__(self, instance, value: Optional[Union[bool, Combinable]]) -> None: ...
     def __get__(self, instance, owner) -> Optional[bool]: ...
 
 class IPAddressField(Field):

django-stubs/views/debug.pyi

@@ -1,9 +1,8 @@
 from importlib.abc import SourceLoader
-from typing import Any, Callable, Dict, List, Optional, Type, Union
 from types import TracebackType
+from typing import Any, Callable, Dict, List, MutableMapping, Optional, Type, Union
 
-from django.core.handlers.wsgi import WSGIRequest
-from django.http.request import QueryDict
+from django.http.request import HttpRequest, QueryDict
 from django.http.response import Http404, HttpResponse
 from django.utils.safestring import SafeText
 
@@ -19,21 +18,21 @@ def cleanse_setting(key: Union[int, str], value: Any) -> Any: ...
 def get_safe_settings() -> Dict[str, Any]: ...
 def technical_500_response(request: Any, exc_type: Any, exc_value: Any, tb: Any, status_code: int = ...): ...
 def get_default_exception_reporter_filter() -> ExceptionReporterFilter: ...
-def get_exception_reporter_filter(request: Optional[WSGIRequest]) -> ExceptionReporterFilter: ...
+def get_exception_reporter_filter(request: Optional[HttpRequest]) -> ExceptionReporterFilter: ...
 
 class ExceptionReporterFilter:
     def get_post_parameters(self, request: Any): ...
     def get_traceback_frame_variables(self, request: Any, tb_frame: Any): ...
 
 class SafeExceptionReporterFilter(ExceptionReporterFilter):
-    def is_active(self, request: Optional[WSGIRequest]) -> bool: ...
-    def get_cleansed_multivaluedict(self, request: WSGIRequest, multivaluedict: QueryDict) -> QueryDict: ...
-    def get_post_parameters(self, request: Optional[WSGIRequest]) -> Union[Dict[Any, Any], QueryDict]: ...
-    def cleanse_special_types(self, request: Optional[WSGIRequest], value: Any) -> Any: ...
+    def is_active(self, request: Optional[HttpRequest]) -> bool: ...
+    def get_cleansed_multivaluedict(self, request: HttpRequest, multivaluedict: QueryDict) -> QueryDict: ...
+    def get_post_parameters(self, request: Optional[HttpRequest]) -> MutableMapping[str, Any]: ...
+    def cleanse_special_types(self, request: Optional[HttpRequest], value: Any) -> Any: ...
     def get_traceback_frame_variables(self, request: Any, tb_frame: Any): ...
 
 class ExceptionReporter:
-    request: Optional[WSGIRequest] = ...
+    request: Optional[HttpRequest] = ...
     filter: ExceptionReporterFilter = ...
     exc_type: None = ...
     exc_value: Optional[str] = ...
@@ -44,7 +43,7 @@ class ExceptionReporter:
     postmortem: None = ...
     def __init__(
         self,
-        request: Optional[WSGIRequest],
+        request: Optional[HttpRequest],
         exc_type: Optional[Type[BaseException]],
         exc_value: Optional[Union[str, BaseException]],
         tb: Optional[TracebackType],
@@ -63,5 +62,5 @@ class ExceptionReporter:
         module_name: Optional[str] = None,
     ): ...
 
-def technical_404_response(request: WSGIRequest, exception: Http404) -> HttpResponse: ...
-def default_urlconf(request: WSGIRequest) -> HttpResponse: ...
+def technical_404_response(request: HttpRequest, exception: Http404) -> HttpResponse: ...
+def default_urlconf(request: HttpRequest) -> HttpResponse: ...

mypy_django_plugin/config.py

@@ -0,0 +1,21 @@
+from configparser import ConfigParser
+from typing import Optional
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Config:
+    django_settings_module: Optional[str] = None
+    ignore_missing_settings: bool = False
+
+    @classmethod
+    def from_config_file(self, fpath: str) -> 'Config':
+        ini_config = ConfigParser()
+        ini_config.read(fpath)
+        if not ini_config.has_section('mypy_django_plugin'):
+            raise ValueError('Invalid config file: no [mypy_django_plugin] section')
+        return Config(django_settings_module=ini_config.get('mypy_django_plugin', 'django_settings',
+                                                            fallback=None),
+                      ignore_missing_settings=ini_config.get('mypy_django_plugin', 'ignore_missing_settings',
+                                                             fallback=False))

mypy_django_plugin/helpers.py

@@ -1,10 +1,9 @@
 import typing
 from typing import Dict, Optional
 
-from mypy.nodes import Expression, FuncDef, ImportedName, MypyFile, NameExpr, SymbolNode, TypeInfo, Var, AssignmentStmt, \
-    CallExpr
+from mypy.nodes import Expression, ImportedName, MypyFile, NameExpr, SymbolNode, TypeInfo
 from mypy.plugin import FunctionContext
-from mypy.types import AnyType, CallableType, Instance, Type, TypeOfAny, TypeVarType, UnionType
+from mypy.types import AnyType, Instance, Type, TypeOfAny, TypeVarType
 
 MODEL_CLASS_FULLNAME = 'django.db.models.base.Model'
 FIELD_FULLNAME = 'django.db.models.fields.Field'
@@ -119,74 +118,6 @@ def fill_typevars(tp: Instance, type_to_fill: Instance) -> Instance:
     return reparametrize_with(type_to_fill, typevar_values)
 
 
-def extract_field_setter_type(tp: Instance) -> Optional[Type]:
-    if tp.type.has_base(FIELD_FULLNAME):
-        set_method = tp.type.get_method('__set__')
-        if isinstance(set_method, FuncDef) and isinstance(set_method.type, CallableType):
-            if 'value' in set_method.type.arg_names:
-                set_value_type = set_method.type.arg_types[set_method.type.arg_names.index('value')]
-                if isinstance(set_value_type, Instance):
-                    set_value_type = fill_typevars(tp, set_value_type)
-                    return set_value_type
-                elif isinstance(set_value_type, UnionType):
-                    items_no_typevars = []
-                    for item in set_value_type.items:
-                        if isinstance(item, Instance):
-                            item = fill_typevars(tp, item)
-                        items_no_typevars.append(item)
-                    return UnionType(items_no_typevars)
-
-        get_method = tp.type.get_method('__get__')
-        if isinstance(get_method, FuncDef) and isinstance(get_method.type, CallableType):
-            return get_method.type.ret_type
-    # GenericForeignKey
-    if tp.type.has_base(GENERIC_FOREIGN_KEY_FULLNAME):
-        return AnyType(TypeOfAny.special_form)
-    return None
-
-
-def extract_primary_key_type(model: TypeInfo) -> Optional[Type]:
-    # only primary keys defined in current class for now
-    for stmt in model.defn.defs.body:
-        if isinstance(stmt, AssignmentStmt) and isinstance(stmt.rvalue, CallExpr):
-            name_expr = stmt.lvalues[0]
-            if isinstance(name_expr, NameExpr):
-                name = name_expr.name
-                if 'primary_key' in stmt.rvalue.arg_names:
-                    is_primary_key = stmt.rvalue.args[stmt.rvalue.arg_names.index('primary_key')]
-                    if is_primary_key:
-                        return extract_field_setter_type(model.names[name].type)
-    return None
-
-
-def extract_expected_types(ctx: FunctionContext, model: TypeInfo) -> Dict[str, Type]:
-    expected_types: Dict[str, Type] = {}
-
-    primary_key_type = extract_primary_key_type(model)
-    if not primary_key_type:
-        # no explicit primary key, set pk to Any and add id
-        primary_key_type = AnyType(TypeOfAny.special_form)
-        expected_types['id'] = ctx.api.named_generic_type('builtins.int', [])
-
-    expected_types['pk'] = primary_key_type
-
-    for base in model.mro:
-        for name, sym in base.names.items():
-            if isinstance(sym.node, Var) and isinstance(sym.node.type, Instance):
-                tp = sym.node.type
-                field_type = extract_field_setter_type(tp)
-                if tp.type.fullname() in {FOREIGN_KEY_FULLNAME, ONETOONE_FIELD_FULLNAME}:
-                    ref_to_model = tp.args[0]
-                    if isinstance(ref_to_model, Instance) and ref_to_model.type.has_base(MODEL_CLASS_FULLNAME):
-                        primary_key_type = extract_primary_key_type(ref_to_model.type)
-                        if not primary_key_type:
-                            primary_key_type = AnyType(TypeOfAny.special_form)
-                        expected_types[name + '_id'] = primary_key_type
-                if field_type:
-                    expected_types[name] = field_type
-    return expected_types
-
-
 def get_argument_by_name(ctx: FunctionContext, name: str) -> Optional[Expression]:
     """Return the expression for the specific argument.