add django-stubs as a dependency, fix pyright and mypy type checking issues

Author: bckohan

.github/workflows/lint.yml

@@ -25,7 +25,8 @@ jobs:
         uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
-
+      - name: Run pyright
+        uses: jakebailey/pyright-action@v2
       - name: Install Poetry
         uses: snok/install-poetry@v1
         with:
@@ -43,6 +44,7 @@ jobs:
           poetry run black django_typer --check
           poetry run pylint django_typer
           poetry run mypy django_typer
+          pyright django_typer
           poetry check
           poetry run pip check
           poetry run python -m readme_renderer ./README.rst -o /tmp/README.html

CONTRIBUTING.rst

@@ -8,6 +8,7 @@
 .. _readthedocs: https://readthedocs.org/
 .. _me: https://github.com/bckohan
 .. _black: https://black.readthedocs.io/en/stable/
+.. _pyright: https://github.com/microsoft/pyright
 
 Contributing
 ############
@@ -51,7 +52,7 @@ then run Sphinx_:
 Static Analysis
 ---------------
 
-`django-typer` uses Pylint_ for python linting and mypy_ for static type
+`django-typer` uses Pylint_ for python linting and mypy_ and pyright_ for static type
 checking. Header imports are also standardized using isort_ and formatting is
 done with black_. Before any PR is accepted the following must be run, and
 static analysis tools should not produce any errors or warnings. Disabling
@@ -63,6 +64,7 @@ certain errors or warnings where justified is acceptable:
     poetry run black django_typer
     poetry run pylint django_typer
     poetry run mypy django_typer
+    pyright django_typer
     poetry check
     poetry run pip check
     poetry run python -m readme_renderer ./README.rst

django_typer/__init__.py

@@ -76,6 +76,7 @@
 from django.core.management import get_commands
 from django.core.management.base import BaseCommand, CommandError
 from django.core.management.base import OutputWrapper as BaseOutputWrapper
+from django.core.management.color import Style as ColorStyle
 from django.db.models import Model
 from django.utils.translation import gettext as _
 
@@ -94,9 +95,16 @@
 
 from .completers import ModelObjectCompleter
 from .parsers import ModelObjectParser
-from .types import ForceColor, NoColor, PythonPath, Settings, SkipChecks
-from .types import Style as ColorStyle
-from .types import Traceback, Verbosity, Version
+from .types import (
+    ForceColor,
+    NoColor,
+    PythonPath,
+    Settings,
+    SkipChecks,
+    Traceback,
+    Verbosity,
+    Version,
+)
 from .utils import _command_context, traceback_config, with_typehint
 
 VERSION = (1, 0, 1)
@@ -1671,19 +1679,20 @@ def command2(self, option: t.Optional[str] = None):
     style: ColorStyle
     stdout: BaseOutputWrapper
     stderr: BaseOutputWrapper
-    requires_system_checks: t.Union[t.Sequence[str], str]
+    # requires_system_checks: t.Union[t.List[str], t.Tuple[str, ...], t.Literal['__all__']]
 
     # we do not use verbosity because the base command does not do anything with it
     # if users want to use a verbosity flag like the base django command adds
     # they can use the type from django_typer.types.Verbosity
-    suppressed_base_arguments: t.Optional[t.Iterable[str]] = {"verbosity"}
+    suppressed_base_arguments = {"verbosity"}
 
     typer_app: Typer
     no_color: bool = False
     force_color: bool = False
     _num_commands: int = 0
     _has_callback: bool = False
     _root_groups: int = 0
+    _handle: t.Callable[..., t.Any]
 
     command_tree: CommandNode
 
