Merge pull request #281 from mkurnikov/update-deps

Update dev deps, mypy to 0.760

dev-requirements.txt

@@ -1,5 +1,5 @@
 black
-pytest-mypy-plugins==1.1.0
+pytest-mypy-plugins==1.2.0
 psycopg2
 flake8==3.7.9
 flake8-pyi==19.3.0

django-stubs/core/management/color.pyi

@@ -1,11 +1,24 @@
 def supports_color() -> bool: ...
 
 class Style:
-    def DEBUG(self, text: str) -> str: ...
-    def INFO(self, text: str) -> str: ...
+    def ERROR(self, text: str) -> str: ...
     def SUCCESS(self, text: str) -> str: ...
     def WARNING(self, text: str) -> str: ...
-    def ERROR(self, text: str) -> str: ...
+    def NOTICE(self, text: str) -> str: ...
+    def SQL_FIELD(self, text: str) -> str: ...
+    def SQL_COLTYPE(self, text: str) -> str: ...
+    def SQL_KEYWORD(self, text: str) -> str: ...
+    def SQL_TABLE(self, text: str) -> str: ...
+    def HTTP_INFO(self, text: str) -> str: ...
+    def HTTP_SUCCESS(self, text: str) -> str: ...
+    def HTTP_REDIRECT(self, text: str) -> str: ...
+    def HTTP_NOT_MODIFIED(self, text: str) -> str: ...
+    def HTTP_BAD_REQUEST(self, text: str) -> str: ...
+    def HTTP_NOT_FOUND(self, text: str) -> str: ...
+    def HTTP_SERVER_ERROR(self, text: str) -> str: ...
+    def MIGRATE_HEADING(self, text: str) -> str: ...
+    def MIGRATE_LABEL(self, text: str) -> str: ...
+    def ERROR_OUTPUT(self, text: str) -> str: ...
 
 def make_style(config_string: str = ...) -> Style: ...
 def no_style() -> Style: ...

django-stubs/db/models/base.pyi

@@ -2,7 +2,7 @@ from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Tuple, Ty
 
 from django.core.checks.messages import CheckMessage
 from django.core.exceptions import ValidationError
-from django.db.models.manager import Manager
+from django.db.models.manager import BaseManager
 from django.db.models.options import Options
 
 _Self = TypeVar("_Self", bound="Model")
@@ -13,9 +13,9 @@ class Model(metaclass=ModelBase):
     class DoesNotExist(Exception): ...
     class MultipleObjectsReturned(Exception): ...
     class Meta: ...
-    _default_manager: Manager[Model]
     _meta: Options[Any]
-    objects: Manager[Any]
+    _default_manager: BaseManager[Model]
+    objects: BaseManager[Any]
     pk: Any = ...
     def __init__(self: _Self, *args, **kwargs) -> None: ...
     def delete(self, using: Any = ..., keep_parents: bool = ...) -> Tuple[int, Dict[str, int]]: ...

django-stubs/db/models/query.pyi

@@ -31,6 +31,7 @@ _T = TypeVar("_T", bound=models.Model, covariant=True)
 _QS = TypeVar("_QS", bound="_BaseQuerySet")
 
 class _BaseQuerySet(Generic[_T], Sized):
