Can it be a bug in the latest version of Pyright?

[rafrafek]

Pylance 2024.6.100 / Pyright version 1.1.367 produces an error with my code, but old Pyright 1.1.347 didn't see any issue here. Can it be a bug in the latest version of Pyright?

The error that shows over function foo_request:

error: Return type, "Generator[filter[Unknown], Any, None]", is partially unknown (reportUnknownParameterType)

The code:

import pytest
import responses

@pytest.fixture
def req_mock():
    with responses.RequestsMock() as mock:
        yield mock

@pytest.fixture
def foo_request(req_mock: responses.RequestsMock):
    req_mock.add(responses.GET, url="https://foo.example.com/123")
    yield filter(
        lambda r: r.request.url.startswith("https://foo.example.com"), req_mock.calls
    )

Python 3.12.3.

pip freeze:

certifi==2024.6.2
charset-normalizer==3.3.2
idna==3.7
iniconfig==2.0.0
packaging==24.1
pluggy==1.5.0
pytest==8.2.2
PyYAML==6.0.1
requests==2.32.3
responses==0.25.3
urllib3==2.2.2

Screenshot:

[erictraut]

I'm guessing that you have "strict" type checking mode enabled? The reportUnknownParameterType check is disabled by default in pyright.

Pyright 1.1.347 is quite old. The behavior with more recent versions looks correct to me. Let's simplify the code to see what's going on.

def test(req_mock: responses.RequestsMock):
    x = filter(lambda r: r.request.url.startswith(""), req_mock.calls)
    reveal_type(x) # filter[Unknown]

The problem stems from the fact that req_mock.calls is of type CallList, which derives from Sequence[Any]. That means a static type checker knows that CallList is iterable, but it doesn't know what type it is iterating over. And that, in turn, means that a call to filter is going to produce a value of type filter[Unknown]. I'm not sure why CallList uses Sequence[Any] as a base class rather than Sequence[Call]. You may want to ask the maintainers of the responses library.

[rafrafek]

Hello,
Yes, I have "strict" type checking mode enabled, I forgot to mention it 😅
I asked the maintainers about Sequence[Any] rather than Sequence[Call] here: getsentry/responses#722
Thank you!

[bschnurr]

passing a typeguard might work

import pytest
from responses import Call
import responses

from typing import List, Sequence, TypeGuard

def is_call_typeguard(call: Call) -> TypeGuard[Call]:
    """Check if the call is to the target URL."""
    if call.request.url is not None:
        return call.request.url.startswith("https://foo.example.com")
    return False

@pytest.fixture
def req_mock():
    with responses.RequestsMock() as mock:
        yield mock

@pytest.fixture
def foo_request(req_mock: responses.RequestsMock):
    req_mock.add(responses.GET, url="https://foo.example.com/123")
    yield filter(is_call_typeguard, req_mock.calls)

[rafrafek]

Hello,
Yes it works! It produces the correct return type for foo_request: Generator[filter[Call], Any, None].

Even without TypeGuard it gives a better return type, Generator[filter[Any], Any, None] instead of Generator[filter[Unknown], Any, None].

Thank you! I can't mark two replies as answers, but if I could I would do!