@@ -1701,8 +1710,8 @@ def __exit__(self, exc_type, exc_val, exc_tb):
 
     def __init__(
         self,
-        stdout: t.Optional[t.IO[str]] = None,
-        stderr: t.Optional[t.IO[str]] = None,
+        stdout: t.Optional[t.TextIO] = None,
+        stderr: t.Optional[t.TextIO] = None,
         no_color: bool = no_color,
         force_color: bool = force_color,
         **kwargs,
@@ -1795,7 +1804,9 @@ def __init_subclass__(cls, **_):
         """Avoid passing typer arguments up the subclass init chain"""
         return super().__init_subclass__()
 
-    def create_parser(self, prog_name: str, subcommand: str, **_):
+    def create_parser(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, prog_name: str, subcommand: str, **_
+    ):
         """
         Create a parser for this command. This also sets the command
         context, so any functions below this call on the stack may
@@ -1862,7 +1873,7 @@ def handle(self, option1: bool, option2: bool):
         :param kwargs: the options to directly pass to handle()
         """
         with self:
-            if getattr(self, "_handle", None):
+            if getattr(self, "_handle", None) and callable(self._handle):
                 return self._handle(*args, **kwargs)
             raise NotImplementedError(
                 _(

django_typer/apps.py

@@ -62,7 +62,7 @@ def check_traceback_config(app_configs, **kwargs) -> t.List[CheckMessage]:
     A system check that validates that the traceback config is valid and
     contains only the expected parameters.
     """
-    warnings = []
+    warnings: t.List[CheckMessage] = []
     tb_cfg = traceback_config()
     if isinstance(tb_cfg, dict):
         if rich:

django_typer/completers.py

@@ -255,7 +255,9 @@ def __init__(
         distinct: bool = distinct,
     ):
         self.model_cls = model_cls
-        self.lookup_field = lookup_field or model_cls._meta.pk.name
+        self.lookup_field = str(
+            lookup_field or getattr(self.model_cls._meta.pk, "name", "id")
+        )
         self.help_field = help_field
         self.limit = limit
         self.case_insensitive = case_insensitive
@@ -322,9 +324,9 @@ def __call__(
                 ],
                 help=getattr(obj, self.help_field, None) if self.help_field else "",
             )
-            for obj in self.model_cls.objects.filter(completion_qry).distinct()[
-                0 : self.limit
-            ]
+            for obj in getattr(self.model_cls, "objects")
+            .filter(completion_qry)
+            .distinct()[0 : self.limit]
             if (
                 getattr(obj, self.lookup_field) is not None
                 and str(getattr(obj, self.lookup_field))

django_typer/parsers.py

@@ -27,9 +27,9 @@
 
 from click import Context, Parameter, ParamType
 from django.apps import AppConfig, apps
-from django.core.exceptions import ObjectDoesNotExist
+from django.contrib.contenttypes.fields import GenericForeignKey
 from django.core.management import CommandError
-from django.db.models import Field, Model, UUIDField
+from django.db.models import Field, ForeignObjectRel, Model, UUIDField
 from django.utils.translation import gettext as _
 
 from django_typer.completers import ModelObjectCompleter
@@ -71,7 +71,7 @@ def handle(
         If not provided, a CommandError will be raised.
     """
 
-    error_handler = t.Callable[[t.Type[Model], str, ObjectDoesNotExist], None]
+    error_handler = t.Callable[[t.Type[Model], str, Exception], None]
 
     model_cls: t.Type[Model]
     lookup_field: str
@@ -84,11 +84,6 @@ def handle(
 
     __name__ = "ModelObjectParser"  # typer internals expect this
 
-    @property
-    def name(self):
-        """Descriptive name of the model object."""
-        return self.model_cls._meta.verbose_name
-
     def __init__(
         self,
         model_cls: t.Type[Model],
@@ -97,12 +92,23 @@ def __init__(
         on_error: t.Optional[error_handler] = on_error,
     ):
         self.model_cls = model_cls
-        self.lookup_field = lookup_field or model_cls._meta.pk.name
+        self.lookup_field = str(
+            lookup_field or getattr(self.model_cls._meta.pk, "name", "id")
+        )
         self.on_error = on_error
         self.case_insensitive = case_insensitive
-        self._field = self.model_cls._meta.get_field(self.lookup_field)
+        field = self.model_cls._meta.get_field(self.lookup_field)
+        assert not isinstance(field, (ForeignObjectRel, GenericForeignKey)), _(
+            "{cls} is not a supported lookup field."
+        ).format(cls=self._field.__class__.__name__)
+        self._field = field
         if self.case_insensitive and "iexact" in self._field.get_lookups():
             self._lookup = "__iexact"
+        self.name = (
+            str(self.model_cls._meta.verbose_name)
+            if self.model_cls._meta.verbose_name
+            else self.model_cls.__name__
+        )
 
     def convert(
         self, value: t.Any, param: t.Optional[Parameter], ctx: t.Optional[Context]
@@ -134,7 +140,7 @@ def convert(
             )
         except (self.model_cls.DoesNotExist, ValueError) as err:
             if self.on_error:
-                return self.on_error(self.model_cls, value, err)
+                return self.on_error(self.model_cls, str(value), err)
             raise CommandError(
                 _('{model} "{value}" does not exist!').format(
                     model=self.model_cls.__name__, value=value

django_typer/types.py

@@ -6,15 +6,14 @@
 
 import sys
 from pathlib import Path
-from typing import Any, Callable, Optional, cast
+from typing import Optional, cast
 
 if sys.version_info < (3, 9):
     from typing_extensions import Annotated
 else:
     from typing import Annotated
 
 from django.core.management import CommandError
-from django.core.management.color import Style as ColorStyle
 from django.utils.translation import gettext_lazy as _
 from typer import Option
 
@@ -216,28 +215,3 @@ def handle(self, verbosity: Verbosity = 1):
 The --skip-checks option is included by default and behaves the same as on BaseCommand_ use it to
 skip system checks.
 """
-
-
-class Style(ColorStyle):
-    """
-    For type hinting.
-    """
-
-    ERROR: Callable[[Any], str]
-    ERROR_OUTPUT: Callable[[Any], str]
-    HTTP_BAD_REQUEST: Callable[[Any], str]
-    HTTP_INFO: Callable[[Any], str]
-    HTTP_NOT_FOUND: Callable[[Any], str]
-    HTTP_NOT_MODIFIED: Callable[[Any], str]
-    HTTP_REDIRECT: Callable[[Any], str]
-    HTTP_SERVER_ERROR: Callable[[Any], str]
-    HTTP_SUCCESS: Callable[[Any], str]
-    MIGRATE_HEADING: Callable[[Any], str]
-    MIGRATE_LABEL: Callable[[Any], str]
-    NOTICE: Callable[[Any], str]
-    SQL_COLTYPE: Callable[[Any], str]
-    SQL_FIELD: Callable[[Any], str]
-    SQL_KEYWORD: Callable[[Any], str]
-    SQL_TABLE: Callable[[Any], str]
-    SUCCESS: Callable[[Any], str]
-    WARNING: Callable[[Any], str]

pyproject.toml

@@ -86,6 +86,7 @@ scipy = [
     { version = ">=1.11", markers = "python_version > '3.8'" },
     { version = "<=1.10", markers = "python_version <= '3.8'" },
 ]
+django-stubs = "^4.2.7"
 
 [tool.poetry.extras]
 rich = ["rich"]