+    model: Type[_T]
     query: Query
     def __init__(
         self,

django-stubs/forms/fields.pyi

@@ -205,10 +205,9 @@ class CallableChoiceIterator:
     def __iter__(self) -> None: ...
 
 class ChoiceField(Field):
-    choices: Any = ...
     def __init__(
         self,
-        choices: Any = ...,
+        choices: Union[_FieldChoices, Callable[[], _FieldChoices]] = ...,
         required: bool = ...,
         widget: Optional[Union[Widget, Type[Widget]]] = ...,
         label: Optional[Any] = ...,

django-stubs/forms/models.pyi

@@ -1,5 +1,21 @@
 from datetime import datetime
-from typing import Any, Callable, Dict, Iterator, List, Mapping, MutableMapping, Optional, Sequence, Tuple, Type, Union
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+    ClassVar,
+    Container,
+    TypeVar,
+)
 from unittest.mock import MagicMock
 from uuid import UUID
 
@@ -24,6 +40,11 @@ _Fields = Union[List[Union[Callable, str]], Sequence[str], Literal["__all__"]]
 _Labels = Dict[str, str]
 _ErrorMessages = Dict[str, Dict[str, str]]
 
+_M = TypeVar("_M", bound=Model)
+
+def construct_instance(
+    form: BaseForm, instance: _M, fields: Optional[Container[str]] = ..., exclude: Optional[Container[str]] = ...
+) -> _M: ...
 def model_to_dict(
     instance: Model, fields: Optional[_Fields] = ..., exclude: Optional[_Fields] = ...
 ) -> Dict[str, Any]: ...
@@ -76,7 +97,8 @@ class BaseModelForm(BaseForm):
     save_m2m: Any = ...
     def save(self, commit: bool = ...) -> Any: ...
 
-class ModelForm(BaseModelForm): ...
+class ModelForm(BaseModelForm, metaclass=ModelFormMetaclass):
+    base_fields: ClassVar[Dict[str, Field]] = ...
 
 def modelform_factory(
     model: Type[Model],

django-stubs/views/generic/edit.pyi

@@ -1,11 +1,12 @@
 from typing import Any, Callable, Dict, Optional, Sequence, Type, Union
 
 from django.forms.forms import BaseForm
-from django.http import HttpRequest, HttpResponse
 from django.views.generic.base import ContextMixin, TemplateResponseMixin, View
 from django.views.generic.detail import BaseDetailView, SingleObjectMixin, SingleObjectTemplateResponseMixin
 from typing_extensions import Literal
 
+from django.http import HttpRequest, HttpResponse
+
 class FormMixin(ContextMixin):
     initial: Dict[str, Any] = ...
     form_class: Optional[Type[BaseForm]] = ...

mypy.ini

@@ -1 +1,2 @@
 [mypy]
+warn_unused_ignores = True

mypy_django_plugin/lib/fullnames.py

@@ -23,9 +23,7 @@ FORM_MIXIN_CLASS_FULLNAME = 'django.views.generic.edit.FormMixin'
 
 MANAGER_CLASSES = {
     MANAGER_CLASS_FULLNAME,
-    RELATED_MANAGER_CLASS,
     BASE_MANAGER_CLASS_FULLNAME,
-    # QUERYSET_CLASS_FULLNAME
 }
 
 RELATED_FIELDS_CLASSES = {

mypy_django_plugin/lib/helpers.py

@@ -327,6 +327,19 @@ def _prepare_new_method_arguments(node: FuncDef) -> Tuple[List[Argument], MypyTy
 def copy_method_to_another_class(ctx: ClassDefContext, self_type: Instance,
                                  new_method_name: str, method_node: FuncDef) -> None:
     arguments, return_type = _prepare_new_method_arguments(method_node)
+
+    semanal_api = get_semanal_api(ctx)
+    for argument in arguments:
+        if argument.type_annotation is not None:
+            argument.type_annotation = semanal_api.anal_type(argument.type_annotation,
+                                                             allow_placeholder=True)
+
+    if return_type is not None:
+        ret = semanal_api.anal_type(return_type,
+                                    allow_placeholder=True)
+        assert ret is not None
+        return_type = ret
+
     add_method(ctx,
                new_method_name,
                args=arguments,

mypy_django_plugin/transformers/managers.py

@@ -1,18 +1,20 @@
 from mypy.nodes import (
-    GDEF, FuncDef, MemberExpr, NameExpr, StrExpr, SymbolTableNode, TypeInfo,
+    GDEF, FuncDef, MemberExpr, NameExpr, RefExpr, StrExpr, SymbolTableNode, TypeInfo,
 )
 from mypy.plugin import ClassDefContext, DynamicClassDefContext
 from mypy.types import AnyType, Instance, TypeOfAny
 
-from mypy_django_plugin.lib import helpers
+from mypy_django_plugin.lib import fullnames, helpers
 
 
 def create_new_manager_class_from_from_queryset_method(ctx: DynamicClassDefContext) -> None:
     semanal_api = helpers.get_semanal_api(ctx)
 
-    assert isinstance(ctx.call.callee, MemberExpr)
-    assert isinstance(ctx.call.callee.expr, NameExpr)
-    base_manager_info = ctx.call.callee.expr.node
+    callee = ctx.call.callee
+    assert isinstance(callee, MemberExpr)
+    assert isinstance(callee.expr, RefExpr)
+
+    base_manager_info = callee.expr.node
     if base_manager_info is None:
         if not semanal_api.final_iteration:
             semanal_api.defer()
@@ -63,9 +65,13 @@ def create_new_manager_class_from_from_queryset_method(ctx: DynamicClassDefConte
     class_def_context = ClassDefContext(cls=new_manager_info.defn,
                                         reason=ctx.call, api=semanal_api)
     self_type = Instance(new_manager_info, [])
-    for name, sym in derived_queryset_info.names.items():
-        if isinstance(sym.node, FuncDef):
-            helpers.copy_method_to_another_class(class_def_context,
-                                                 self_type,
-                                                 new_method_name=name,
-                                                 method_node=sym.node)
+    # we need to copy all methods in MRO before django.db.models.query.QuerySet
+    for class_mro_info in derived_queryset_info.mro:
+        if class_mro_info.fullname == fullnames.QUERYSET_CLASS_FULLNAME:
+            break
+        for name, sym in class_mro_info.names.items():
+            if isinstance(sym.node, FuncDef):
+                helpers.copy_method_to_another_class(class_def_context,
+                                                     self_type,
+                                                     new_method_name=name,
+                                                     method_node=sym.node)

mypy_django_plugin/transformers/models.py

@@ -1,4 +1,4 @@
-from typing import Dict, Optional, Type, cast
+from typing import Dict, List, Optional, Type, cast
 
 from django.db.models.base import Model
 from django.db.models.fields import DateField, DateTimeField
@@ -58,6 +58,12 @@ class ModelClassInitializer:
                                      name=name,
                                      sym_type=typ)
 
+    def add_new_class_for_current_module(self, name: str, bases: List[Instance]) -> TypeInfo:
+        current_module = self.api.modules[self.model_classdef.info.module_name]
+        new_class_info = helpers.add_new_class_for_module(current_module,
+                                                          name=name, bases=bases)
+        return new_class_info
+
     def run(self) -> None:
         model_cls = self.django_context.get_model_class_by_fullname(self.model_classdef.fullname)
         if model_cls is None:
@@ -144,7 +150,7 @@ class AddManagers(ModelClassInitializer):
         return False
 
     def is_any_parametrized_manager(self, typ: Instance) -> bool:
-        return typ.type.fullname == fullnames.MANAGER_CLASS_FULLNAME and isinstance(typ.args[0], AnyType)
+        return typ.type.fullname in fullnames.MANAGER_CLASSES and isinstance(typ.args[0], AnyType)
 
     def get_generated_manager_mappings(self, base_manager_fullname: str) -> Dict[str, str]:
         base_manager_info = self.lookup_typeinfo(base_manager_fullname)
@@ -164,14 +170,12 @@ class AddManagers(ModelClassInitializer):
                                                                [Instance(self.model_classdef.info, [])])
             bases.append(original_base)
 
-        current_module = self.api.modules[self.model_classdef.info.module_name]
-        custom_manager_info = helpers.add_new_class_for_module(current_module,
-                                                               name=name, bases=bases)
+        new_manager_info = self.add_new_class_for_current_module(name, bases)
         # copy fields to a new manager
-        new_cls_def_context = ClassDefContext(cls=custom_manager_info.defn,
+        new_cls_def_context = ClassDefContext(cls=new_manager_info.defn,
                                               reason=self.ctx.reason,
                                               api=self.api)
-        custom_manager_type = Instance(custom_manager_info, [Instance(self.model_classdef.info, [])])
+        custom_manager_type = Instance(new_manager_info, [Instance(self.model_classdef.info, [])])
 
         for name, sym in base_manager_info.names.items():
             # replace self type with new class, if copying method
@@ -185,10 +189,10 @@ class AddManagers(ModelClassInitializer):
             new_sym = sym.copy()
             if isinstance(new_sym.node, Var):
                 new_var = Var(name, type=sym.type)
-                new_var.info = custom_manager_info
-                new_var._fullname = custom_manager_info.fullname + '.' + name
+                new_var.info = new_manager_info
+                new_var._fullname = new_manager_info.fullname + '.' + name
                 new_sym.node = new_var
-            custom_manager_info.names[name] = new_sym
+            new_manager_info.names[name] = new_sym
 
         return custom_manager_type
 
@@ -268,15 +272,30 @@ class AddRelatedManagers(ModelClassInitializer):
 
             if isinstance(relation, (ManyToOneRel, ManyToManyRel)):
                 try:
-                    manager_info = self.lookup_typeinfo_or_incomplete_defn_error(fullnames.RELATED_MANAGER_CLASS)
+                    related_manager_info = self.lookup_typeinfo_or_incomplete_defn_error(fullnames.RELATED_MANAGER_CLASS)  # noqa: E501
+                    if 'objects' not in related_model_info.names:
+                        raise helpers.IncompleteDefnException()
                 except helpers.IncompleteDefnException as exc:
                     if not self.api.final_iteration:
                         raise exc
                     else:
                         continue
-                self.add_new_node_to_model_class(attname,
-                                                 Instance(manager_info, [Instance(related_model_info, [])]))
-                continue
+
+                # create new RelatedManager subclass
+                parametrized_related_manager_type = Instance(related_manager_info,
+                                                             [Instance(related_model_info, [])])
+                default_manager_type = related_model_info.names['objects'].type
+                if (default_manager_type is None
+                        or not isinstance(default_manager_type, Instance)
+                        or default_manager_type.type.fullname == fullnames.MANAGER_CLASS_FULLNAME):
+                    self.add_new_node_to_model_class(attname, parametrized_related_manager_type)
+                    continue
+
+                name = related_model_cls.__name__ + '_' + 'RelatedManager'
+                bases = [parametrized_related_manager_type, default_manager_type]
+                new_related_manager_info = self.add_new_class_for_current_module(name, bases)
+
+                self.add_new_node_to_model_class(attname, Instance(new_related_manager_info, []))
 
 
 class AddExtraFieldMethods(ModelClassInitializer):

scripts/enabled_test_modules.py

@@ -3,7 +3,7 @@
 import re
 
 IGNORED_MODULES = {'schema', 'gis_tests', 'admin_widgets', 'admin_filters',
-                   'sitemaps_tests', 'staticfiles_tests', 'modeladmin', 'model_forms',
+                   'sitemaps_tests', 'staticfiles_tests', 'modeladmin',
                    'generic_views', 'forms_tests', 'flatpages_tests',
                    'admin_ordering', 'admin_changelist', 'admin_views',
                    'invalid_models_tests', 'i18n', 'model_formsets',
@@ -178,7 +178,6 @@ IGNORED_ERRORS = {
     ],
     'files': [
         'Incompatible types in assignment (expression has type "IOBase", variable has type "File")',
-        'Argument 1 to "write" of "SpooledTemporaryFile"',
     ],
     'filtered_relation': [
         'has no attribute "name"',
@@ -231,13 +230,8 @@ IGNORED_ERRORS = {
     ],
     'mail': [
         'List item 1 has incompatible type "None"; expected "str"',
-        'Argument 1 to "push" of "SMTPChannel" has incompatible type "str"; expected "bytes"',
-        'Value of type "Union[List[Message], str, bytes, None]" is not indexable',
         'Incompatible types in assignment '
         + '(expression has type "bool", variable has type "Union[SMTP_SSL, SMTP, None]")',
-        re.compile(
-            r'Item "(int|str)" of "Union\[Message, str, int, Any\]" has no attribute "(get_content_type|get_filename)"'
-        )
     ],
     'messages_tests': [
         'List item 0 has incompatible type "Dict[str, Message]"; expected "Message"',
@@ -248,7 +242,7 @@ IGNORED_ERRORS = {
         re.compile(r'"(HttpRequest|WSGIRequest)" has no attribute'),
     ],
     'many_to_many': [
-        '(expression has type "List[Article]", variable has type "RelatedManager[Article]"',
+        '(expression has type "List[Article]", variable has type "Article_RelatedManager2',
         '"add" of "RelatedManager" has incompatible type "Article"; expected "Union[Publication, int]"',
     ],
     'many_to_one': [
@@ -271,7 +265,7 @@ IGNORED_ERRORS = {
         '"Manager[Any]" has no attribute "args"',
         'Dict entry 0 has incompatible type "Any"',
         'Argument 1 to "append" of "list" has incompatible type',
-        'base class "Model" defined the type as "Manager[Any]"',
+        'base class "Model" defined the type as "BaseManager[Any]"',
         'Argument 1 to "RunPython" has incompatible type "str"',
 
     ],
@@ -283,6 +277,14 @@ IGNORED_ERRORS = {
         'Incompatible type for "size" of "FloatModel" (got "object", expected "Union[float, int, str, Combinable]")',
         'Incompatible type for "value" of "IntegerModel" (got "object", expected',
     ],
+    'model_forms': [
+        '"render" of "Widget"',
+        "Module 'django.core.validators' has no attribute 'ValidationError'",
+        'Incompatible types in assignment',
+        'NewForm',
+        '"type" has no attribute "base_fields"',
+        'Argument "instance" to "InvalidModelForm" has incompatible type "Type[Category]"',
+    ],
     'model_indexes': [
         'Argument "condition" to "Index" has incompatible type "str"; expected "Optional[Q]"'
     ],
@@ -312,9 +314,6 @@ IGNORED_ERRORS = {
     'model_enums': [
         "'bool' is not a valid base class",
     ],
-    'multiple_database': [
-        'Unexpected attribute "extra_arg" for model "Book"'
-    ],
     'null_queries': [
         "Cannot resolve keyword 'foo' into field"
     ],

scripts/typecheck_tests.py

@@ -14,8 +14,8 @@ from scripts.enabled_test_modules import (
 )
 
 DJANGO_COMMIT_REFS: Dict[str, Tuple[str, str]] = {
-    '2.2': ('stable/2.2.x', 'e8b0903976077b951795938b260211214ed7fe41'),
-    '3.0': ('stable/3.0.x', '7ec5962638144cbf4c2e47ea7d8dc02d1ce44394')
+    '2.2': ('stable/2.2.x', '86befcc172c23170a720b3e0c06db51a99b3da59'),
+    '3.0': ('stable/3.0.x', '6cb30414bc0f83b49afc4cae76d4af5656effe9a')
 }
 PROJECT_DIRECTORY = Path(__file__).parent.parent
 DJANGO_SOURCE_DIRECTORY = PROJECT_DIRECTORY / 'django-sources'  # type: Path

setup.py

@@ -21,14 +21,14 @@ with open('README.md', 'r') as f:
     readme = f.read()
 
 dependencies = [
-    'mypy>=0.750,<0.760',
+    'mypy>=0.760,<0.770',
     'typing-extensions',
     'django',
 ]
 
 setup(
     name="django-stubs",
-    version="1.3.1",
+    version="1.4.0",
     description='Mypy stubs for Django',
     long_description=readme,
     long_description_content_type='text/markdown',

test-data/typecheck/fields/test_related.yml

@@ -648,3 +648,27 @@
                         abstract = True
                 class User(AbstractUser):
                     pass
+
+
+-   case: related_manager_is_a_subclass_of_default_manager
+    main: |
+        from myapp.models import User
+        reveal_type(User().orders)  # N: Revealed type is 'myapp.models.Order_RelatedManager'
+        reveal_type(User().orders.get())  # N: Revealed type is 'myapp.models.Order*'
+        reveal_type(User().orders.manager_method())  # N: Revealed type is 'builtins.int'
+    installed_apps:
+        - myapp
+    files:
+        -   path: myapp/__init__.py
+        -   path: myapp/models.py
+            content: |
+                from django.db import models
+                class User(models.Model):
+                    pass
+                class OrderManager(models.Manager):
+                    def manager_method(self) -> int:
+                        pass
+                class Order(models.Model):
+                    objects = OrderManager()
+                    user = models.ForeignKey(to=User, on_delete=models.CASCADE, related_name='orders')
+

test-data/typecheck/managers/querysets/test_from_queryset.yml

@@ -1,4 +1,48 @@
--   case: test_from_queryset_returns_intersection_of_manager_and_queryset
+-   case: from_queryset_with_base_manager
+    main: |
+        from myapp.models import MyModel
+        reveal_type(MyModel().objects)  # N: Revealed type is 'myapp.models.MyModel_NewManager[myapp.models.MyModel]'
+        reveal_type(MyModel().objects.get())  # N: Revealed type is 'myapp.models.MyModel*'
+        reveal_type(MyModel().objects.queryset_method())  # N: Revealed type is 'builtins.str'
+    installed_apps:
+        - myapp
+    files:
+        -   path: myapp/__init__.py
+        -   path: myapp/models.py
+            content: |
+                from django.db import models
+                from django.db.models.manager import BaseManager
+
+                class ModelQuerySet(models.QuerySet):
+                    def queryset_method(self) -> str:
+                        return 'hello'
+                NewManager = BaseManager.from_queryset(ModelQuerySet)
+                class MyModel(models.Model):
+                    objects = NewManager()
+
+-   case: from_queryset_with_manager
+    main: |
+        from myapp.models import MyModel
+        reveal_type(MyModel().objects)  # N: Revealed type is 'myapp.models.MyModel_NewManager[myapp.models.MyModel]'
+        reveal_type(MyModel().objects.get())  # N: Revealed type is 'myapp.models.MyModel*'
+        reveal_type(MyModel().objects.queryset_method())  # N: Revealed type is 'builtins.str'
+    installed_apps:
+        - myapp
+    files:
+        -   path: myapp/__init__.py
+        -   path: myapp/models.py
+            content: |
+                from django.db import models
+
+                class ModelQuerySet(models.QuerySet):
+                    def queryset_method(self) -> str:
+                        return 'hello'
+
+                NewManager = models.Manager.from_queryset(ModelQuerySet)
+                class MyModel(models.Model):
+                    objects = NewManager()
+
+-   case: from_queryset_returns_intersection_of_manager_and_queryset
     main: |
         from myapp.models import MyModel, NewManager
         reveal_type(NewManager())  # N: Revealed type is 'myapp.models.NewManager'
@@ -24,7 +68,7 @@
                 class MyModel(models.Model):
                     objects = NewManager()
 
--   case: test_from_queryset_with_class_name_provided
+-   case: from_queryset_with_class_name_provided
     main: |
         from myapp.models import MyModel, NewManager
         reveal_type(NewManager())  # N: Revealed type is 'myapp.models.NewManager'
@@ -50,3 +94,55 @@
                 class MyModel(models.Model):
                     objects = NewManager()
 
+-   case: from_queryset_with_class_inheritance
+    main: |
+        from myapp.models import MyModel
+        reveal_type(MyModel().objects)  # N: Revealed type is 'myapp.models.MyModel_NewManager[myapp.models.MyModel]'
+        reveal_type(MyModel().objects.get())  # N: Revealed type is 'myapp.models.MyModel*'
+        reveal_type(MyModel().objects.queryset_method())  # N: Revealed type is 'builtins.str'
+    installed_apps:
+        - myapp
+    files:
+        - path: myapp/__init__.py
+        - path: myapp/models.py
+          content: |
+              from django.db import models
+              from django.db.models.manager import BaseManager
+              class BaseQuerySet(models.QuerySet):
+                  def queryset_method(self) -> str:
+                      return 'hello'
+              class ModelQuerySet(BaseQuerySet):
+                  pass
+
+              NewManager = BaseManager.from_queryset(ModelQuerySet)
+              class MyModel(models.Model):
+                  objects = NewManager()
+
+-   case: from_queryset_with_manager_in_another_directory_and_imports
+    main: |
+        from myapp.models import MyModel
+        reveal_type(MyModel().objects)  # N: Revealed type is 'myapp.models.MyModel_NewManager[myapp.models.MyModel]'
+        reveal_type(MyModel().objects.get())  # N: Revealed type is 'myapp.models.MyModel*'
+        reveal_type(MyModel().objects.queryset_method)  # N: Revealed type is 'def (param: Union[builtins.str, None] =) -> Union[builtins.str, None]'
+        reveal_type(MyModel().objects.queryset_method('str'))  # N: Revealed type is 'Union[builtins.str, None]'
+    installed_apps:
+        - myapp
+    files:
+        -   path: myapp/__init__.py
+        -   path: myapp/models.py
+            content: |
+                from django.db import models
+                from myapp.managers import NewManager
+
+                class MyModel(models.Model):
+                    objects = NewManager()
+        -   path: myapp/managers.py
+            content: |
+                from typing import Optional
+                from django.db import models
+
+                class ModelQuerySet(models.QuerySet):
+                    def queryset_method(self, param: Optional[str] = None) -> Optional[str]:
+                        return param
+
+                NewManager = models.Manager.from_queryset(ModelQuerySet)

test-data/typecheck/managers/test_managers.yml

@@ -48,7 +48,7 @@
                 class Base(Generic[_T]):
                     def __init__(self, model_cls: Type[_T]):
                         self.model_cls = model_cls
-                        reveal_type(self.model_cls._default_manager)  # N: Revealed type is 'django.db.models.manager.Manager[django.db.models.base.Model]'
+                        reveal_type(self.model_cls._default_manager)  # N: Revealed type is 'django.db.models.manager.BaseManager[django.db.models.base.Model]'
                 class MyModel(models.Model):
                     pass
                 class Child(Base[MyModel]):