How to overload method(*args) to return diff type when args is empty?

[Kache]

I'm aware of overloads based on value of positional/keyword args, e.g.:

    @overload
    def one(self, row: Literal['dict']) -> Dict[str, Any] | None: ...
    @overload
    def one(self, row: Literal['tuple']) -> Tuple[Any, ...] | None: ...
    @overload
    def one(self, row: None = ...) -> Tuple[Any, ...] | None: ...

    def one(self, row: Literal['tuple', 'dict'] | None = 'tuple'):
        # implementation

How do to similar, but based on whether *args is empty or not? e.g.:

    @overload
    def one(self) -> Iterator[Resource]: ...

    # something like this?
    @overload
    def one(self, at_least_one: str, *maybe_more: str) -> Iterator[Tuple[Resource, ...]]]: ...

    # or?
    @overload
    def one(self, *resource_names: str) -> Iterator[Tuple[Resource, ...]]]: ...

    def one(self, *resource_names: str):
        # implementation

Actually it half works? Doesn't complain for one but does complain for rows:

[erictraut]

If you have the ability to change the interface to this function (e.g. refactor it into two calls), that's what I'd recommend. This sort of polymorphism will not work well with static typing.

If you're stuck with the existing interface definition, then this is probably the best approach:

@overload
def one(self, *names: str) -> Iterator[Tuple[Resource, ...]]: ...

[erictraut]

The error you're seeing is about the overload implementation. If you include a proper return type annotation on the implementation, this error should go away. Without a return type annotation, pyright is doing its best to infer the return type, but the resulting type isn't compatible with the overloads.

[Kache]

I see, yeah it seems that for callers of these methods, the type hinting actually works as intended, so I can just # type: ignore that one line

[Kache]

OH, I see, this works:

    def rows(self, *resources: str) -> Iterator[Any | Tuple[Any, ...]]: