How to correctly override parse_args?

[ostr00000]

Consider this code

pyright_override.py

import argparse


class MyArgumentParser(argparse.ArgumentParser):
    def parse_args(self, args=None, namespace=None):
        return super().parse_args(args, namespace)

Error

This command PYRIGHT_PYTHON_FORCE_VERSION=1.1.338 pyright ./pyright_override.py returns no problems.
But this PYRIGHT_PYTHON_FORCE_VERSION=1.1.339 pyright ./pyright_override.py complain:

 error: Method "parse_args" overrides class "ArgumentParser" in an incompatible manner
    Parameter "namespace" is missing in override (reportIncompatibleMethodOverride)

Problem

I believe this is the cause of the new default mode that have enabled reportIncompatibleMethodOverride by default.

I am not sure what is wrong here:
a) the code? Should I add type annotations? Do I have to write all overload from base class?
b) is this error in typeshed?
c) maybe pyright problem?

[Eric Traut (erictraut)]

This isn't a bug in pyright, nor is it a bug in typeshed.

Starting in pyright 1.1.339, the reportIncompatibleMethodOverride is enabled by default. If you don't want this rule to be enabled, you can disable it in your pyrightconfig.json or pyproject.toml file.

If you would like your code to be correct from a type checking perspective, you need to override the base class with a method signature that is compatible with the base class.

[ostr00000]

you need to override the base class with a method signature that is compatible with the base class.

I tried various way to annotate this, but I cannot find any solution without error. Could you show me how to do this for this specific example?

I tried to annotate this method using the same overloads as in typeshed,
but I always get at least one such error: Overloaded implementation is not consistent with signature of overload 1.

class MyArgumentParser(argparse.ArgumentParser):
    @overload
    def parse_args(
        self, args: Sequence[str] | None = None, namespace: None = None
    ) -> Namespace:
        ...

    @overload
    def parse_args(self, args: Sequence[str] | None, namespace: _N) -> _N:
        ...

    @overload
    def parse_args(self, *, namespace: _N) -> _N:
        ...

    def parse_args(self, args=None, namespace:_N=None) -> _N:
        return super().parse_args(args, namespace)

Question 2:

Does annotations on the implementation function (I mean function without @overload) can influence the typing result?
I would expect it should not have any impact, but it seems that I can annotate the implementation function in various way and the type checker result differs.

Similar example but other errors

class MyArgumentParser(argparse.ArgumentParser):
    @overload
    def parse_args(
        self, args: Sequence[str] | None = None, namespace: None = None
    ) -> Namespace:
        ...

    @overload
    def parse_args(self, args: Sequence[str] | None, namespace: _N) -> _N:
        ...

    @overload
    def parse_args(self, *, namespace: _N) -> _N:
        ...

    def parse_args(self, args=None, namespace: None = None):
        return super().parse_args(args, namespace)

The errors are:

• error: Overloaded implementation is not consistent with signature of overload 2
• error: Overloaded implementation is not consistent with signature of overload 3

I read Python docs and PEP 484. There is nothing about it, so I assume it is implementation detail?

[Eric Traut (erictraut)]

Here's a signature for the implementation that's compatible with your overloads.

    def parse_args(
        self, args: Sequence[str] | None = None, namespace: _N = None
    ) -> argparse.Namespace | _N:
        return super().parse_args(args, namespace)

Does annotations on the implementation function (I mean function without overload) can influence the typing result?

The overload signatures are used for evaluating calls to the function, and the implementation signature is used for type checking the implementation itself. If the implementation signature is not a "superset" of all of the overload signatures, then there's something wrong with one of the two.

[ostr00000]

Thanks! Indeed, now there is no error.

The overload signatures are used for evaluating calls to the function, and the implementation signature is used for type checking the implementation itself.

That explains me perfectly why there were errors. So if I want to have a fully typed function, the annotations must be on all overload and the implementation.

[Daniel Sperber (Daraan)]

I just ran into this problem as well. Having the an error with Parameter "namespace" is missing in override, when there is namespace=None in the re-definition is weird and I wonder what triggers the error. Is it because once it is a keyword-only parameter and once as a normal one?

    @overload
    def parse_known_args(self, args: Sequence[str] | None = None, namespace: None = None) -> tuple[Namespace, list[str]]: ...
    @overload
    def parse_known_args(self, args: Sequence[str] | None, namespace: _N) -> tuple[_N, list[str]]: ...
    @overload
    def parse_known_args(self, *, namespace: _N) -> tuple[_N, list[str]]: ...