Summary

Comparing branches/commits:
Old: main (merge base) 3c229ae5
New: 20962/merge 75ee92f4
Lint Rule Removed Added Changed
Total 25 867 177
invalid-argument-type 0 262 84
invalid-assignment 0 280 15
invalid-return-type 0 180 10
possibly-missing-attribute 2 29 38
unresolved-attribute 0 45 1
unsupported-operator 0 30 12
unused-ignore-comment 21 0 0
no-matching-overload 0 17 0
not-iterable 0 5 9
index-out-of-bounds 0 13 0
non-subscriptable 0 2 6
possibly-missing-implicit-call 0 2 2
call-non-callable 0 1 0
missing-argument 0 1 0
possibly-unresolved-reference 1 0 0
type-assertion-failure 1 0 0

PyGithub (https://github.com/PyGithub/PyGithub)

github/Requester.py

[error] invalid-assignment - :1264:21 - Object of type `dict[str & ~Literal["Authorization"], str]` is not assignable to `dict[str, str]`

PyWinCtl (https://github.com/Kalmat/PyWinCtl)

src/pywinctl/_main.py

[error] invalid-assignment - :853:9 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: Literal[0], /) -> None, (key: slice[Any, Any, Any], value: Iterable[Literal[0]], /) -> None]` cannot be called with a key of type `Literal[0]` and a value of type `int` on object of type `list[Literal[0]]`
[error] invalid-assignment - :854:5 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: list[Literal[0]], /) -> None, (key: slice[Any, Any, Any], value: Iterable[list[Literal[0]]], /) -> None]` cannot be called with a key of type `Literal[0]` and a value of type `list[int]` on object of type `list[list[Literal[0]]]`
[error] invalid-assignment - :859:17 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: Literal[0], /) -> None, (key: slice[Any, Any, Any], value: Iterable[Literal[0]], /) -> None]` cannot be called with a key of type `int` and a value of type `Literal[1, 0]` on object of type `list[Literal[0]]`
[error] invalid-assignment - :865:17 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: Literal[0], /) -> None, (key: slice[Any, Any, Any], value: Iterable[Literal[0]], /) -> None]` cannot be called with a key of type `int` and a value of type `Literal[1]` on object of type `list[Literal[0]]`

Tanjun (https://github.com/FasterSpeeding/Tanjun)

tanjun/clients.py

[error] invalid-return-type - :3136:16 - Return type does not match returned value: expected `list[Path | str]`, found `list[str]`
[error] invalid-return-type - :3138:12 - Return type does not match returned value: expected `list[Path | str]`, found `list[Path]`

aiohttp (https://github.com/aio-libs/aiohttp)

aiohttp/client_middleware_digest_auth.py

[error] invalid-return-type - :134:12 - Return type does not match returned value: expected `dict[str, str]`, found `dict[Any & ~AlwaysFalsy, str | Any]`

aiortc (https://github.com/aiortc/aiortc)

src/aiortc/sdp.py

[error] invalid-argument-type - :446:52 -
Old: Argument is incorrect: Expected `str`, found `None | Unknown`
New: Argument is incorrect: Expected `str`, found `None | Unknown | str`

alerta (https://github.com/alerta/alerta)

alerta/commands.py

[error] invalid-argument-type - :73:13 - Argument to bound method `__init__` is incorrect: Expected `list[str]`, found `(list[Scope] & ~AlwaysFalsy) | list[Unknown | str]`

alerta/models/key.py

[error] invalid-argument-type - :52:13 - Argument to bound method `__init__` is incorrect: Expected `list[str]`, found `list[Scope]`
[error] invalid-argument-type - :90:13 - Argument to bound method `__init__` is incorrect: Expected `list[str]`, found `(list[Scope] & ~AlwaysFalsy) | (list[str] & ~AlwaysFalsy) | list[Unknown]`
[error] invalid-argument-type - :105:13 - Argument to bound method `__init__` is incorrect: Expected `list[str]`, found `list[Scope]`

altair (https://github.com/vega/altair)

altair/utils/core.py

[error] invalid-return-type - :287:12 - Return type does not match returned value: expected `dict[str, Any]`, found `Any | dict[Literal["type", "geometry"], Any]`

anyio (https://github.com/agronholm/anyio)

src/anyio/_core/_sockets.py

[error] invalid-argument-type - :385:56 -
Old: Argument to function `setup_raw_socket` is incorrect: Expected `tuple[str, int] | tuple[str, int, int, int]`, found `tuple[@Todo, int, @Todo]`
New: Argument to function `setup_raw_socket` is incorrect: Expected `tuple[str, int] | tuple[str, int, int, int]`, found `tuple[str, int, @Todo]`

apprise (https://github.com/caronc/apprise)

apprise/config/base.py

[error] unresolved-attribute - :1386:13 - Type `object` has no attribute `update`

apprise/plugins/email/base.py

[error] invalid-assignment - :1047:17 -
Old: Object of type `list[@Todo]` is not assignable to `set[Unknown] | None`
New: Object of type `list[str]` is not assignable to `set[Unknown] | None`

apprise/plugins/sparkpost.py

[error] invalid-assignment - :389:13 - Method `__setitem__` of type `bound method dict[Unknown & ~Literal["content"], Unknown].__setitem__(key: Unknown & ~Literal["content"], value: Unknown, /) -> None` cannot be called with a key of type `Literal["content"]` and a value of type `dict[Unknown & ~Literal["attachments"], Unknown]` on object of type `dict[Unknown & ~Literal["content"], Unknown]`
[error] invalid-argument-type - :394:13 - Method `__getitem__` of type `bound method dict[Unknown & ~Literal["content"], Unknown].__getitem__(key: Unknown & ~Literal["content"], /) -> Unknown` cannot be called with key of type `Literal["content"]` on object of type `dict[Unknown & ~Literal["content"], Unknown]`
[error] invalid-assignment - :394:13 - Method `__setitem__` of type `bound method dict[Unknown & ~Literal["attachments"], Unknown].__setitem__(key: Unknown & ~Literal["attachments"], value: Unknown, /) -> None` cannot be called with a key of type `Literal["attachments"]` and a value of type `list[dict[Unknown & ~Literal["data"], Unknown]]` on object of type `dict[Unknown & ~Literal["attachments"], Unknown]`

artigraph (https://github.com/artigraph/artigraph)

src/arti/types/pydantic.py

[error] no-matching-overload - :51:16 - No overload of function `create_model` matches arguments

arviz (https://github.com/arviz-devs/arviz)

arviz/data/io_emcee.py

[error] invalid-assignment - :175:13 - Method `__setitem__` of type `bound method dict[Unknown, OrderedDict[Unknown, Unknown]].__setitem__(key: Unknown, value: OrderedDict[Unknown, Unknown], /) -> None` cannot be called with a key of type `Unknown` and a value of type `Dataset` on object of type `dict[Unknown, OrderedDict[Unknown, Unknown]]`

arviz/stats/stats.py

[error] invalid-argument-type - :1560:39 - Argument to bound method `round` is incorrect: Expected `int | dict[@Todo, int] | Series`, found `dict[Unknown, Literal[3, 2, 0]]`

arviz/tests/base_tests/test_stats.py

[error] invalid-argument-type - :399:9 -
Old: Method `__getitem__` of type `bound method _LocIndexer[Unknown].__getitem__(key: Mapping[Any, Any]) -> Unknown` cannot be called with key of type `list[@Todo]` on object of type `_LocIndexer[Unknown]`
New: Method `__getitem__` of type `bound method _LocIndexer[Unknown].__getitem__(key: Mapping[Any, Any]) -> Unknown` cannot be called with key of type `list[Unknown & ~Literal["theta[Deerfield]"]]` on object of type `_LocIndexer[Unknown]`

arviz/tests/helpers.py

[error] invalid-argument-type - :203:9 - Argument to function `from_dict` is incorrect: Expected `int | None`, found `dict[Unknown | str, Unknown]`

doc/sphinxext/gallery_generator.py

[warning] possibly-missing-attribute - :386:17 -
Old: Attribute `append` on type `Unknown | None` may be missing
New: Attribute `append` on type `Unknown | list[Unknown] | None` may be missing
[warning] possibly-missing-attribute - :386:17 -
Old: Attribute `get` on type `Unknown | dict[@Todo, @Todo] | None` may be missing
New: Attribute `append` on type `Unknown | list[Unknown] | None` may be missing
[warning] possibly-missing-attribute - :386:17 - Attribute `get` on type `Unknown | dict[Unknown | str, list[Unknown]] | None` may be missing
[warning] possibly-missing-attribute - :389:17 -
Old: Attribute `append` on type `Unknown | None` may be missing
New: Attribute `append` on type `Unknown | list[Unknown] | None` may be missing
[warning] possibly-missing-attribute - :389:17 -
Old: Attribute `get` on type `Unknown | dict[@Todo, @Todo] | None` may be missing
New: Attribute `append` on type `Unknown | list[Unknown] | None` may be missing
[warning] possibly-missing-attribute - :389:17 - Attribute `get` on type `Unknown | dict[Unknown | str, list[Unknown]] | None` may be missing
[warning] possibly-missing-attribute - :401:30 -
Old: Attribute `items` on type `Unknown | dict[@Todo, @Todo] | None` may be missing
New: Attribute `items` on type `Unknown | dict[Unknown | str, list[Unknown]] | None` may be missing
[warning] possibly-missing-attribute - :408:30 -
Old: Attribute `items` on type `Unknown | dict[@Todo, @Todo] | None` may be missing
New: Attribute `items` on type `Unknown | dict[Unknown | str, list[Unknown]] | None` may be missing

attrs (https://github.com/python-attrs/attrs)

src/attr/_make.py

[error] unresolved-attribute - :2644:33 - Type `Attribute` has no attribute `name`
[error] unresolved-attribute - :2646:29 - Type `Attribute` has no attribute `hash`
[error] unresolved-attribute - :2646:40 - Type `Attribute` has no attribute `name`

black (https://github.com/psf/black)

src/black/cache.py

[error] invalid-assignment - :144:17 - Object of type `dict[Unknown, tuple[@Todo]]` is not assignable to `dict[str, tuple[int | float, int, str]]`

src/blib2to3/pgen2/parse.py

[error] invalid-return-type - :46:12 - Return type does not match returned value: expected `list[tuple[tuple[list[list[tuple[int, int]]], dict[int, int]], int, tuple[int, str | None, tuple[str, tuple[int, int]] | None, list[@Todo] | None]]]`, found `list[tuple[tuple[list[list[tuple[int, int]]], dict[int, int]], int, tuple[Literal[-1], None, None, None]]]`

bokeh (https://github.com/bokeh/bokeh)

src/bokeh/core/enums.py

[error] no-matching-overload - :261:5 - No overload of bound method `update` matches arguments

src/bokeh/core/has_props.py

[error] invalid-assignment - :790:5 - Object of type `list[type[Model] & ~<class 'DataModel'>]` is not assignable to `list[type[HasProps]]`

src/bokeh/layouts.py

[error] invalid-argument-type - :558:26 - Argument is incorrect: Expected `list[row | col]`, found `list[row]`
[error] invalid-argument-type - :384:9 -
Old: Argument is incorrect: Expected `Literal["normal", "grey"] | None`, found `@Todo | UndefinedType`
New: Argument is incorrect: Expected `Literal["normal", "grey"] | None`, found `Literal["normal", "grey"] | None | UndefinedType`
[error] invalid-argument-type - :385:9 -
Old: Argument is incorrect: Expected `bool`, found `@Todo | UndefinedType`
New: Argument is incorrect: Expected `bool`, found `bool | UndefinedType`

cki-lib (https://gitlab.com/cki-project/cki-lib)

cki_lib/owners.py

[error] invalid-return-type - :242:16 - Return type does not match returned value: expected `None`, found `str`

cloud-init (https://github.com/canonical/cloud-init)

cloudinit/util.py

[error] invalid-assignment - :2603:9 - Object of type `list[Unknown & ~AlwaysFalsy]` is not assignable to `list[str] | None`
[error] invalid-assignment - :2711:9 - Object of type `list[(str & ~AlwaysFalsy) | (@Todo & ~AlwaysFalsy)]` is not assignable to `list[str] | None`

tests/unittests/test_ds_identify.py

[warning] possibly-missing-implicit-call - :953:9 - Method `__setitem__` of type `Unknown | str | dict[Unknown | str, Unknown | str | int]` may be missing

colour (https://github.com/colour-science/colour)

colour/io/ctl.py

[error] invalid-assignment - :172:9 - Object of type `dict[str, list[Unknown]]` is not assignable to `dict[str, Sequence[Unknown]]`

colour/io/luts/cinespace_csp.py

[warning] possibly-unresolved-reference - :243:12 - Name `LUT` used when possibly not defined

colour/notation/munsell.py

[error] invalid-argument-type - :2553:13 - Argument to bound method `index` is incorrect: Expected `tuple[int | float, int | float]`, found `tuple[@Todo, @Todo, @Todo]`
[error] invalid-argument-type - :2558:13 - Argument to bound method `index` is incorrect: Expected `tuple[int | float, int | float]`, found `tuple[@Todo, @Todo, @Todo]`
[error] invalid-argument-type - :2565:17 - Argument to bound method `index` is incorrect: Expected `tuple[int | float, int | float]`, found `tuple[@Todo, @Todo, @Todo]`
[error] invalid-argument-type - :2570:17 - Argument to bound method `index` is incorrect: Expected `tuple[int | float, int | float]`, found `tuple[@Todo, @Todo, @Todo]`

colour/plotting/colorimetry.py

[error] invalid-argument-type - :394:36 - Argument to function `filter_cmfs` is incorrect: Expected `MultiSpectralDistributions | Sequence[MultiSpectralDistributions | str]`, found `Unknown | str | bool`
[error] invalid-argument-type - :398:43 - Argument to function `filter_illuminants` is incorrect: Expected `SpectralDistribution | Sequence[SpectralDistribution | str]`, found `Unknown | str | bool`
[error] invalid-argument-type - :420:40 - Argument to bound method `plot` is incorrect: Expected `bool`, found `Unknown | str | bool`
[error] invalid-argument-type - :420:40 - Argument to bound method `plot` is incorrect: Expected `bool`, found `Unknown | str | bool`

colour/plotting/common.py

[warning] possibly-missing-attribute - :984:24 - Attribute `name` on type `(@Todo & ~Top[dict[Unknown, Unknown]] & ~CanonicalMapping) | (Sequence[Any | str] & ~Top[list[Unknown]] & ~tuple[object, ...] & ~Top[dict[Unknown, Unknown]] & ~CanonicalMapping)` may be missing
[warning] possibly-missing-attribute - :987:28 - Attribute `__name__` on type `(@Todo & ~Top[dict[Unknown, Unknown]] & ~CanonicalMapping) | (Sequence[Any | str] & ~Top[list[Unknown]] & ~tuple[object, ...] & ~Top[dict[Unknown, Unknown]] & ~CanonicalMapping)` may be missing
[error] invalid-argument-type - :1608:55 - Argument to bound method `plot` is incorrect: Expected `bool`, found `Unknown | str`
[error] invalid-argument-type - :1608:55 - Argument to bound method `plot` is incorrect: Expected `bool`, found `Unknown | str`

colour/plotting/diagrams.py

[error] invalid-argument-type - :1092:36 - Argument to function `filter_cmfs` is incorrect: Expected `MultiSpectralDistributions | Sequence[MultiSpectralDistributions | str]`, found `Unknown | Sequence[MultiSpectralDistributions | str] | MultiSpectralDistributions | bool`
[error] invalid-argument-type - :1096:43 - Argument to function `filter_illuminants` is incorrect: Expected `SpectralDistribution | Sequence[SpectralDistribution | str]`, found `Unknown | Sequence[MultiSpectralDistributions | str] | MultiSpectralDistributions | bool`
[error] invalid-argument-type - :1112:33 - Argument to bound method `plot` is incorrect: Expected `bool`, found `Unknown | Sequence[MultiSpectralDistributions | str] | MultiSpectralDistributions | bool`
[error] invalid-argument-type - :1112:33 - Argument to bound method `plot` is incorrect: Expected `bool`, found `Unknown | Sequence[MultiSpectralDistributions | str] | MultiSpectralDistributions | bool`
[error] invalid-argument-type - :1118:43 - Argument to bound method `annotate` is incorrect: Expected `bool | None`, found `Unknown | bool | tuple[int, int] | str | Structure`
[error] invalid-argument-type - :1118:43 - Argument to bound method `annotate` is incorrect: Expected `dict[str, Any] | None`, found `Unknown | bool | tuple[int, int] | str | Structure`
[error] invalid-argument-type - :1118:43 - Argument to bound method `annotate` is incorrect: Expected `tuple[int | float, int | float] | None`, found `Unknown | bool | tuple[int, int] | str | Structure`

colour/plotting/models.py

[error] invalid-argument-type - :629:45 - Argument to bound method `plot` is incorrect: Expected `bool`, found `Unknown | str`
[error] invalid-argument-type - :629:45 - Argument to bound method `plot` is incorrect: Expected `bool`, found `Unknown | str`
[error] invalid-argument-type - :636:49 - Argument to bound method `plot` is incorrect: Expected `bool`, found `Unknown | str`
[error] invalid-argument-type - :636:49 - Argument to bound method `plot` is incorrect: Expected `bool`, found `Unknown | str`

colour/plotting/temperature.py

[error] invalid-argument-type - :695:33 - Argument to bound method `plot` is incorrect: Expected `bool`, found `Unknown | str`
[error] invalid-argument-type - :695:33 - Argument to bound method `plot` is incorrect: Expected `bool`, found `Unknown | str`
[error] invalid-argument-type - :701:46 - Argument to bound method `annotate` is incorrect: Expected `bool | None`, found `Unknown | bool | tuple[int, int] | str | Structure`
[error] invalid-argument-type - :701:46 - Argument to bound method `annotate` is incorrect: Expected `dict[str, Any] | None`, found `Unknown | bool | tuple[int, int] | str | Structure`
[error] invalid-argument-type - :701:46 - Argument to bound method `annotate` is incorrect: Expected `tuple[int | float, int | float] | None`, found `Unknown | bool | tuple[int, int] | str | Structure`

core (https://github.com/home-assistant/core)

homeassistant/components/accuweather/sensor.py

[error] invalid-assignment - :400:5 - Object of type `list[AccuWeatherSensor]` is not assignable to `list[AccuWeatherSensor | AccuWeatherForecastSensor]`

homeassistant/components/airtouch4/climate.py

[error] invalid-assignment - :72:5 - Object of type `list[AirtouchGroup]` is not assignable to `list[ClimateEntity]`

homeassistant/components/blue_current/sensor.py

[error] invalid-assignment - :219:5 - Object of type `list[ChargePointSensor]` is not assignable to `list[SensorEntity]`

homeassistant/components/demo/climate.py

[error] invalid-argument-type - :69:17 - Argument to bound method `__init__` is incorrect: Expected `list[HVACMode]`, found `list[Literal[HVACMode.OFF, HVACMode.HEAT, HVACMode.COOL, HVACMode.AUTO, HVACMode.DRY, HVACMode.FAN_ONLY]]`
[error] invalid-argument-type - :88:17 - Argument to bound method `__init__` is incorrect: Expected `list[HVACMode]`, found `list[Literal[HVACMode.OFF, HVACMode.COOL, HVACMode.HEAT_COOL, HVACMode.AUTO, HVACMode.DRY, HVACMode.FAN_ONLY]]`

homeassistant/components/dlna_dms/util.py

[error] invalid-assignment - :14:5 - Object of type `set[Any & ~AlwaysFalsy]` is not assignable to `set[str]`

homeassistant/components/ecobee/number.py

[error] invalid-assignment - :63:5 - Object of type `list[EcobeeVentilatorMinTime]` is not assignable to `list[NumberEntity]`

homeassistant/components/ecobee/switch.py

[error] invalid-assignment - :33:5 - Object of type `list[EcobeeVentilator20MinSwitch]` is not assignable to `list[SwitchEntity]`

homeassistant/components/ecovacs/util.py

[error] invalid-return-type - :39:12 - Return type does not match returned value: expected `list[EcovacsEntity[Unknown]]`, found `list[EcovacsDescriptionEntity[Unknown]]`

homeassistant/components/fireservicerota/binary_sensor.py

[error] invalid-return-type - :65:16 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[(Literal["start_time"] & Unknown) | (Literal["end_time"] & Unknown) | (Literal["available"] & Unknown) | ... omitted 5 union elements, @Todo]`

homeassistant/components/fireservicerota/switch.py

[error] invalid-return-type - :85:16 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[(Literal["user_name"] & Unknown) | (Literal["assigned_skill_ids"] & Unknown) | (Literal["responded_at"] & Unknown) | ... omitted 6 union elements, @Todo]`

homeassistant/components/fitbit/sensor.py

[error] invalid-assignment - :572:9 - Object of type `list[FitbitBatterySensor]` is not assignable to `list[SensorEntity]`

homeassistant/components/freebox/binary_sensor.py

[error] invalid-assignment - :45:5 - Object of type `list[FreeboxRaidDegradedSensor]` is not assignable to `list[BinarySensorEntity]`

homeassistant/components/freebox/sensor.py

[error] invalid-assignment - :78:5 - Object of type `list[FreeboxSensor]` is not assignable to `list[SensorEntity]`

homeassistant/components/fritz/button.py

[error] invalid-assignment - :79:5 - Object of type `list[FritzButton]` is not assignable to `list[ButtonEntity]`

homeassistant/components/geniushub/sensor.py

[error] invalid-assignment - :35:5 - Object of type `list[GeniusBattery]` is not assignable to `list[GeniusBattery | GeniusIssue]`

homeassistant/components/guardian/binary_sensor.py

[error] invalid-assignment - :126:5 - Object of type `list[ValveControllerBinarySensor]` is not assignable to `list[PairedSensorBinarySensor | ValveControllerBinarySensor]`

homeassistant/components/guardian/sensor.py

[error] invalid-assignment - :165:5 - Object of type `list[ValveControllerSensor]` is not assignable to `list[PairedSensorSensor | ValveControllerSensor]`

homeassistant/components/hassio/sensor.py

[error] invalid-assignment - :119:5 - Object of type `list[HassioAddonSensor]` is not assignable to `list[HassioOSSensor | HassioAddonSensor | CoreSensor | SupervisorSensor | HostSensor]`

homeassistant/components/mysensors/const.py

[error] invalid-assignment - :162:1 - Object of type `dict[tuple[EntityPlatforms, str], set[str]]` is not assignable to `dict[tuple[str, SensorType], set[ValueType]]`

homeassistant/components/notify/legacy.py

[error] invalid-return-type - :155:12 - Return type does not match returned value: expected `list[Coroutine[Any, Any, None]]`, found `list[CoroutineType[Any, Any, None]]`

homeassistant/components/proximity/sensor.py

[error] invalid-assignment - :91:5 - Object of type `list[ProximitySensor]` is not assignable to `list[ProximitySensor | ProximityTrackedEntitySensor]`

homeassistant/components/reolink/siren.py

[error] invalid-assignment - :69:5 - Object of type `list[ReolinkSirenEntity]` is not assignable to `list[SirenEntity]`

homeassistant/components/roku/entity.py

[error] invalid-argument-type - :35:25 - Invalid argument to key "connections" with declared type `set[tuple[str, str]]` on TypedDict `DeviceInfo`: value of type `set[tuple[Literal["mac"], Unknown & ~None]]`

homeassistant/components/verisure/sensor.py

[error] invalid-assignment - :30:5 - Object of type `list[VerisureThermometer]` is not assignable to `list[Entity]`

homeassistant/components/webmin/sensor.py

[error] invalid-assignment - :208:5 - Object of type `list[WebminSensor]` is not assignable to `list[WebminSensor | WebminFSSensor]`

homeassistant/components/yale_smart_alarm/binary_sensor.py

[error] invalid-assignment - :54:5 - Object of type `list[YaleDoorSensor]` is not assignable to `list[YaleDoorSensor | YaleDoorBatterySensor | YaleProblemSensor]`

homeassistant/helpers/icon.py

[error] invalid-return-type - :105:16 - Return type does not match returned value: expected `dict[str, dict[str, Any]]`, found `dict[str, Unknown & ~AlwaysFalsy]`

homeassistant/auth/__init__.py

[error] invalid-assignment - :370:9 - Object of type `dict[Literal["name", "group_ids", "local_only"], str | list[str] | bool]` is not assignable to `dict[str, Any]`

homeassistant/auth/auth_store.py

[error] no-matching-overload - :108:9 - No overload of bound method `update` matches arguments

homeassistant/auth/permissions/merge.py

[error] invalid-argument-type - :63:43 - Argument to function `_merge_policies` is incorrect: Expected `list[CategoryType]`, found `list[Never]`

homeassistant/components/abode/switch.py

[error] invalid-assignment - :30:5 - Object of type `list[AbodeSwitch]` is not assignable to `list[SwitchEntity]`

homeassistant/components/acaia/sensor.py

[error] invalid-assignment - :85:5 - Object of type `list[AcaiaSensor]` is not assignable to `list[SensorEntity]`

homeassistant/components/airzone_cloud/binary_sensor.py

[error] invalid-assignment - :119:5 - Object of type `list[AirzoneAidooBinarySensor]` is not assignable to `list[AirzoneBinarySensor]`

homeassistant/components/airzone_cloud/sensor.py

[error] invalid-assignment - :230:5 - Object of type `list[AirzoneAidooSensor]` is not assignable to `list[AirzoneSensor]`

homeassistant/components/application_credentials/__init__.py

[error] invalid-return-type - :233:12 - Return type does not match returned value: expected `list[AbstractOAuth2Implementation]`, found `list[AuthImplementation]`

homeassistant/components/arris_tg2492lg/device_tracker.py

[error] invalid-return-type - :59:16 - Return type does not match returned value: expected `list[str]`, found `list[Unknown & ~AlwaysFalsy]`

homeassistant/components/assist_pipeline/pipeline.py

[error] no-matching-overload - :361:5 - No overload of bound method `update` matches arguments

homeassistant/components/asuswrt/helpers.py

[error] invalid-return-type - :44:16 -
Old: Return type does not match returned value: expected `T@translate_to_legacy`, found `dict[@Todo, @Todo]`
New: Return type does not match returned value: expected `T@translate_to_legacy`, found `dict[Unknown | str, object]`
[error] invalid-return-type - :47:16 -
Old: Return type does not match returned value: expected `T@translate_to_legacy`, found `list[@Todo]`
New: Return type does not match returned value: expected `T@translate_to_legacy`, found `list[object]`

homeassistant/components/aws_s3/backup.py

[error] invalid-return-type - :56:12 - Return type does not match returned value: expected `list[BackupAgent]`, found `list[S3BackupAgent]`

homeassistant/components/azure_devops/sensor.py

[error] invalid-assignment - :154:5 - Object of type `list[AzureDevOpsBuildSensor]` is not assignable to `list[SensorEntity]`

homeassistant/components/azure_storage/backup.py

[error] invalid-return-type - :37:12 - Return type does not match returned value: expected `list[BackupAgent]`, found `list[AzureStorageBackupAgent]`

homeassistant/components/bbox/sensor.py

[error] invalid-assignment - :112:5 - Object of type `list[BboxSensor]` is not assignable to `list[BboxSensor | BboxUptimeSensor]`

homeassistant/components/bluetooth/passive_update_processor.py

[error] invalid-argument-type - :169:24 - Invalid argument to key "devices" with declared type `dict[str, DeviceInfo]` on TypedDict `RestoredPassiveBluetoothDataUpdate`: value of type `dict[(Unknown & ~AlwaysFalsy) | Literal[""], Unknown]`
[error] invalid-return-type - :317:16 - Return type does not match returned value: expected `dict[str, RestoredPassiveBluetoothDataUpdate]`, found `dict[Unknown & ~AlwaysFalsy, Unknown]`

homeassistant/components/bond/light.py

[error] invalid-assignment - :59:5 - Object of type `list[BondLight]` is not assignable to `list[Entity]`
[error] invalid-assignment - :67:5 - Object of type `list[BondUpLight]` is not assignable to `list[Entity]`
[error] invalid-assignment - :73:5 - Object of type `list[BondDownLight]` is not assignable to `list[Entity]`
[error] invalid-assignment - :79:5 - Object of type `list[BondFireplace]` is not assignable to `list[Entity]`
[error] invalid-assignment - :85:5 - Object of type `list[BondLight]` is not assignable to `list[Entity]`
[error] invalid-assignment - :91:5 - Object of type `list[BondLight]` is not assignable to `list[Entity]`

homeassistant/components/bosch_alarm/binary_sensor.py

[error] invalid-assignment - :124:5 - Object of type `list[PointSensor]` is not assignable to `list[BinarySensorEntity]`

homeassistant/components/bosch_alarm/switch.py

[error] invalid-assignment - :64:5 - Object of type `list[PanelOutputEntity]` is not assignable to `list[SwitchEntity]`

homeassistant/components/bosch_shc/binary_sensor.py

[error] invalid-assignment - :27:5 - Object of type `list[ShutterContactSensor]` is not assignable to `list[BinarySensorEntity]`

homeassistant/components/bosch_shc/sensor.py

[error] invalid-assignment - :134:5 - Object of type `list[SHCSensor]` is not assignable to `list[SensorEntity]`

homeassistant/components/bosch_shc/switch.py

[error] invalid-assignment - :87:5 - Object of type `list[SHCSwitch]` is not assignable to `list[SwitchEntity]`

homeassistant/components/bryant_evolution/config_flow.py

[error] invalid-return-type - :27:12 - Return type does not match returned value: expected `list[tuple[int, int]]`, found `list[tuple[Literal[1, 2], Unknown]]`

homeassistant/components/calendar/__init__.py

[error] invalid-return-type - :451:12 - Return type does not match returned value: expected `dict[str, JsonValueType]`, found `dict[str, str]`

homeassistant/components/configurator/__init__.py

[error] no-matching-overload - :190:9 - No overload of bound method `update` matches arguments

homeassistant/components/device_tracker/legacy.py

[error] invalid-assignment - :186:5 - Object of type `dict[Literal["mac", "dev_id", "host_name", "location_name", "gps", "gps_accuracy", "battery"], str | tuple[int | float, int | float] | int]` is not assignable to `dict[str, Any]`

homeassistant/components/easyenergy/services.py

[error] invalid-return-type - :78:12 - Return type does not match returned value: expected `ServiceResponse`, found `dict[Unknown | str, Unknown | list[dict[str, str | int | float]]]`

homeassistant/components/ecovacs/vacuum.py

[error] invalid-assignment - :48:5 - Object of type `list[EcovacsVacuum]` is not assignable to `list[EcovacsVacuum | EcovacsLegacyVacuum]`

homeassistant/components/electric_kiwi/sensor.py

[error] invalid-assignment - :140:5 - Object of type `list[ElectricKiwiAccountEntity]` is not assignable to `list[SensorEntity]`

homeassistant/components/elevenlabs/config_flow.py

[error] invalid-return-type - :69:12 - Return type does not match returned value: expected `tuple[dict[str, str], dict[str, str]]`, found `tuple[dict[Unknown, Unknown & ~AlwaysFalsy], dict[Unknown, Unknown & ~AlwaysFalsy]]`

homeassistant/components/energyzero/services.py

[error] invalid-return-type - :75:12 - Return type does not match returned value: expected `ServiceResponse`, found `dict[Unknown | str, Unknown | list[dict[Unknown, str | (Unknown & ~datetime)]]]`

homeassistant/components/enphase_envoy/sensor.py

[error] invalid-assignment - :1021:5 - Object of type `list[EnvoyProductionEntity]` is not assignable to `list[Entity]`

homeassistant/components/environment_canada/sensor.py

[error] invalid-assignment - :262:5 - Object of type `list[ECSensorEntity[Unknown]]` is not assignable to `list[ECBaseSensorEntity[Unknown]]`

homeassistant/components/fibaro/sensor.py

[error] invalid-assignment - :110:5 - Object of type `list[FibaroSensor]` is not assignable to `list[SensorEntity]`

homeassistant/components/fjaraskupan/binary_sensor.py

[error] invalid-return-type - :56:16 - Return type does not match returned value: expected `list[Entity]`, found `list[BinarySensor]`

homeassistant/components/flux_led/util.py

[error] invalid-return-type - :18:12 - Return type does not match returned value: expected `set[str]`, found `set[ColorMode]`

homeassistant/components/gardena_bluetooth/number.py

[error] invalid-assignment - :117:5 - Object of type `list[GardenaBluetoothNumber]` is not assignable to `list[NumberEntity]`

homeassistant/components/gardena_bluetooth/sensor.py

[error] invalid-assignment - :102:5 - Object of type `list[GardenaBluetoothSensor]` is not assignable to `list[GardenaBluetoothEntity]`

homeassistant/components/gdacs/geo_location.py

[error] invalid-return-type - :192:16 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[Literal["external_id", "description", "event_type", "alert_level", "country", ... omitted 6 literals], (Unknown & ~AlwaysFalsy) | (Unknown & bool)]`

homeassistant/components/gdacs/sensor.py

[error] invalid-return-type - :136:16 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[Literal["status", "last_update", "last_update_successful", "last_timestamp", "created", "updated", "removed"], (Unknown & ~AlwaysFalsy) | (Unknown & bool)]`

homeassistant/components/generic_thermostat/climate.py

[error] invalid-assignment - :174:5 - Object of type `dict[Literal["away", "comfort", "eco", "home", "sleep", "activity"], Any]` is not assignable to `dict[str, int | float]`

homeassistant/components/geonetnz_quakes/geo_location.py

[error] invalid-return-type - :159:16 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[Literal["external_id", "depth", "locality", "magnitude", "mmi", "quality", "time"], (Unknown & ~AlwaysFalsy) | (Unknown & bool)]`

homeassistant/components/google_assistant/helpers.py

[error] invalid-assignment - :622:13 -
Old: Method `__setitem__` of type `Unknown | (bound method dict[Unknown | str, Unknown].__setitem__(key: Unknown | str, value: Unknown, /) -> None) | (bound method dict[Unknown, Unknown].__setitem__(key: Unknown, value: Unknown, /) -> None) | (Overload[(key: SupportsIndex, value: @Todo, /) -> None, (key: slice[Any, Any, Any], value: Iterable[@Todo], /) -> None])` cannot be called with a key of type `Literal["nicknames"]` and a value of type `list[Unknown]` on object of type `Unknown | dict[Unknown | str, Unknown] | dict[Unknown, Unknown] | list[@Todo]`
New: Method `__setitem__` of type `Unknown | (bound method dict[Unknown | str, Unknown].__setitem__(key: Unknown | str, value: Unknown, /) -> None) | (bound method dict[Unknown, Unknown].__setitem__(key: Unknown, value: Unknown, /) -> None) | (Overload[(key: SupportsIndex, value: Unknown, /) -> None, (key: slice[Any, Any, Any], value: Iterable[Unknown], /) -> None])` cannot be called with a key of type `Literal["nicknames"]` and a value of type `list[Unknown]` on object of type `Unknown | dict[Unknown | str, Unknown] | dict[Unknown, Unknown] | list[Unknown]`
[error] invalid-argument-type - :624:17 -
Old: Method `__getitem__` of type `Overload[(i: SupportsIndex, /) -> @Todo, (s: slice[Any, Any, Any], /) -> list[@Todo]]` cannot be called with key of type `Literal["nicknames"]` on object of type `list[@Todo]`
New: Method `__getitem__` of type `Overload[(i: SupportsIndex, /) -> Unknown, (s: slice[Any, Any, Any], /) -> list[Unknown]]` cannot be called with key of type `Literal["nicknames"]` on object of type `list[Unknown]`
[warning] possibly-missing-attribute - :637:13 -
Old: Attribute `update` on type `Unknown | dict[Unknown | str, Unknown] | dict[Unknown, Unknown] | list[@Todo]` may be missing
New: Attribute `update` on type `Unknown | dict[Unknown | str, Unknown] | dict[Unknown, Unknown] | list[Unknown]` may be missing

homeassistant/components/google_assistant_sdk/services.py

[error] invalid-return-type - :44:16 - Return type does not match returned value: expected `ServiceResponse`, found `dict[Unknown | str, Unknown | list[dict[str, Any]]]`

homeassistant/components/google_drive/backup.py

[error] invalid-return-type - :34:12 - Return type does not match returned value: expected `list[BackupAgent]`, found `list[GoogleDriveBackupAgent]`

homeassistant/components/google_generative_ai_conversation/__init__.py

[error] invalid-argument-type - :111:35 - Argument to function `async_prepare_files_for_prompt` is incorrect: Expected `list[tuple[Path, str | None]]`, found `list[tuple[Path, None]]`

homeassistant/components/google_generative_ai_conversation/ai_task.py

[error] invalid-argument-type - :125:21 - Argument to function `async_prepare_files_for_prompt` is incorrect: Expected `list[tuple[Path, str | None]]`, found `list[tuple[Path, str]]`

homeassistant/components/google_generative_ai_conversation/entity.py

[error] invalid-argument-type - :586:21 - Argument to function `async_prepare_files_for_prompt` is incorrect: Expected `list[tuple[Path, str | None]]`, found `list[tuple[Path, str]]`

homeassistant/components/google_mail/services.py

[error] invalid-return-type - :52:12 - Return type does not match returned value: expected `list[GoogleMailConfigEntry]`, found `list[(Unknown & ~AlwaysFalsy) | (ConfigEntry[Any] & ~AlwaysFalsy)]`

homeassistant/components/google_photos/services.py

[error] invalid-return-type - :141:16 - Return type does not match returned value: expected `ServiceResponse`, found `dict[Unknown | str, Unknown | list[dict[Unknown | str, Unknown]]]`

homeassistant/components/greeneye_monitor/sensor.py

[error] invalid-assignment - :66:13 - Object of type `list[CurrentSensor]` is not assignable to `list[GEMSensor]`

homeassistant/components/habitica/binary_sensor.py

[error] invalid-assignment - :67:5 - Object of type `list[HabiticaBinarySensorEntity]` is not assignable to `list[BinarySensorEntity]`

homeassistant/components/habitica/coordinator.py

[error] invalid-argument-type - :214:13 - Argument is incorrect: Expected `dict[UUID, Unknown]`, found `dict[Unknown & ~AlwaysFalsy, Unknown]`

homeassistant/components/heos/media_player.py

[error] invalid-return-type - :222:16 - Return type does not match returned value: expected `list[str] | None`, found `(list[Unknown & ~AlwaysFalsy] & ~AlwaysFalsy) | None`
[error] invalid-return-type - :255:16 - Return type does not match returned value: expected `ServiceResponse`, found `dict[Unknown | str, Unknown | list[dict[str, Any]]]`

homeassistant/components/home_connect/light.py

[error] invalid-return-type - :85:12 - Return type does not match returned value: expected `list[HomeConnectEntity]`, found `list[HomeConnectLight]`

homeassistant/components/home_connect/number.py

[error] invalid-return-type - :129:12 - Return type does not match returned value: expected `list[HomeConnectEntity]`, found `list[HomeConnectNumberEntity]`
[error] invalid-return-type - :141:12 - Return type does not match returned value: expected `list[HomeConnectOptionEntity]`, found `list[HomeConnectOptionNumberEntity]`

homeassistant/components/home_connect/select.py

[error] invalid-argument-type - :123:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[str, Literal["ConsumerProducts.CleaningRobot.EnumType.AvailableMaps.TempMap", "ConsumerProducts.CleaningRobot.EnumType.AvailableMaps.Map1", "ConsumerProducts.CleaningRobot.EnumType.AvailableMaps.Map2", "ConsumerProducts.CleaningRobot.EnumType.AvailableMaps.Map3"]]`
[error] invalid-argument-type - :124:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[Literal["ConsumerProducts.CleaningRobot.EnumType.AvailableMaps.TempMap", "ConsumerProducts.CleaningRobot.EnumType.AvailableMaps.Map1", "ConsumerProducts.CleaningRobot.EnumType.AvailableMaps.Map2", "ConsumerProducts.CleaningRobot.EnumType.AvailableMaps.Map3"], str]`
[error] invalid-argument-type - :133:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[str, Literal["Cooking.Hood.EnumType.ColorTemperature.custom", "Cooking.Hood.EnumType.ColorTemperature.warm", "Cooking.Hood.EnumType.ColorTemperature.warmToNeutral", "Cooking.Hood.EnumType.ColorTemperature.neutral", "Cooking.Hood.EnumType.ColorTemperature.neutralToCold", "Cooking.Hood.EnumType.ColorTemperature.cold"]]`
[error] invalid-argument-type - :134:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[Literal["Cooking.Hood.EnumType.ColorTemperature.custom", "Cooking.Hood.EnumType.ColorTemperature.warm", "Cooking.Hood.EnumType.ColorTemperature.warmToNeutral", "Cooking.Hood.EnumType.ColorTemperature.neutral", "Cooking.Hood.EnumType.ColorTemperature.neutralToCold", "Cooking.Hood.EnumType.ColorTemperature.cold"], str]`
[error] invalid-argument-type - :156:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[str, Literal["ConsumerProducts.CleaningRobot.EnumType.AvailableMaps.TempMap", "ConsumerProducts.CleaningRobot.EnumType.AvailableMaps.Map1", "ConsumerProducts.CleaningRobot.EnumType.AvailableMaps.Map2", "ConsumerProducts.CleaningRobot.EnumType.AvailableMaps.Map3"]]`
[error] invalid-argument-type - :157:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[Literal["ConsumerProducts.CleaningRobot.EnumType.AvailableMaps.TempMap", "ConsumerProducts.CleaningRobot.EnumType.AvailableMaps.Map1", "ConsumerProducts.CleaningRobot.EnumType.AvailableMaps.Map2", "ConsumerProducts.CleaningRobot.EnumType.AvailableMaps.Map3"], str]`
[error] invalid-argument-type - :166:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[str, Literal["ConsumerProducts.CleaningRobot.EnumType.CleaningModes.Silent", "ConsumerProducts.CleaningRobot.EnumType.CleaningModes.Standard", "ConsumerProducts.CleaningRobot.EnumType.CleaningModes.Power", "ConsumerProducts.CleaningRobot.EnumType.CleaningMode.IntelligentMode", "ConsumerProducts.CleaningRobot.EnumType.CleaningMode.VacuumOnly", ... omitted 3 literals]]`
[error] invalid-argument-type - :167:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[Literal["ConsumerProducts.CleaningRobot.EnumType.CleaningModes.Silent", "ConsumerProducts.CleaningRobot.EnumType.CleaningModes.Standard", "ConsumerProducts.CleaningRobot.EnumType.CleaningModes.Power", "ConsumerProducts.CleaningRobot.EnumType.CleaningMode.IntelligentMode", "ConsumerProducts.CleaningRobot.EnumType.CleaningMode.VacuumOnly", ... omitted 3 literals], str]`
[error] invalid-argument-type - :176:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[str, Literal["ConsumerProducts.CleaningRobot.EnumType.SuctionPower.Silent", "ConsumerProducts.CleaningRobot.EnumType.SuctionPower.Standard", "ConsumerProducts.CleaningRobot.EnumType.SuctionPower.Max"]]`
[error] invalid-argument-type - :177:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[Literal["ConsumerProducts.CleaningRobot.EnumType.SuctionPower.Silent", "ConsumerProducts.CleaningRobot.EnumType.SuctionPower.Standard", "ConsumerProducts.CleaningRobot.EnumType.SuctionPower.Max"], str]`
[error] invalid-argument-type - :186:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[str, Literal["ConsumerProducts.CoffeeMaker.EnumType.BeanAmount.VeryMild", "ConsumerProducts.CoffeeMaker.EnumType.BeanAmount.Mild", "ConsumerProducts.CoffeeMaker.EnumType.BeanAmount.MildPlus", "ConsumerProducts.CoffeeMaker.EnumType.BeanAmount.Normal", "ConsumerProducts.CoffeeMaker.EnumType.BeanAmount.NormalPlus", ... omitted 11 literals]]`
[error] invalid-argument-type - :187:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[Literal["ConsumerProducts.CoffeeMaker.EnumType.BeanAmount.VeryMild", "ConsumerProducts.CoffeeMaker.EnumType.BeanAmount.Mild", "ConsumerProducts.CoffeeMaker.EnumType.BeanAmount.MildPlus", "ConsumerProducts.CoffeeMaker.EnumType.BeanAmount.Normal", "ConsumerProducts.CoffeeMaker.EnumType.BeanAmount.NormalPlus", ... omitted 11 literals], str]`
[error] invalid-argument-type - :196:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[str, Literal["ConsumerProducts.CoffeeMaker.EnumType.CoffeeTemperature.88C", "ConsumerProducts.CoffeeMaker.EnumType.CoffeeTemperature.90C", "ConsumerProducts.CoffeeMaker.EnumType.CoffeeTemperature.92C", "ConsumerProducts.CoffeeMaker.EnumType.CoffeeTemperature.94C", "ConsumerProducts.CoffeeMaker.EnumType.CoffeeTemperature.95C", "ConsumerProducts.CoffeeMaker.EnumType.CoffeeTemperature.96C"]]`
[error] invalid-argument-type - :197:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[Literal["ConsumerProducts.CoffeeMaker.EnumType.CoffeeTemperature.88C", "ConsumerProducts.CoffeeMaker.EnumType.CoffeeTemperature.90C", "ConsumerProducts.CoffeeMaker.EnumType.CoffeeTemperature.92C", "ConsumerProducts.CoffeeMaker.EnumType.CoffeeTemperature.94C", "ConsumerProducts.CoffeeMaker.EnumType.CoffeeTemperature.95C", "ConsumerProducts.CoffeeMaker.EnumType.CoffeeTemperature.96C"], str]`
[error] invalid-argument-type - :206:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[str, Literal["ConsumerProducts.CoffeeMaker.EnumType.BeanContainerSelection.Right", "ConsumerProducts.CoffeeMaker.EnumType.BeanContainerSelection.Left"]]`
[error] invalid-argument-type - :207:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[Literal["ConsumerProducts.CoffeeMaker.EnumType.BeanContainerSelection.Right", "ConsumerProducts.CoffeeMaker.EnumType.BeanContainerSelection.Left"], str]`
[error] invalid-argument-type - :216:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[str, Literal["ConsumerProducts.CoffeeMaker.EnumType.FlowRate.Normal", "ConsumerProducts.CoffeeMaker.EnumType.FlowRate.Intense", "ConsumerProducts.CoffeeMaker.EnumType.FlowRate.IntensePlus"]]`
[error] invalid-argument-type - :217:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[Literal["ConsumerProducts.CoffeeMaker.EnumType.FlowRate.Normal", "ConsumerProducts.CoffeeMaker.EnumType.FlowRate.Intense", "ConsumerProducts.CoffeeMaker.EnumType.FlowRate.IntensePlus"], str]`
[error] invalid-argument-type - :226:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[str, Literal["ConsumerProducts.CoffeeMaker.EnumType.CoffeeMilkRatio.10Percent", "ConsumerProducts.CoffeeMaker.EnumType.CoffeeMilkRatio.20Percent", "ConsumerProducts.CoffeeMaker.EnumType.CoffeeMilkRatio.25Percent", "ConsumerProducts.CoffeeMaker.EnumType.CoffeeMilkRatio.30Percent", "ConsumerProducts.CoffeeMaker.EnumType.CoffeeMilkRatio.40Percent", ... omitted 10 literals]]`
[error] invalid-argument-type - :227:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[Literal["ConsumerProducts.CoffeeMaker.EnumType.FlowRate.Normal", "ConsumerProducts.CoffeeMaker.EnumType.FlowRate.Intense", "ConsumerProducts.CoffeeMaker.EnumType.FlowRate.IntensePlus"], str]`
[error] invalid-argument-type - :236:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[str, Literal["ConsumerProducts.CoffeeMaker.EnumType.HotWaterTemperature.WhiteTea", "ConsumerProducts.CoffeeMaker.EnumType.HotWaterTemperature.GreenTea", "ConsumerProducts.CoffeeMaker.EnumType.HotWaterTemperature.BlackTea", "ConsumerProducts.CoffeeMaker.EnumType.HotWaterTemperature.50C", "ConsumerProducts.CoffeeMaker.EnumType.HotWaterTemperature.55C", ... omitted 20 literals]]`
[error] invalid-argument-type - :237:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[Literal["ConsumerProducts.CoffeeMaker.EnumType.HotWaterTemperature.WhiteTea", "ConsumerProducts.CoffeeMaker.EnumType.HotWaterTemperature.GreenTea", "ConsumerProducts.CoffeeMaker.EnumType.HotWaterTemperature.BlackTea", "ConsumerProducts.CoffeeMaker.EnumType.HotWaterTemperature.50C", "ConsumerProducts.CoffeeMaker.EnumType.HotWaterTemperature.55C", ... omitted 20 literals], str]`
[error] invalid-argument-type - :246:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[str, Literal["LaundryCare.Dryer.EnumType.DryingTarget.IronDry", "LaundryCare.Dryer.EnumType.DryingTarget.GentleDry", "LaundryCare.Dryer.EnumType.DryingTarget.CupboardDry", "LaundryCare.Dryer.EnumType.DryingTarget.CupboardDryPlus", "LaundryCare.Dryer.EnumType.DryingTarget.ExtraDry"]]`
[error] invalid-argument-type - :247:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[Literal["LaundryCare.Dryer.EnumType.DryingTarget.IronDry", "LaundryCare.Dryer.EnumType.DryingTarget.GentleDry", "LaundryCare.Dryer.EnumType.DryingTarget.CupboardDry", "LaundryCare.Dryer.EnumType.DryingTarget.CupboardDryPlus", "LaundryCare.Dryer.EnumType.DryingTarget.ExtraDry"], str]`
[error] invalid-argument-type - :256:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[str, Literal["Cooking.Hood.EnumType.Stage.FanOff", "Cooking.Hood.EnumType.Stage.FanStage01", "Cooking.Hood.EnumType.Stage.FanStage02", "Cooking.Hood.EnumType.Stage.FanStage03", "Cooking.Hood.EnumType.Stage.FanStage04", "Cooking.Hood.EnumType.Stage.FanStage05"]]`
[error] invalid-argument-type - :257:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[Literal["Cooking.Hood.EnumType.Stage.FanOff", "Cooking.Hood.EnumType.Stage.FanStage01", "Cooking.Hood.EnumType.Stage.FanStage02", "Cooking.Hood.EnumType.Stage.FanStage03", "Cooking.Hood.EnumType.Stage.FanStage04", "Cooking.Hood.EnumType.Stage.FanStage05"], str]`
[error] invalid-argument-type - :266:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[str, Literal["Cooking.Hood.EnumType.IntensiveStage.IntensiveStageOff", "Cooking.Hood.EnumType.IntensiveStage.IntensiveStage1", "Cooking.Hood.EnumType.IntensiveStage.IntensiveStage2"]]`
[error] invalid-argument-type - :267:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[Literal["Cooking.Hood.EnumType.IntensiveStage.IntensiveStageOff", "Cooking.Hood.EnumType.IntensiveStage.IntensiveStage1", "Cooking.Hood.EnumType.IntensiveStage.IntensiveStage2"], str]`
[error] invalid-argument-type - :276:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[str, Literal["Cooking.Oven.EnumType.WarmingLevel.Low", "Cooking.Oven.EnumType.WarmingLevel.Medium", "Cooking.Oven.EnumType.WarmingLevel.High"]]`
[error] invalid-argument-type - :277:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[Literal["Cooking.Oven.EnumType.WarmingLevel.Low", "Cooking.Oven.EnumType.WarmingLevel.Medium", "Cooking.Oven.EnumType.WarmingLevel.High"], str]`
[error] invalid-argument-type - :286:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[str, Literal["LaundryCare.Washer.EnumType.Temperature.Cold", "LaundryCare.Washer.EnumType.Temperature.GC20", "LaundryCare.Washer.EnumType.Temperature.GC30", "LaundryCare.Washer.EnumType.Temperature.GC40", "LaundryCare.Washer.EnumType.Temperature.GC50", ... omitted 8 literals]]`
[error] invalid-argument-type - :287:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[Literal["LaundryCare.Washer.EnumType.Temperature.Cold", "LaundryCare.Washer.EnumType.Temperature.GC20", "LaundryCare.Washer.EnumType.Temperature.GC30", "LaundryCare.Washer.EnumType.Temperature.GC40", "LaundryCare.Washer.EnumType.Temperature.GC50", ... omitted 8 literals], str]`
[error] invalid-argument-type - :296:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[str, Literal["LaundryCare.Washer.EnumType.SpinSpeed.Off", "LaundryCare.Washer.EnumType.SpinSpeed.RPM400", "LaundryCare.Washer.EnumType.SpinSpeed.RPM600", "LaundryCare.Washer.EnumType.SpinSpeed.RPM700", "LaundryCare.Washer.EnumType.SpinSpeed.RPM800", ... omitted 9 literals]]`
[error] invalid-argument-type - :297:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[Literal["LaundryCare.Washer.EnumType.SpinSpeed.Off", "LaundryCare.Washer.EnumType.SpinSpeed.RPM400", "LaundryCare.Washer.EnumType.SpinSpeed.RPM600", "LaundryCare.Washer.EnumType.SpinSpeed.RPM700", "LaundryCare.Washer.EnumType.SpinSpeed.RPM800", ... omitted 9 literals], str]`
[error] invalid-argument-type - :306:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[str, Literal["LaundryCare.Common.EnumType.VarioPerfect.Off", "LaundryCare.Common.EnumType.VarioPerfect.EcoPerfect", "LaundryCare.Common.EnumType.VarioPerfect.SpeedPerfect"]]`
[error] invalid-argument-type - :307:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[Literal["LaundryCare.Common.EnumType.VarioPerfect.Off", "LaundryCare.Common.EnumType.VarioPerfect.EcoPerfect", "LaundryCare.Common.EnumType.VarioPerfect.SpeedPerfect"], str]`
[error] invalid-return-type - :342:12 - Return type does not match returned value: expected `list[HomeConnectOptionEntity]`, found `list[HomeConnectSelectOptionEntity]`

homeassistant/components/home_connect/switch.py

[error] invalid-return-type - :163:12 - Return type does not match returned value: expected `list[HomeConnectOptionEntity]`, found `list[HomeConnectSwitchOptionEntity]`

homeassistant/components/homematicip_cloud/cover.py

[error] invalid-assignment - :44:5 - Object of type `list[HomematicipCoverShutterGroup]` is not assignable to `list[HomematicipGenericEntity]`

homeassistant/components/homematicip_cloud/switch.py

[error] invalid-assignment - :43:5 - Object of type `list[HomematicipGroupSwitch]` is not assignable to `list[HomematicipGenericEntity]`

homeassistant/components/homewizard/sensor.py

[error] invalid-argument-type - :716:21 - Argument to bound method `append` is incorrect: Expected `HomeWizardSensorEntity`, found `HomeWizardExternalSensorEntity`

homeassistant/components/huawei_lte/__init__.py

[error] invalid-argument-type - :155:29 - Argument to bound method `add` is incorrect: Expected `tuple[Literal["mac"], Unknown]`, found `tuple[Literal["upnp"], Unknown & ~AlwaysFalsy]`
[error] invalid-return-type - :156:16 - Return type does not match returned value: expected `set[tuple[str, str]]`, found `set[tuple[Literal["mac"], Unknown]]`

homeassistant/components/ign_sismologia/geo_location.py

[error] invalid-return-type - :227:16 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[Literal["external_id", "title", "region", "magnitude", "publication_date", "image_url"], (Unknown & ~AlwaysFalsy) | (Unknown & bool)]`

homeassistant/components/ipp/sensor.py

[error] invalid-assignment - :94:5 - Object of type `list[IPPSensor]` is not assignable to `list[SensorEntity]`

homeassistant/components/iqvia/sensor.py

[error] invalid-assignment - :134:5 - Object of type `list[ForecastSensor]` is not assignable to `list[ForecastSensor | IndexSensor]`

homeassistant/components/isy994/button.py

[error] invalid-assignment - :36:5 - Object of type `list[ISYNetworkResourceButtonEntity]` is not assignable to `list[ISYNodeQueryButtonEntity | ISYNodeBeepButtonEntity | ISYNetworkResourceButtonEntity]`

homeassistant/components/isy994/cover.py

[error] invalid-assignment - :31:5 - Object of type `list[ISYCoverEntity]` is not assignable to `list[ISYCoverEntity | ISYCoverProgramEntity]`

homeassistant/components/isy994/fan.py

[error] invalid-assignment - :35:5 - Object of type `list[ISYFanEntity]` is not assignable to `list[ISYFanEntity | ISYFanProgramEntity]`

homeassistant/components/isy994/lock.py

[error] invalid-assignment - :55:5 - Object of type `list[ISYLockEntity]` is not assignable to `list[ISYLockEntity | ISYLockProgramEntity]`

homeassistant/components/jewish_calendar/sensor.py

[error] invalid-assignment - :216:5 - Object of type `list[JewishCalendarSensor]` is not assignable to `list[JewishCalendarBaseSensor]`

homeassistant/components/lamarzocco/number.py

[error] invalid-assignment - :209:5 - Object of type `list[LaMarzoccoNumberEntity]` is not assignable to `list[NumberEntity]`

homeassistant/components/letpot/switch.py

[error] invalid-assignment - :87:5 - Object of type `list[LetPotSwitchEntity]` is not assignable to `list[SwitchEntity]`

homeassistant/components/lifx/__init__.py

[error] invalid-argument-type - :87:32 - Argument to function `async_migrate_legacy_entries` is incorrect: Expected `set[str]`, found `set[str & ~AlwaysFalsy]`

homeassistant/components/mealie/services.py

[error] invalid-return-type - :148:12 - Return type does not match returned value: expected `ServiceResponse`, found `dict[Unknown | str, Unknown | list[dict[str, Any]]]`

homeassistant/components/media_extractor/__init__.py

[error] invalid-assignment - :238:13 - Method `__setitem__` of type `bound method dict[Unknown & ~Literal["entity_id"], Unknown].__setitem__(key: Unknown & ~Literal["entity_id"], value: Unknown, /) -> None` cannot be called with a key of type `Literal["entity_id"]` and a value of type `str & ~AlwaysFalsy` on object of type `dict[Unknown & ~Literal["entity_id"], Unknown]`

homeassistant/components/melcloud/climate.py

[error] invalid-assignment - :83:5 - Object of type `list[AtaDeviceClimate]` is not assignable to `list[AtaDeviceClimate | AtwDeviceZoneClimate]`

homeassistant/components/miele/services.py

[error] invalid-return-type - :170:12 - Return type does not match returned value: expected `ServiceResponse`, found `dict[Unknown | str, Unknown | list[dict[Unknown | str, Unknown | dict[Unknown | str, Unknown | dict[Unknown | str, Unknown] | dict[Unknown, Unknown] | dict[Unknown | str, Unknown | dict[Unknown | str, Unknown]]] | dict[Unknown, Unknown]]]]`

homeassistant/components/monarch_money/sensor.py

[error] invalid-assignment - :118:5 - Object of type `list[MonarchMoneyCashFlowSensor]` is not assignable to `list[MonarchMoneySensor | MonarchMoneyCashFlowSensor]`

homeassistant/components/motionblinds_ble/sensor.py

[error] invalid-assignment - :103:5 - Object of type `list[MotionblindsBLESensorEntity[Unknown]]` is not assignable to `list[SensorEntity]`

homeassistant/components/mqtt/climate.py

[error] invalid-assignment - :611:9 - Object of type `dict[Literal["current_humidity_template", "current_temperature_template", "fan_mode_state_template", "target_humidity_state_template", "mode_state_template", ... omitted 7 literals], Any | None]` is not assignable to `dict[str, Template | None]`
[error] no-matching-overload - :614:9 - No overload of bound method `update` matches arguments

homeassistant/components/mqtt/entity.py

[error] invalid-argument-type - :1270:21 - Invalid argument to key "identifiers" with declared type `set[tuple[str, str]]` on TypedDict `DeviceInfo`: value of type `set[tuple[Literal["mqtt"], @Todo]]`

homeassistant/components/mqtt/light/schema_basic.py

[error] invalid-assignment - :285:9 - Object of type `dict[Literal["brightness_command_topic", "brightness_state_topic", "color_mode_state_topic", "color_temp_command_topic", "color_temp_state_topic", ... omitted 15 literals], Any | None]` is not assignable to `dict[str, str | None]`

homeassistant/components/mqtt/water_heater.py

[error] invalid-assignment - :228:9 - Object of type `dict[Literal["current_temperature_template", "mode_state_template", "temperature_state_template"], Any | None]` is not assignable to `dict[str, Template | None]`
[error] no-matching-overload - :231:9 - No overload of bound method `update` matches arguments

homeassistant/components/music_assistant/media_player.py

[error] invalid-assignment - :278:9 - Object of type `list[Unknown & ~AlwaysFalsy]` is not assignable to `list[str]`

homeassistant/components/nest/config_flow.py

[error] invalid-assignment - :89:5 - Object of type `list[Unknown & ~AlwaysFalsy]` is not assignable to `list[str]`

homeassistant/components/nobo_hub/select.py

[error] invalid-assignment - :42:5 - Object of type `list[NoboProfileSelector]` is not assignable to `list[SelectEntity]`

homeassistant/components/nordpool/services.py

[error] invalid-return-type - :159:20 - Return type does not match returned value: expected `ServiceResponse`, found `dict[str, list[Unknown]]`

homeassistant/components/nsw_rural_fire_service_feed/geo_location.py

[error] invalid-return-type - :272:16 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[Literal["external_id", "category", "location", "publication_date", "council_area", ... omitted 5 literals], (Unknown & ~AlwaysFalsy) | (Unknown & bool)]`

homeassistant/components/nuki/lock.py

[error] invalid-assignment - :35:5 - Object of type `list[NukiLockEntity]` is not assignable to `list[NukiDeviceEntity[Unknown]]`

homeassistant/components/nut/__init__.py

[error] invalid-argument-type - :57:35 - Argument to bound method `async_update_entry` is incorrect: Expected `Mapping[str, Any] | UndefinedType`, found `dict[str & ~Literal["resources"], Any]`

homeassistant/components/nyt_games/sensor.py

[error] invalid-assignment - :155:5 - Object of type `list[NYTGamesWordleSensor]` is not assignable to `list[SensorEntity]`

homeassistant/components/onedrive/backup.py

[error] invalid-return-type - :52:12 - Return type does not match returned value: expected `list[BackupAgent]`, found `list[OneDriveBackupAgent]`

homeassistant/components/onedrive/services.py

[error] invalid-return-type - :123:20 - Return type does not match returned value: expected `ServiceResponse`, found `dict[Unknown | str, Unknown | list[dict[str, Any]]]`

homeassistant/components/open_router/entity.py

[error] invalid-argument-type - :272:17 - Argument to function `async_prepare_files_for_prompt` is incorrect: Expected `list[tuple[Path, str | None]]`, found `list[tuple[Path, str]]`

homeassistant/components/openai_conversation/__init__.py

[error] invalid-argument-type - :151:27 - Argument to function `async_prepare_files_for_prompt` is incorrect: Expected `list[tuple[Path, str | None]]`, found `list[tuple[Path, None]]`

homeassistant/components/openai_conversation/entity.py

[error] invalid-argument-type - :542:17 - Argument to function `async_prepare_files_for_prompt` is incorrect: Expected `list[tuple[Path, str | None]]`, found `list[tuple[Path, str]]`

homeassistant/components/opentherm_gw/select.py

[error] invalid-argument-type - :152:9 - Argument is incorrect: Expected `list[str] | None`, found `list[Literal[OpenThermSelectGPIOMode.INPUT, OpenThermSelectGPIOMode.GROUND, OpenThermSelectGPIOMode.VCC, OpenThermSelectGPIOMode.LED_E, OpenThermSelectGPIOMode.LED_F, ... omitted 3 literals]]`

homeassistant/components/openuv/__init__.py

[error] invalid-assignment - :56:5 - Object of type `dict[Literal["uv", "protection_window"], OpenUvCoordinator]` is not assignable to `dict[str, OpenUvCoordinator]`

homeassistant/components/oralb/sensor.py

[error] invalid-argument-type - :113:9 - Argument is incorrect: Expected `dict[PassiveBluetoothEntityKey, EntityDescription]`, found `dict[PassiveBluetoothEntityKey, SensorEntityDescription]`

homeassistant/components/overkiz/cover/__init__.py

[error] invalid-assignment - :23:5 - Object of type `list[Awning]` is not assignable to `list[OverkizGenericCover]`

homeassistant/components/qbus/binary_sensor.py

[error] invalid-return-type - :69:16 - Return type does not match returned value: expected `list[BinarySensorEntity]`, found `list[QbusWeatherBinarySensor]`

homeassistant/components/qbus/sensor.py

[error] invalid-return-type - :254:16 - Return type does not match returned value: expected `list[QbusEntity[Unknown]]`, found `list[QbusWeatherSensor]`

homeassistant/components/qld_bushfire/geo_location.py

[error] invalid-return-type - :226:16 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[Literal["external_id", "category", "publication_date", "updated_date", "status"], (Unknown & ~AlwaysFalsy) | (Unknown & bool)]`

homeassistant/components/recorder/filters.py

[error] invalid-return-type - :39:12 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[Literal["exclude", "include"], dict[Literal["entities", "domains", "entity_globs"], set[Unknown]]]`
[error] invalid-return-type - :55:12 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[Literal["exclude", "include"], dict[Literal["entities", "domains", "entity_globs"], Any]]`

homeassistant/components/recorder/history/__init__.py

[error] invalid-return-type - :936:12 - Return type does not match returned value: expected `dict[str, list[State | dict[str, Any]]]`, found `dict[str, list[Unknown] & ~AlwaysFalsy]`

homeassistant/components/recorder/migration.py

[error] invalid-argument-type - :1989:13 - Argument to function `_restore_foreign_key_constraints` is incorrect: Expected `list[tuple[str, str, str | None, str | None]]`, found `list[tuple[Literal["events", "states", "statistics", "statistics_short_term"], Literal["data_id", "event_type_id", "event_id", "old_state_id", "attributes_id", "metadata_id"], Literal["event_data", "event_types", "states", "state_attributes", "states_meta", "statistics_meta"] | None, Literal["data_id", "event_type_id", "state_id", "attributes_id", "metadata_id", "id"] | None]]`

homeassistant/components/recorder/statistics.py

[error] invalid-assignment - :238:1 - Object of type `dict[str, type[BaseUnitConverter]]` is not assignable to `dict[str | None, type[BaseUnitConverter]]`

homeassistant/components/reolink/button.py

[error] invalid-assignment - :159:5 - Object of type `list[ReolinkButtonEntity]` is not assignable to `list[ReolinkButtonEntity | ReolinkHostButtonEntity]`

homeassistant/components/reolink/light.py

[error] invalid-assignment - :108:5 - Object of type `list[ReolinkLightEntity]` is not assignable to `list[ReolinkLightEntity | ReolinkHostLightEntity]`

homeassistant/components/reolink/number.py

[error] invalid-assignment - :921:5 - Object of type `list[ReolinkNumberEntity]` is not assignable to `list[NumberEntity]`

homeassistant/components/reolink/select.py

[error] invalid-assignment - :407:5 - Object of type `list[ReolinkSelectEntity]` is not assignable to `list[SelectEntity]`

homeassistant/components/reolink/sensor.py

[error] invalid-assignment - :223:5 - Object of type `list[ReolinkSensorEntity]` is not assignable to `list[ReolinkSensorEntity | ReolinkHostSensorEntity | ReolinkHddSensorEntity]`

homeassistant/components/reolink/switch.py

[error] invalid-assignment - :337:5 - Object of type `list[ReolinkSwitchEntity]` is not assignable to `list[SwitchEntity]`

homeassistant/components/reolink/update.py

[error] invalid-assignment - :83:5 - Object of type `list[ReolinkUpdateEntity]` is not assignable to `list[ReolinkUpdateEntity | ReolinkHostUpdateEntity]`

homeassistant/components/rfxtrx/sensor.py

[error] invalid-return-type - :258:16 - Return type does not match returned value: expected `list[Entity]`, found `list[RfxtrxSensor]`

homeassistant/components/roborock/__init__.py

[error] invalid-return-type - :206:12 - Return type does not match returned value: expected `list[Coroutine[Any, Any, RoborockDataUpdateCoordinator | RoborockDataUpdateCoordinatorA01 | None]]`, found `list[CoroutineType[Any, Any, RoborockDataUpdateCoordinator | RoborockDataUpdateCoordinatorA01 | None]]`

homeassistant/components/roborock/sensor.py

[error] invalid-assignment - :340:5 - Object of type `list[RoborockSensorEntity]` is not assignable to `list[RoborockEntity]`

homeassistant/components/roborock/vacuum.py

[error] invalid-return-type - :200:16 - Return type does not match returned value: expected `ServiceResponse`, found `dict[Unknown | str, Unknown | list[dict[Unknown | str, Unknown]]]`

homeassistant/components/russound_rio/media_browser.py

[error] invalid-return-type - :87:12 - Return type does not match returned value: expected `dict[int, dict[int, str]]`, found `dict[Unknown, Unknown & ~AlwaysFalsy]`

homeassistant/components/screenlogic/binary_sensor.py

[error] invalid-assignment - :204:5 - Object of type `list[ScreenLogicPushBinarySensor]` is not assignable to `list[ScreenLogicBinarySensor]`

homeassistant/components/screenlogic/sensor.py

[error] invalid-assignment - :281:5 - Object of type `list[ScreenLogicPushSensor]` is not assignable to `list[ScreenLogicSensor]`

homeassistant/components/search/__init__.py

[error] invalid-return-type - :109:16 - Return type does not match returned value: expected `dict[str, set[str]]`, found `dict[Unknown, Unknown & ~AlwaysFalsy]`

homeassistant/components/sensirion_ble/sensor.py

[error] invalid-argument-type - :88:9 - Argument is incorrect: Expected `dict[PassiveBluetoothEntityKey, EntityDescription]`, found `dict[PassiveBluetoothEntityKey, SensorEntityDescription]`

homeassistant/components/seventeentrack/services.py

[error] invalid-return-type - :89:12 - Return type does not match returned value: expected `ServiceResponse`, found `dict[Unknown | str, Unknown | list[dict[str, Any]]]`

homeassistant/components/sftp_storage/backup.py

[error] invalid-return-type - :28:12 - Return type does not match returned value: expected `list[BackupAgent]`, found `list[SFTPBackupAgent]`

homeassistant/components/shelly/utils.py

[error] invalid-return-type - :268:12 - Return type does not match returned value: expected `list[tuple[str, str]]`, found `list[tuple[Unknown | str, Literal["button"]]]`

homeassistant/components/slack/notify.py

[error] invalid-argument-type - :173:13 - Argument to function `upload_file_to_slack` is incorrect: Expected `list[str | None]`, found `list[Unknown & ~AlwaysFalsy] & ~AlwaysFalsy`
[error] invalid-argument-type - :223:13 - Argument to function `upload_file_to_slack` is incorrect: Expected `list[str | None]`, found `list[Unknown & ~AlwaysFalsy] & ~AlwaysFalsy`

homeassistant/components/smartthings/climate.py

[error] invalid-assignment - :157:5 - Object of type `list[SmartThingsAirConditioner]` is not assignable to `list[ClimateEntity]`

homeassistant/components/smartthings/number.py

[error] invalid-assignment - :24:5 - Object of type `list[SmartThingsWasherRinseCyclesNumberEntity]` is not assignable to `list[NumberEntity]`

homeassistant/components/smartthings/switch.py

[error] invalid-assignment - :154:5 - Object of type `list[SmartThingsCommandSwitch]` is not assignable to `list[SmartThingsEntity]`

homeassistant/components/snapcast/media_player.py

[error] invalid-return-type - :535:16 - Return type does not match returned value: expected `list[str] | None`, found `list[Unknown & ~AlwaysFalsy]`

homeassistant/components/solarlog/sensor.py

[error] invalid-assignment - :318:5 - Object of type `list[SolarLogCoordinatorSensor]` is not assignable to `list[SensorEntity]`

homeassistant/components/squeezebox/media_player.py

[error] invalid-return-type - :419:16 - Return type does not match returned value: expected `list[str]`, found `list[Unknown & ~AlwaysFalsy]`

homeassistant/components/stt/legacy.py

[error] invalid-return-type - :103:12 - Return type does not match returned value: expected `list[Coroutine[Any, Any, None]]`, found `list[CoroutineType[Any, Any, None]]`

homeassistant/components/swiss_public_transport/coordinator.py

[error] invalid-return-type - :126:16 - Return type does not match returned value: expected `list[JsonValueType]`, found `list[dict[Unknown | str, Unknown | None]]`

homeassistant/components/synology_dsm/backup.py

[error] invalid-return-type - :55:12 - Return type does not match returned value: expected `list[BackupAgent]`, found `list[SynologyDSMBackupAgent]`

homeassistant/components/synology_dsm/binary_sensor.py

[error] invalid-assignment - :75:5 - Object of type `list[SynoDSMSecurityBinarySensor]` is not assignable to `list[SynoDSMSecurityBinarySensor | SynoDSMStorageBinarySensor]`

homeassistant/components/synology_dsm/sensor.py

[error] invalid-assignment - :385:5 - Object of type `list[SynoDSMUtilSensor]` is not assignable to `list[SynoDSMUtilSensor | SynoDSMStorageSensor | SynoDSMInfoSensor]`

homeassistant/components/system_bridge/__init__.py

[error] invalid-return-type - :290:16 - Return type does not match returned value: expected `ServiceResponse`, found `dict[Unknown | str, Unknown | int | list[dict[str, Any]]]`

homeassistant/components/tautulli/sensor.py

[error] invalid-assignment - :222:5 - Object of type `list[TautulliSensor]` is not assignable to `list[TautulliSensor | TautulliSessionSensor]`

homeassistant/components/telegram_bot/__init__.py

[error] invalid-return-type - :495:20 - Return type does not match returned value: expected `ServiceResponse`, found `dict[Unknown | str, Unknown | list[dict[Unknown | str, Unknown]]]`

homeassistant/components/telegram_bot/bot.py

[error] invalid-return-type - :214:16 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[Literal["file_id", "file_name", "file_mime_type", "file_size"], Any]`

homeassistant/components/todo/__init__.py

[error] invalid-assignment - :306:9 - Object of type `list[dict[str, Any]]` is not assignable to `list[JsonValueType]`
[error] invalid-argument-type - :539:46 - Argument to bound method `async_delete_todo_items` is incorrect: Expected `list[str]`, found `list[Unknown & ~AlwaysFalsy] & ~AlwaysFalsy`

homeassistant/components/tplink/__init__.py

[error] invalid-argument-type - :175:59 - Argument to bound method `async_update_entry` is incorrect: Expected `Mapping[str, Any] | UndefinedType`, found `dict[str & ~Literal["credentials_hash"], Any]`

homeassistant/components/tractive/__init__.py

[error] invalid-argument-type - :113:49 - Argument is incorrect: Expected `list[Trackables]`, found `list[Unknown & ~AlwaysFalsy]`

homeassistant/components/tts/legacy.py

[error] invalid-return-type - :198:12 - Return type does not match returned value: expected `list[Coroutine[Any, Any, None]]`, found `list[CoroutineType[Any, Any, None]]`

homeassistant/components/unifiprotect/binary_sensor.py

[error] invalid-return-type - :754:12 - Return type does not match returned value: expected `list[BaseProtectEntity]`, found `list[ProtectDiskBinarySensor]`

homeassistant/components/unifiprotect/services.py

[error] invalid-assignment - :235:5 - Object of type `list[dict[Unknown | str, Unknown | list[dict[Unknown | str, Unknown]]]]` is not assignable to `list[JsonValueType]`

homeassistant/components/upcloud/entity.py

[error] invalid-return-type - :81:16 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[Literal["uuid", "title", "hostname", "zone", "core_number", "memory_amount"], Any | None]`

homeassistant/components/usgs_earthquakes_feed/geo_location.py

[error] invalid-return-type - :278:16 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[Literal["external_id", "place", "magnitude", "time", "updated", ... omitted 3 literals], (Unknown & ~AlwaysFalsy) | (Unknown & bool)]`

homeassistant/components/velbus/light.py

[error] invalid-assignment - :41:5 - Object of type `list[VelbusLight]` is not assignable to `list[Entity]`

homeassistant/components/voip/assist_satellite.py

[error] invalid-assignment - :90:5 - Object of type `list[VoipAssistSatellite]` is not assignable to `list[VoIPEntity]`

homeassistant/components/weatherflow_cloud/sensor.py

[error] invalid-assignment - :363:5 - Object of type `list[WeatherFlowCloudSensorREST]` is not assignable to `list[SensorEntity]`

homeassistant/components/webdav/backup.py

[error] invalid-return-type - :40:12 - Return type does not match returned value: expected `list[BackupAgent]`, found `list[WebDavBackupAgent]`
[error] invalid-return-type - :231:20 - Return type does not match returned value: expected `dict[str, AgentBackup]`, found `dict[str, AgentBackup & ~AlwaysFalsy]`

homeassistant/components/whirlpool/sensor.py

[error] invalid-argument-type - :161:9 - Argument is incorrect: Expected `list[str] | None`, found `list[(Unknown & ~AlwaysFalsy) | (str & ~AlwaysFalsy)]`

homeassistant/components/wmspro/button.py

[error] invalid-assignment - :23:5 - Object of type `list[WebControlProIdentifyButton]` is not assignable to `list[WebControlProGenericEntity]`

homeassistant/components/yamaha_musiccast/entity.py

[error] invalid-assignment - :72:45 - Invalid assignment to key "connections" with declared type `set[tuple[str, str]]` on TypedDict `DeviceInfo`: value of type `set[tuple[Literal["mac"], Unknown]]`

homeassistant/components/yamaha_musiccast/media_player.py

[error] invalid-argument-type - :385:37 -
Old: Argument to bound method `extend` is incorrect: Expected `Iterable[@Todo]`, found `Unknown | Sequence[BrowseMedia] | None`
New: Argument to bound method `extend` is incorrect: Expected `Iterable[BrowseMedia]`, found `Unknown | Sequence[BrowseMedia] | None`

homeassistant/components/zwave_js/lock.py

[error] no-matching-overload - :196:9 - No overload of bound method `update` matches arguments

homeassistant/helpers/area_registry.py

[error] invalid-assignment - :389:9 - Object of type `dict[Literal["aliases", "floor_id", "humidity_entity_id", "icon", "labels", "picture", "temperature_entity_id"], set[str] | str | None]` is not assignable to `dict[str, Any]`

homeassistant/helpers/condition.py

[error] invalid-return-type - :1065:12 - Return type does not match returned value: expected `list[ConfigType | Template]`, found `list[dict[str, Any]]`

homeassistant/helpers/config_validation.py

[error] invalid-return-type - :634:12 - Return type does not match returned value: expected `list[_T@remove_falsy]`, found `list[_T@remove_falsy & ~AlwaysFalsy]`

homeassistant/helpers/entityfilter.py

[error] invalid-assignment - :153:5 - Object of type `list[str & ~AlwaysFalsy]` is not assignable to `list[str]`

homeassistant/helpers/floor_registry.py

[error] invalid-assignment - :233:9 - Object of type `dict[Literal["aliases", "icon", "level"], set[str] | str | None | int]` is not assignable to `dict[str, Any]`

homeassistant/helpers/integration_platform.py

[error] invalid-return-type - :136:12 - Return type does not match returned value: expected `list[Future[Awaitable[None] | None]]`, found `list[Future[Unknown] & ~AlwaysFalsy]`

homeassistant/helpers/label_registry.py

[error] invalid-assignment - :195:9 - Object of type `dict[Literal["color", "description", "icon"], str | None]` is not assignable to `dict[str, Any]`

homeassistant/helpers/llm.py

[error] invalid-assignment - :590:9 - Object of type `list[IntentTool]` is not assignable to `list[Tool]`

homeassistant/helpers/template/__init__.py

[error] invalid-assignment - :296:1 - Object of type `dict[<class 'dict'> | <class 'list'> | <class 'set'>, type]` is not assignable to `dict[type, type]`

homeassistant/helpers/translation.py

[error] invalid-return-type - :81:12 - Return type does not match returned value: expected `dict[str, dict[str, Any] | str]`, found `dict[str, (dict[str, Any] & ~AlwaysFalsy) | (str & ~AlwaysFalsy)]`

homeassistant/util/dt.py

[error] invalid-assignment - :284:9 - Object of type `dict[str, float]` is not assignable to `dict[str, int | float]`

cwltool (https://github.com/common-workflow-language/cwltool)

cwltool/main.py

[error] invalid-assignment - :989:17 - Object of type `list[str & ~Literal[""]]` is not assignable to `list[str]`

cwltool/workflow_job.py

[error] invalid-argument-type - :1019:25 - Argument to function `object_from_state` is incorrect: Expected `list[MutableMapping[str, @Todo | None]]`, found `list[dict[Unknown | str, Unknown | str]]`

dd-trace-py (https://github.com/DataDog/dd-trace-py)

ddtrace/vendor/dogstatsd/base.py

[error] invalid-argument-type - :361:33 - Argument to bound method `append` is incorrect: Expected `str & ~AlwaysFalsy`, found `str`

benchmarks/bm/flask_utils.py

[error] invalid-argument-type - :21:25 - Argument to bound method `append` is incorrect: Expected `int | float`, found `bytes`

ddtrace/appsec/_iast/_taint_tracking/aspects.py

[error] invalid-assignment - :773:9 - Object of type `list[(@Todo & ~None) | bytes | str]` is not assignable to `list[@Todo | None]`

ddtrace/internal/ci_visibility/recorder.py

[error] invalid-argument-type - :736:35 - Argument to bound method `append` is incorrect: Expected `(Unknown & ~CIVisibilitySpanForwarder) | (TraceProcessor & ~CIVisibilitySpanForwarder)`, found `TraceFilter & ~AlwaysFalsy`
[error] invalid-argument-type - :737:34 - Argument to bound method `configure` is incorrect: Expected `list[TraceProcessor] | None`, found `list[(Unknown & ~CIVisibilitySpanForwarder) | (TraceProcessor & ~CIVisibilitySpanForwarder)]`

ddtrace/llmobs/_llmobs.py

[error] invalid-assignment - :985:9 - Object of type `dict[Unknown | str, list[Unknown | str] | Literal[True]]` is not assignable to `dict[str, list[str] | bool]`

ddtrace/settings/errortracking.py

[error] invalid-return-type - :12:12 - Return type does not match returned value: expected `list[str]`, found `list[str & ~Literal[""]]`

tests/appsec/contrib_appsec/utils.py

[error] invalid-assignment - :1008:5 - Method `__setitem__` of type `bound method dict[str, dict[str, dict[str, str]]].__setitem__(key: str, value: dict[str, dict[str, str]], /) -> None` cannot be called with a key of type `Literal["attack"]` and a value of type `Literal["yqrweytqwreasldhkuqwgervflnmlnli"]` on object of type `dict[str, dict[str, dict[str, str]]]`

tests/contrib/vertexai/test_vertexai_llmobs.py

[error] no-matching-overload - :747:25 - No overload of bound method `join` matches arguments

tests/debugging/exploration/_profiler.py

[warning] possibly-missing-attribute - :42:46 - Attribute `__code__` on type `FullyNamedFunction | Unknown` may be missing
[warning] possibly-missing-attribute - :50:37 - Attribute `__code__` on type `FullyNamedFunction | Unknown` may be missing

dedupe (https://github.com/dedupeio/dedupe)

dedupe/branch_and_bound.py

[error] invalid-return-type - :29:12 - Return type does not match returned value: expected `dict[Any, frozenset[int]]`, found `dict[Any, frozenset[int] & ~AlwaysFalsy]`

discord.py (https://github.com/Rapptz/discord.py)

discord/app_commands/tree.py

[error] invalid-assignment - :272:9 - Object of type `dict[tuple[Unknown, int, Unknown], Unknown]` is not assignable to `dict[tuple[str, int | None, int], ContextMenu]`

discord/audit_logs.py

[error] invalid-return-type - :124:12 - Return type does not match returned value: expected `list[GuildChannel | Thread | Object]`, found `list[(Thread & ~AlwaysFalsy) | (@Todo & ~AlwaysFalsy) | Object]`
[error] invalid-return-type - :140:12 - Return type does not match returned value: expected `list[Role | Object]`, found `list[(Role & ~AlwaysFalsy) | Object]`
[error] invalid-return-type - :146:16 - Return type does not match returned value: expected `list[ForumTag | Object]`, found `list[(@Todo & ~AlwaysFalsy) | Object]`
[error] invalid-return-type - :147:12 - Return type does not match returned value: expected `list[ForumTag | Object]`, found `list[Object]`

discord/embeds.py

[error] invalid-assignment - :758:17 - Method `__setitem__` of type `bound method dict[Literal["itle", "rl", "ype", "timestamp", "colour", ... omitted 9 literals], Any].__setitem__(key: Literal["itle", "rl", "ype", "timestamp", "colour", ... omitted 9 literals], value: Any, /) -> None` cannot be called with a key of type `Literal["color"]` and a value of type `Any` on object of type `dict[Literal["itle", "rl", "ype", "timestamp", "colour", ... omitted 9 literals], Any]`
[error] invalid-assignment - :773:13 - Method `__setitem__` of type `bound method dict[Literal["itle", "rl", "ype", "timestamp", "colour", ... omitted 9 literals], Any].__setitem__(key: Literal["itle", "rl", "ype", "timestamp", "colour", ... omitted 9 literals], value: Any, /) -> None` cannot be called with a key of type `Literal["type"]` and a value of type `Unknown & ~AlwaysFalsy` on object of type `dict[Literal["itle", "rl", "ype", "timestamp", "colour", ... omitted 9 literals], Any]`
[error] invalid-assignment - :776:13 - Method `__setitem__` of type `bound method dict[Literal["itle", "rl", "ype", "timestamp", "colour", ... omitted 9 literals], Any].__setitem__(key: Literal["itle", "rl", "ype", "timestamp", "colour", ... omitted 9 literals], value: Any, /) -> None` cannot be called with a key of type `Literal["description"]` and a value of type `Unknown & ~AlwaysFalsy` on object of type `dict[Literal["itle", "rl", "ype", "timestamp", "colour", ... omitted 9 literals], Any]`
[error] invalid-assignment - :779:13 - Method `__setitem__` of type `bound method dict[Literal["itle", "rl", "ype", "timestamp", "colour", ... omitted 9 literals], Any].__setitem__(key: Literal["itle", "rl", "ype", "timestamp", "colour", ... omitted 9 literals], value: Any, /) -> None` cannot be called with a key of type `Literal["url"]` and a value of type `Unknown & ~AlwaysFalsy` on object of type `dict[Literal["itle", "rl", "ype", "timestamp", "colour", ... omitted 9 literals], Any]`
[error] invalid-assignment - :782:13 - Method `__setitem__` of type `bound method dict[Literal["itle", "rl", "ype", "timestamp", "colour", ... omitted 9 literals], Any].__setitem__(key: Literal["itle", "rl", "ype", "timestamp", "colour", ... omitted 9 literals], value: Any, /) -> None` cannot be called with a key of type `Literal["title"]` and a value of type `Unknown & ~AlwaysFalsy` on object of type `dict[Literal["itle", "rl", "ype", "timestamp", "colour", ... omitted 9 literals], Any]`
[warning] unused-ignore-comment - :594:71 - Unused blanket `type: ignore` directive

discord/message.py

[error] invalid-assignment - :964:5 - Object of type `list[Literal["_edited_timestamp", "_cs_channel_mentions", "_cs_raw_mentions", "_cs_clean_content", "_cs_raw_channel_mentions", ... omitted 32 literals]]` is not assignable to attribute `_CACHED_SLOTS` of type `list[str]`

django-stubs (https://github.com/typeddjango/django-stubs)

mypy_django_plugin/transformers/init_create.py

[error] invalid-argument-type - :44:59 - Argument to function `get_actual_types` is incorrect: Expected `list[str]`, found `list[str & ~Literal["pk"]]`

dragonchain (https://github.com/dragonchain/dragonchain)

dragonchain/lib/dao/interchain_dao.py

[error] invalid-return-type - :88:12 - Return type does not match returned value: expected `list[InterchainModel]`, found `list[BitcoinNetwork | EthereumNetwork | BinanceNetwork]`

dulwich (https://github.com/dulwich/dulwich)

dulwich/ignore.py

[error] invalid-argument-type - :638:35 - Argument to bound method `insert` is incorrect: Expected `tuple[Literal[0], Unknown]`, found `tuple[int, Unknown & ~None]`

dulwich/client.py

[error] invalid-return-type - :222:12 - Return type does not match returned value: expected `dict[bytes, bytes | None]`, found `dict[bytes, bytes]`

dulwich/diff_tree.py

[error] invalid-argument-type - :403:26 -
Old: Argument to function `_all_eq` is incorrect: Expected `(@Todo, /) -> Literal["delete"]`, found `def change_type(c: TreeChange) -> str`
New: Argument to function `_all_eq` is incorrect: Expected `(Unknown & ~None, /) -> Literal["delete"]`, found `def change_type(c: TreeChange) -> str`

dulwich/porcelain.py

[error] invalid-assignment - :4019:5 - Object of type `list[tuple[bytes, bytes, bytes & ~Literal[b"HEAD"]]]` is not assignable to `list[tuple[bytes, bytes, bytes]]`

dulwich/refs.py

[error] invalid-return-type - :1588:12 - Return type does not match returned value: expected `T@strip_peeled_refs`, found `dict[bytes, bytes | None]`
[error] invalid-return-type - :1604:12 - Return type does not match returned value: expected `tuple[T@split_peeled_refs, dict[bytes, bytes]]`, found `tuple[dict[bytes, bytes | None], dict[bytes, bytes]]`
[error] invalid-return-type - :1883:12 - Return type does not match returned value: expected `T@filter_ref_prefix`, found `dict[bytes, bytes | None]`

egglog-python (https://github.com/egraphs-good/egglog-python)

python/egglog/egraph.py

[error] invalid-assignment - :751:5 - Object of type `list[RuntimeExpr]` is not assignable to `list[object]`

flake8 (https://github.com/pycqa/flake8)

src/flake8/utils.py

[error] invalid-return-type - :42:12 - Return type does not match returned value: expected `list[str]`, found `list[@Todo & ~AlwaysFalsy]`

freqtrade (https://github.com/freqtrade/freqtrade)

freqtrade/commands/data_commands.py

[error] invalid-assignment - :172:21 - Not enough values to unpack: Expected 6
[error] invalid-assignment - :226:21 - Not enough values to unpack: Expected 4

freqtrade/config_schema/config_schema.py

[error] invalid-assignment - :25:1 - Object of type `dict[RPCMessageType, dict[Unknown | str, Unknown | str]]` is not assignable to `dict[str, dict[str, str]]`

freqtrade/plugins/pairlist/AgeFilter.py

[error] invalid-assignment - :103:9 - Object of type `list[tuple[str, Literal["1d"], Unknown]]` is not assignable to `list[tuple[str, str, CandleType]]`

freqtrade/plugins/pairlist/VolatilityFilter.py

[error] invalid-assignment - :118:9 - Object of type `list[tuple[str, Literal["1d"], Unknown]]` is not assignable to `list[tuple[str, str, CandleType]]`

freqtrade/plugins/pairlist/rangestabilityfilter.py

[error] invalid-assignment - :115:9 - Object of type `list[tuple[str, Literal["1d"], Unknown]]` is not assignable to `list[tuple[str, str, CandleType]]`

freqtrade/optimize/hyperopt/hyperopt.py

[error] invalid-return-type - :213:16 - Return type does not match returned value: expected `tuple[list[Any], list[bool]]`, found `tuple[list[Unknown], list[Literal[False]]]`

hydpy (https://github.com/hydpy-dev/hydpy)

hydpy/core/testtools.py

[error] invalid-argument-type - :1722:37 - Argument to bound method `remove` is incorrect: Expected `type[Sequence_] & ~type[InputSequence] & ~type[InletSequence] & ~type[ObserverSequence] & ~type[ReceiverSequence] & ~type[StateSequence] & ~type[LogSequence]`, found `type[Sequence_]`
[error] invalid-assignment - :1988:5 - Object of type `dict[Literal["CONTROLPARAMETERS", "DERIVEDPARAMETERS", "FIXEDPARAMETERS", "SOLVERPARAMETERS", "REQUIREDSEQUENCES", "UPDATEDSEQUENCES", "RESULTSEQUENCES"], set[Unknown]]` is not assignable to `dict[str, set[type[Variable]]]`
[error] invalid-assignment - :1991:5 - Object of type `dict[Literal["CONTROLPARAMETERS", "DERIVEDPARAMETERS", "FIXEDPARAMETERS", "SOLVERPARAMETERS", "REQUIREDSEQUENCES", "UPDATEDSEQUENCES", "RESULTSEQUENCES"], set[Unknown]]` is not assignable to `dict[str, set[type[Variable]]]`

hydpy/docs/draw_model_sketches.py

[error] invalid-argument-type - :1262:9 - Argument to bound method `extend` is incorrect: Expected `Iterable[Unknown & ~UZ & ~LZ]`, found `tuple[UZ, UZ, SG1, SG1, SG23, SG23]`
[error] invalid-argument-type - :1291:9 - Argument to bound method `extend` is incorrect: Expected `Iterable[Unknown & ~LZ & ~UZ_SG1_BW & ~SG23]`, found `tuple[BW, BW, BW, BW, LZ]`

hydra-zen (https://github.com/mit-ll-responsible-ai/hydra-zen)

src/hydra_zen/structured_configs/_implementations.py

[error] invalid-assignment - :3248:9 - Object of type `list[tuple[str, Any]]` is not assignable to `list[tuple[str, type] | tuple[str, type, Any]]`
[error] invalid-return-type - :1324:20 -
Old: Return type does not match returned value: expected `_T@_sanitize_collection`, found `dict[@Todo, @Todo]`
New: Return type does not match returned value: expected `_T@_sanitize_collection`, found `dict[Unknown, Unknown]`

ibis (https://github.com/ibis-project/ibis)

ibis/backends/athena/__init__.py

[error] invalid-argument-type - :287:27 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`
[error] invalid-argument-type - :583:13 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`

ibis/backends/bigquery/datatypes.py

[error] invalid-argument-type - :50:31 -
Old: Argument is incorrect: Expected `bool`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `bool`, found `dict[Unknown, Unknown]`
[error] invalid-argument-type - :67:27 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`

ibis/backends/bigquery/tests/unit/test_compiler.py

[error] invalid-argument-type - :273:26 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, Literal["string"]]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[str, Literal["string"]]`

ibis/backends/databricks/__init__.py

[error] invalid-argument-type - :63:13 -
Old: Argument is incorrect: Expected `bool`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `bool`, found `dict[Unknown, DataType]`
[error] invalid-argument-type - :82:9 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Any, DataType]`
[error] invalid-argument-type - :608:13 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`

ibis/backends/datafusion/__init__.py

[error] invalid-argument-type - :542:13 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[str | @Todo, DataType]`

ibis/backends/duckdb/__init__.py

[error] invalid-argument-type - :329:13 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`
[error] invalid-argument-type - :1714:13 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`

ibis/backends/exasol/__init__.py

[error] invalid-argument-type - :274:13 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`

ibis/backends/flink/datatypes.py

[error] invalid-argument-type - :75:17 -
Old: Argument is incorrect: Expected `bool`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `bool`, found `dict[Unknown, Unknown]`

ibis/backends/flink/ddl.py

[error] invalid-argument-type - :128:42 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`
[error] invalid-argument-type - :136:38 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`

ibis/backends/impala/ddl.py

[error] invalid-argument-type - :141:42 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`
[error] invalid-argument-type - :149:38 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`

ibis/backends/mysql/__init__.py

[error] invalid-argument-type - :231:27 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`

ibis/backends/oracle/__init__.py

[error] invalid-argument-type - :377:27 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, DataType]`

ibis/backends/polars/__init__.py

[error] invalid-assignment - :418:13 - Object of type `dict[Node, Any]` is not assignable to `Mapping[Expr, Any] | None`

ibis/backends/polars/rewrites.py

[error] invalid-argument-type - :33:13 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`

ibis/backends/postgres/__init__.py

[error] invalid-argument-type - :497:13 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`

ibis/backends/pyspark/datatypes.py

[error] invalid-argument-type - :64:30 -
Old: Argument is incorrect: Expected `bool`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `bool`, found `dict[Unknown, Unknown]`
[error] invalid-argument-type - :125:27 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`

ibis/backends/risingwave/__init__.py

[error] invalid-argument-type - :309:13 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`

ibis/backends/snowflake/__init__.py

[error] invalid-argument-type - :574:13 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`
[error] invalid-argument-type - :590:13 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`

ibis/backends/sql/compilers/bigquery/udf/core.py

[error] invalid-argument-type - :500:34 - Argument to bound method `__init__` is incorrect: Expected `list[expr]`, found `list[arg]`

ibis/backends/sql/datatypes.py

[error] invalid-assignment - :1316:9 -
Old: Object of type `dict[@Todo, @Todo]` is not assignable to `tuple[Unknown, ...]`
New: Object of type `dict[Unknown, Array[Unknown]]` is not assignable to `tuple[Unknown, ...]`

ibis/backends/sql/rewrites.py

[error] invalid-argument-type - :68:23 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`
[error] invalid-argument-type - :324:9 -
Old: Argument is incorrect: Expected `FrozenDict[str, Value[Unknown, Any]]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenDict[str, Value[Unknown, Any]]`, found `dict[Unknown, Unknown]`
[error] invalid-argument-type - :476:30 -
Old: Argument is incorrect: Expected `FrozenDict[str, Value[Unknown, Any]]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenDict[str, Value[Unknown, Any]]`, found `dict[Unknown, Unknown]`

ibis/backends/sqlite/__init__.py

[error] invalid-argument-type - :274:13 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Any, Unknown]`

ibis/backends/trino/__init__.py

[error] invalid-argument-type - :184:13 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`
[error] invalid-argument-type - :345:13 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`

ibis/expr/api.py

[error] invalid-argument-type - :1189:27 - Argument to bound method `append` is incorrect: Expected `tuple[(Unknown & ~AlwaysFalsy) | (int & ~AlwaysFalsy), Unknown | str]`, found `tuple[Literal[0], Literal["s"]]`
[error] invalid-argument-type - :1191:46 -
Old: Argument is incorrect: Expected `bool`, found `@Todo | str`
New: Argument is incorrect: Expected `bool`, found `Unknown | str`

ibis/expr/datatypes/value.py

[error] invalid-argument-type - :48:22 -
Old: Argument is incorrect: Expected `bool`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `bool`, found `dict[str, Unknown]`

ibis/expr/operations/arrays.py

[error] invalid-argument-type - :223:17 -
Old: Argument is incorrect: Expected `bool`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `bool`, found `dict[str, Unknown]`

ibis/expr/operations/relations.py

[error] invalid-argument-type - :133:23 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`
[error] invalid-argument-type - :251:23 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`
[error] invalid-argument-type - :328:23 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`
[error] invalid-argument-type - :467:23 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[Unknown, Unknown]`

ibis/expr/operations/udf.py

[error] no-matching-overload - :141:9 - No overload of bound method `update` matches arguments
[error] no-matching-overload - :141:9 - No overload of bound method `update` matches arguments

ibis/expr/types/joins.py

[error] invalid-argument-type - :166:54 - Argument to bound method `from_targets` is incorrect: Expected `Mapping[Node, Node] | None`, found `dict[Field, Unknown & Field]`
[error] invalid-argument-type - :167:64 - Argument to bound method `from_targets` is incorrect: Expected `Mapping[Node, Node] | None`, found `dict[Field, Unknown & Field]`

ibis/formats/numpy.py

[error] invalid-argument-type - :107:27 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[str, DataType]`

ibis/formats/pandas.py

[error] invalid-argument-type - :75:27 -
Old: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `FrozenOrderedDict[str, DataType]`, found `dict[str | Any, Unknown]`

ibis/formats/pyarrow.py

[error] invalid-argument-type - :103:30 -
Old: Argument is incorrect: Expected `bool`, found `dict[@Todo, @Todo]`
New: Argument is incorrect: Expected `bool`, found `dict[Unknown, Unknown]`

ibis/legacy/udf/vectorized.py

[error] invalid-return-type - :191:12 - Return type does not match returned value: expected `DataFrame`, found `@Todo | Series[Any]`

ignite (https://github.com/pytorch/ignite)

ignite/handlers/lr_finder.py

[error] invalid-argument-type - :134:21 - Argument to bound method `__init__` is incorrect: Expected `list[ParamScheduler]`, found `list[PiecewiseLinear]`

ignite/handlers/polyaxon_logger.py

[error] invalid-assignment - :312:9 - Method `__setitem__` of type `bound method dict[str, float].__setitem__(key: str, value: float, /) -> None` cannot be called with a key of type `Literal["step"]` and a value of type `Unknown | int` on object of type `dict[str, float]`

isort (https://github.com/pycqa/isort)

isort/main.py

[error] invalid-assignment - :941:9 - Method `__setitem__` of type `bound method dict[str, Any & ~AlwaysFalsy].__setitem__(key: str, value: Any & ~AlwaysFalsy, /) -> None` cannot be called with a key of type `Literal["order_by_type"]` and a value of type `Literal[False]` on object of type `dict[str, Any & ~AlwaysFalsy]`
[error] invalid-assignment - :944:9 - Method `__setitem__` of type `bound method dict[str, Any & ~AlwaysFalsy].__setitem__(key: str, value: Any & ~AlwaysFalsy, /) -> None` cannot be called with a key of type `Literal["follow_links"]` and a value of type `Literal[False]` on object of type `dict[str, Any & ~AlwaysFalsy]`
[error] invalid-assignment - :951:13 - Method `__setitem__` of type `bound method dict[str, Any & ~AlwaysFalsy].__setitem__(key: str, value: Any & ~AlwaysFalsy, /) -> None` cannot be called with a key of type `Literal["float_to_top"]` and a value of type `Literal[False]` on object of type `dict[str, Any & ~AlwaysFalsy]`

jax (https://github.com/google/jax)

jax/experimental/_private_mm/examples/example_pp.py

[error] invalid-argument-type - :207:21 - Method `__getitem__` of type `bound method dict[tuple[int, Literal[0]], Unknown].__getitem__(key: tuple[int, Literal[0]], /) -> Unknown` cannot be called with key of type `tuple[int, int]` on object of type `dict[tuple[int, Literal[0]], Unknown]`
[error] invalid-assignment - :214:25 - Method `__setitem__` of type `bound method dict[tuple[int, Literal[0]], Unknown].__setitem__(key: tuple[int, Literal[0]], value: Unknown, /) -> None` cannot be called with a key of type `tuple[int, int]` and a value of type `Unknown` on object of type `dict[tuple[int, Literal[0]], Unknown]`
[error] invalid-argument-type - :226:35 - Argument to bound method `pop` is incorrect: Expected `tuple[int, Literal[0]]`, found `tuple[int, int]`

jax/experimental/roofline/rooflines.py

[error] invalid-argument-type - :459:5 - Argument is incorrect: Expected `dict[str, int]`, found `dict[str, Literal[0]]`
[error] invalid-argument-type - :460:5 - Argument is incorrect: Expected `dict[str, int]`, found `dict[str, Literal[0]]`

jax/_src/core.py

[error] invalid-assignment - :4057:3 - Object of type `dict[@Todo & ~Literal, None]` is not assignable to `dict[Var, JaxprEqn | None]`
[warning] unused-ignore-comment - :3411:34 - Unused blanket `type: ignore` directive

jax/_src/internal_test_util/test_harnesses.py

[error] unsupported-operator - :256:14 - Operator `-` is unsupported between objects of type `set[LiteralString]` and `set[Unknown | str]`
[error] unsupported-operator - :259:14 - Operator `-` is unsupported between objects of type `set[LiteralString] | Unknown` and `set[Unknown | str]`
[error] unsupported-operator - :262:14 - Operator `-` is unsupported between objects of type `set[LiteralString] | Unknown` and `set[Unknown | str]`
[error] unsupported-operator - :266:14 - Operator `-` is unsupported between objects of type `set[LiteralString] | Unknown` and `set[Unknown | str]`
[error] unsupported-operator - :270:14 - Operator `-` is unsupported between objects of type `set[LiteralString] | Unknown` and `set[Unknown | str]`
[error] unsupported-operator - :274:14 - Operator `-` is unsupported between objects of type `set[LiteralString] | Unknown` and `set[Unknown | str]`
[error] unsupported-operator - :278:14 - Operator `-` is unsupported between objects of type `set[LiteralString] | Unknown` and `set[Unknown | str]`

jax/_src/interpreters/partial_eval.py

[error] invalid-return-type - :2587:12 - Return type does not match returned value: expected `dict[int, Hashable]`, found `dict[int, Unknown & ~None]`
[warning] unused-ignore-comment - :1482:66 - Unused blanket `type: ignore` directive
[warning] unused-ignore-comment - :1821:32 - Unused blanket `type: ignore` directive
[warning] unused-ignore-comment - :2740:63 - Unused blanket `type: ignore` directive

jax/_src/interpreters/pxla.py

[error] invalid-return-type - :604:10 - Return type does not match returned value: expected `dict[Hashable, int]`, found `dict[Unknown & ~None, int]`
[error] invalid-argument-type - :3255:47 -
Old: Argument is incorrect: Expected `tuple[str, ...] | None`, found `list[@Todo] | tuple[Literal[""], ...]`
New: Argument is incorrect: Expected `tuple[str, ...] | None`, found `list[Unknown] | tuple[Literal[""], ...]`

jax/_src/lax/control_flow/loops.py

[warning] possibly-missing-attribute - :1323:38 -
Old: Attribute `in_avals` on type `int | tuple[@Todo, ...] | ClosedJaxpr` may be missing
New: Attribute `in_avals` on type `int | tuple[Unknown, ...] | ClosedJaxpr` may be missing
[warning] possibly-missing-attribute - :1324:38 -
Old: Attribute `out_avals` on type `int | tuple[@Todo, ...] | ClosedJaxpr` may be missing
New: Attribute `out_avals` on type `int | tuple[Unknown, ...] | ClosedJaxpr` may be missing

jax/_src/lax/lax.py

[error] invalid-return-type - :258:12 - Return type does not match returned value: expected `tuple[list[Tracer], list[int | None]]`, found `tuple[list[Tracer], list[None | (int & ~Tracer)]]`

jax/_src/mesh_utils.py

[error] invalid-assignment - :282:3 - Object of type `list[tuple[()]]` is not assignable to `list[tuple[int, ...]]`

jax/_src/numpy/lax_numpy.py

[error] invalid-argument-type - :3101:30 - Argument to function `split` is incorrect: Expected `Sequence[int]`, found `list[Unknown | signedinteger[_64Bit]]`

jax/_src/numpy/linalg.py

[error] invalid-assignment - :2123:3 - Object of type `list[tuple[int, int]]` is not assignable to `list[tuple[int, ...]]`

jax/_src/pallas/hlo_interpreter.py

[error] invalid-argument-type - :394:33 - Argument to function `pad` is incorrect: Expected `Sequence[tuple[int, int, int]]`, found `list[tuple[@Todo, Literal[0]]]`

jax/_src/pallas/mosaic/pallas_call_registration.py

[error] invalid-assignment - :339:3 -
Old: Object of type `list[@Todo]` is not assignable to `tuple[AbstractValue, ...]`
New: Object of type `list[ShapedArray]` is not assignable to `tuple[AbstractValue, ...]`

jax/_src/pallas/mosaic_gpu/lowering.py

[error] invalid-argument-type - :955:9 - Argument is incorrect: Expected `dict[Sequence[Hashable], int]`, found `dict[Unknown, Literal[0]]`

jax/_src/pallas/mosaic_gpu/pipeline.py

[error] invalid-argument-type - :427:38 - Argument to function `len` is incorrect: Expected `Sized`, found `Sequence[@Todo | int | None] | None`
[error] invalid-argument-type - :892:40 - Argument to function `len` is incorrect: Expected `Sized`, found `Sequence[@Todo | int | None] | None`

jax/_src/pallas/pallas_call.py

[warning] unused-ignore-comment - :1544:44 - Unused blanket `type: ignore` directive
[error] invalid-assignment - :113:3 -
Old: Object of type `list[@Todo]` is not assignable to `tuple[AbstractValue, ...]`
New: Object of type `list[ShapedArray | Unknown | (AbstractValue & ~ShapedArrayWithMemorySpace)]` is not assignable to `tuple[AbstractValue, ...]`

jax/_src/pallas/primitives.py

[error] unresolved-attribute - :962:9 - Type `AbstractValue` has no attribute `shape`
[error] unresolved-attribute - :962:21 - Type `AbstractValue` has no attribute `dtype`

jax/_src/pallas/triton/lowering.py

[error] invalid-argument-type - :416:51 - Argument is incorrect: Expected `Sequence[ShapedArray]`, found `list[AbstractValue]`

jax/_src/pjit.py

[warning] unused-ignore-comment - :718:60 - Unused blanket `type: ignore` directive

jax/_src/shard_map.py

[error] invalid-argument-type - :1033:35 - Argument to function `_check_names` is incorrect: Expected `Sequence[ShapedArray]`, found `list[AbstractValue]`

jax/experimental/_private_mm/examples/example_overlap.py

[error] invalid-argument-type - :78:46 - Method `__getitem__` of type `bound method dict[tuple[int, Literal[0]], Unknown].__getitem__(key: tuple[int, Literal[0]], /) -> Unknown` cannot be called with key of type `tuple[int, int]` on object of type `dict[tuple[int, Literal[0]], Unknown]`
[error] invalid-assignment - :84:21 - Method `__setitem__` of type `bound method dict[tuple[int, Literal[0]], Unknown].__setitem__(key: tuple[int, Literal[0]], value: Unknown, /) -> None` cannot be called with a key of type `tuple[int, int]` and a value of type `Unknown` on object of type `dict[tuple[int, Literal[0]], Unknown]`

jax/experimental/jax2tf/jax2tf.py

[error] invalid-assignment - :654:3 -
Old: Method `__setitem__` of type `bound method dict[str, int | tuple[@Todo, ...] | list[@Todo]].__setitem__(key: str, value: int | tuple[@Todo, ...] | list[@Todo], /) -> None` cannot be called with a key of type `Literal["module"]` and a value of type `bytes` on object of type `dict[str, int | tuple[@Todo, ...] | list[@Todo]]`
New: Method `__setitem__` of type `bound method dict[str, int | tuple[@Todo, ...] | list[Any]].__setitem__(key: str, value: int | tuple[@Todo, ...] | list[Any], /) -> None` cannot be called with a key of type `Literal["module"]` and a value of type `bytes` on object of type `dict[str, int | tuple[@Todo, ...] | list[Any]]`

jax/experimental/jax2tf/tests/models_test_main.py

[error] missing-argument - :195:15 - No argument provided for required parameter 1

jax/experimental/sparse/bcoo.py

[error] invalid-assignment - :2329:3 - Object of type `list[None]` is not assignable to `list[int | None]`

koda-validate (https://github.com/keithasaurus/koda-validate)

koda_validate/union.py

[error] invalid-assignment - :158:9 - Object of type `list[(Unknown & ~AlwaysFalsy) | (Validator[T2@typed] & ~AlwaysFalsy) | (Validator[T3@typed] & ~AlwaysFalsy) | ... omitted 5 union elements]` is not assignable to `list[Validator[Any]]`

kornia (https://github.com/kornia/kornia)

kornia/contrib/models/efficient_vit/utils/network.py

[warning] unused-ignore-comment - :30:69 - Unused blanket `type: ignore` directive

kornia/feature/scale_space_detector.py

[error] invalid-assignment - :364:9 - Object of type `list[int]` is not assignable to `list[int | float]`

kornia/metrics/mean_average_precision.py

[error] invalid-return-type - :179:12 - Return type does not match returned value: expected `tuple[Unknown, dict[int, int | float]]`, found `tuple[Unknown, dict[int, float]]`

manticore (https://github.com/trailofbits/manticore)

tests/ethereum/test_general.py

[error] invalid-argument-type - :782:28 - Argument to bound method `add` is incorrect: Expected `Literal["user_00000000.summary", "user_00000000.constraints", "user_00000000.pkl", "user_00000000.tx.json", "user_00000000.tx", "user_00000000.trace", "user_00000000.logs"]`, found `Literal["state_00000000.pkl"]`

materialize (https://github.com/MaterializeInc/materialize)

misc/python/materialize/cli/cloudbench.py

[error] invalid-assignment - :124:5 - Object of type `list[None]` is not assignable to `list[BenchSuccessResult | BenchFailureLogs | None]`

misc/python/materialize/file_util.py

[error] invalid-return-type - :39:12 - Return type does not match returned value: expected `list[str]`, found `list[str & ~Literal[""]]`

test/data-ingest/mzcompose.py

[error] invalid-assignment - :194:9 - Method `__setitem__` of type `bound method dict[Literal["materialized", "zookeeper", "kafka", "schema-registry", "postgres", "mysql", "sql-server"], Unknown].__setitem__(key: Literal["materialized", "zookeeper", "kafka", "schema-registry", "postgres", "mysql", "sql-server"], value: Unknown, /) -> None` cannot be called with a key of type `Literal["materialized2"]` and a value of type `Literal[26875]` on object of type `dict[Literal["materialized", "zookeeper", "kafka", "schema-registry", "postgres", "mysql", "sql-server"], Unknown]`

meson (https://github.com/mesonbuild/meson)

mesonbuild/cmake/toolchain.py

[error] no-matching-overload - :232:31 - No overload of bound method `join` matches arguments

mesonbuild/compilers/mixins/visualstudio.py

[error] invalid-return-type - :187:16 - Return type does not match returned value: expected `list[str]`, found `list[str] | list[str & ~Literal["/Gw"]]`

mesonbuild/dependencies/cuda.py

[error] invalid-return-type - :181:16 - Return type does not match returned value: expected `list[tuple[str, bool]]`, found `list[tuple[str, Literal[False]]]`

mesonbuild/backend/backends.py

[error] invalid-return-type - :1271:16 - Return type does not match returned value: expected `list[str]`, found `list[Unknown] | list[bytes]`
[error] invalid-assignment - :1572:9 - Object of type `list[str | (ExternalProgram & ~str)]` is not assignable to `list[str | ExternalProgram]`

mesonbuild/build.py

[warning] possibly-missing-attribute - :2075:29 - Attribute `absolute_path` on type `Unknown | FileInTargetPrivateDir | (File & ~CustomTarget & ~CustomTargetIndex & ~GeneratedList & ~str)` may be missing

mesonbuild/cargo/interpreter.py

[error] invalid-argument-type - :132:38 - Argument to bound method `array` is incorrect: Expected `list[BaseNode]`, found `list[StringNode]`
[error] invalid-argument-type - :448:36 - Argument to bound method `array` is incorrect: Expected `list[BaseNode]`, found `list[StringNode]`
[error] invalid-argument-type - :476:36 - Argument to bound method `array` is incorrect: Expected `list[BaseNode]`, found `list[StringNode]`
[error] invalid-argument-type - :519:38 - Argument to bound method `array` is incorrect: Expected `list[BaseNode]`, found `list[StringNode]`

mesonbuild/cargo/manifest.py

[error] invalid-assignment - :116:17 - Method `__setitem__` of type `bound method dict[str & ~Literal["workspace"], object].__setitem__(key: str & ~Literal["workspace"], value: object, /) -> None` cannot be called with a key of type `str` and a value of type `@Todo` on object of type `dict[str & ~Literal["workspace"], object]`
[error] invalid-assignment - :118:21 - Method `__setitem__` of type `bound method dict[str & ~Literal["workspace"], object].__setitem__(key: str & ~Literal["workspace"], value: object, /) -> None` cannot be called with a key of type `str` and a value of type `object` on object of type `dict[str & ~Literal["workspace"], object]`
[error] invalid-argument-type - :118:46 - Method `__getitem__` of type `bound method dict[str & ~Literal["workspace"], object].__getitem__(key: str & ~Literal["workspace"], /) -> object` cannot be called with key of type `str` on object of type `dict[str & ~Literal["workspace"], object]`
[error] invalid-argument-type - :120:21 - Method `__getitem__` of type `bound method dict[str & ~Literal["workspace"], object].__getitem__(key: str & ~Literal["workspace"], /) -> object` cannot be called with key of type `str` on object of type `dict[str & ~Literal["workspace"], object]`
[error] invalid-assignment - :127:17 - Method `__setitem__` of type `bound method dict[str & ~Literal["workspace"], object].__setitem__(key: str & ~Literal["workspace"], value: object, /) -> None` cannot be called with a key of type `str` and a value of type `object` on object of type `dict[str & ~Literal["workspace"], object]`
[error] invalid-return-type - :128:12 - Return type does not match returned value: expected `Mapping[str, object]`, found `dict[str & ~Literal["workspace"], object]`

mesonbuild/cmake/fileapi.py

[error] unsupported-operator - :195:21 - Operator `+=` is unsupported between objects of type `list[Path]` and `list[Unknown | dict[Unknown, Unknown]]`
[error] unsupported-operator - :200:21 - Operator `+=` is unsupported between objects of type `list[Path]` and `list[Unknown | dict[Unknown, Unknown]]`
[error] unsupported-operator - :218:17 - Operator `+=` is unsupported between objects of type `list[Path]` and `list[Unknown | dict[Unknown | str, Unknown | bool | (list[Unknown] & ~AlwaysFalsy)]]`
[error] unsupported-operator - :223:17 - Operator `+=` is unsupported between objects of type `list[Path]` and `list[Unknown | dict[Unknown | str, Unknown | bool | (list[Unknown] & ~AlwaysFalsy)]]`

mesonbuild/cmake/interpreter.py

[error] invalid-assignment - :1049:13 - Object of type `dict[IdNode, BaseNode]` is not assignable to attribute `kwargs` of type `dict[BaseNode, BaseNode]`
[error] invalid-assignment - :1061:13 - Object of type `dict[IdNode, BaseNode]` is not assignable to attribute `kwargs` of type `dict[BaseNode, BaseNode]`

mesonbuild/coredata.py

[error] no-matching-overload - :496:5 - No overload of bound method `update` matches arguments
[error] invalid-assignment - :497:5 - Object of type `dict[OptionKey, str]` is not assignable to attribute `cmd_line_options` of type `dict[OptionKey, str | None]`

mesonbuild/dependencies/cmake.py

[error] unsupported-operator - :133:9 - Operator `+=` is unsupported between objects of type `list[tuple[str, Literal[True]]]` and `list[tuple[str, Literal[False]]]`

mesonbuild/dependencies/mpi.py

[error] invalid-argument-type - :74:31 - Argument to bound method `extend` is incorrect: Expected `Iterable[str & ~AlwaysFalsy]`, found `list[Unknown | str]`
[error] invalid-argument-type - :76:31 - Argument to bound method `extend` is incorrect: Expected `Iterable[str & ~AlwaysFalsy]`, found `list[Unknown | str]`

mesonbuild/dependencies/pkgconfig.py

[error] invalid-return-type - :214:16 -
Old: Return type does not match returned value: expected `ImmutableListProtocol[str]`, found `list[@Todo]`
New: Return type does not match returned value: expected `ImmutableListProtocol[str]`, found `list[Unknown]`

mesonbuild/interpreter/interpreter.py

[error] invalid-argument-type - :1812:46 - Argument to bound method `__init__` is incorrect: Expected `list[str]`, found `list[str & ~AlwaysFalsy]`

mesonbuild/mintro.py

[error] invalid-assignment - :452:5 -
Old: Object of type `dict[Unknown | str, Unknown | str | None | list[str] | list[@Todo]]` is not assignable to `dict[str, str | list[str] | list[dict[str, str]]]`
New: Object of type `dict[Unknown | str, Unknown | str | None | list[str] | list[Unknown | str]]` is not assignable to `dict[str, str | list[str] | list[dict[str, str]]]`

mesonbuild/modules/external_project.py

[error] invalid-assignment - :190:9 - Object of type `dict[str, tuple[str, None]]` is not assignable to `dict[str, tuple[str, str | None]]`

mesonbuild/rewriter.py

[error] invalid-assignment - :969:13 - Object of type `list[BaseNode & ~StringNode]` is not assignable to `list[BaseNode]`
[error] invalid-assignment - :909:13 - Object of type `list[StringNode]` is not assignable to attribute `arguments` of type `list[BaseNode]`

mesonbuild/utils/universal.py

[error] invalid-return-type - :714:12 -
Old: Return type does not match returned value: expected `ImmutableListProtocol[str]`, found `list[@Todo]`
New: Return type does not match returned value: expected `ImmutableListProtocol[str]`, found `list[Unknown | str]`

run_project_tests.py

[error] invalid-assignment - :408:9 - Method `__setitem__` of type `bound method dict[Path, Literal[False]].__setitem__(key: Path, value: Literal[False], /) -> None` cannot be called with a key of type `Path` and a value of type `Literal[True]` on object of type `dict[Path, Literal[False]]`

test cases/common/22 object extraction/check-obj.py

[error] unsupported-operator - :19:35 -
Old: Operator `not in` is not supported for types `str` and `None`, in comparing `str` with `None | set[@Todo]`
New: Operator `not in` is not supported for types `str` and `None`, in comparing `str` with `None | set[Any]`

unittests/allplatformstests.py

[warning] possibly-missing-implicit-call - :3117:13 -
Old: Method `__setitem__` of type `Unknown | str | dict[Unknown | str, Unknown | str | dict[@Todo, @Todo]] | ... omitted 5 union elements` may be missing
New: Method `__setitem__` of type `Unknown | str | dict[Unknown | str, Unknown | str | dict[str, Any]] | ... omitted 5 union elements` may be missing
[warning] possibly-missing-implicit-call - :3143:21 -
Old: Method `__setitem__` of type `Unknown | str | dict[Unknown | str, Unknown | str | dict[@Todo, @Todo]] | ... omitted 5 union elements` may be missing
New: Method `__setitem__` of type `Unknown | str | dict[Unknown | str, Unknown | str | dict[str, Any]] | ... omitted 5 union elements` may be missing

mkdocs (https://github.com/mkdocs/mkdocs)

mkdocs/structure/toc.py

[warning] unused-ignore-comment - :24:31 - Unused blanket `type: ignore` directive

mkosi (https://github.com/systemd/mkosi)

mkosi/completion.py

[error] invalid-argument-type - :125:13 - Argument to function `to_bash_hasharray` is incorrect: Expected `Mapping[str, str | int]`, found `dict[str & ~AlwaysFalsy, str]`
[error] invalid-argument-type - :132:13 - Argument to function `to_bash_hasharray` is incorrect: Expected `Mapping[str, str | int]`, found `dict[str & ~AlwaysFalsy, str]`

mkosi/config.py

[error] call-non-callable - :4864:30 - Object of type `None` is not callable
[warning] possibly-missing-attribute - :1926:27 -
Old: Attribute `section` on type `@Todo | None` may be missing
New: Attribute `section` on type `ConfigSetting[object] | None` may be missing
[warning] possibly-missing-attribute - :1928:83 -
Old: Attribute `section` on type `@Todo | None` may be missing
New: Attribute `section` on type `ConfigSetting[object] | None` may be missing
[warning] possibly-missing-attribute - :1932:24 -
Old: Attribute `name` on type `@Todo | None` may be missing
New: Attribute `name` on type `ConfigSetting[object] | None` may be missing
[warning] possibly-missing-attribute - :1934:84 -
Old: Attribute `name` on type `@Todo | None` may be missing
New: Attribute `name` on type `ConfigSetting[object] | None` may be missing
[warning] possibly-missing-attribute - :1937:20 -
Old: Attribute `dest` on type `@Todo | None` may be missing
New: Attribute `dest` on type `ConfigSetting[object] | None` may be missing
[warning] possibly-missing-attribute - :1937:30 -
Old: Attribute `parse` on type `@Todo | None` may be missing
New: Attribute `parse` on type `ConfigSetting[object] | None` may be missing
[warning] possibly-missing-attribute - :1937:56 -
Old: Attribute `dest` on type `@Todo | None` may be missing
New: Attribute `dest` on type `ConfigSetting[object] | None` may be missing
[warning] possibly-missing-attribute - :4986:31 -
Old: Attribute `section` on type `@Todo | None` may be missing
New: Attribute `section` on type `ConfigSetting[Any] | None` may be missing
[warning] possibly-missing-attribute - :4988:87 -
Old: Attribute `section` on type `@Todo | None` may be missing
New: Attribute `section` on type `ConfigSetting[Any] | None` may be missing
[warning] possibly-missing-attribute - :4992:28 -
Old: Attribute `name` on type `@Todo | None` may be missing
New: Attribute `name` on type `ConfigSetting[Any] | None` may be missing
[warning] possibly-missing-attribute - :4994:88 -
Old: Attribute `name` on type `@Todo | None` may be missing
New: Attribute `name` on type `ConfigSetting[Any] | None` may be missing
[warning] possibly-missing-attribute - :4999:29 -
Old: Attribute `dest` on type `@Todo | None` may be missing
New: Attribute `dest` on type `ConfigSetting[Any] | None` may be missing
[warning] possibly-missing-attribute - :4999:39 -
Old: Attribute `parse` on type `@Todo | None` may be missing
New: Attribute `parse` on type `ConfigSetting[Any] | None` may be missing
[warning] possibly-missing-attribute - :4999:66 -
Old: Attribute `dest` on type `@Todo | None` may be missing
New: Attribute `dest` on type `ConfigSetting[Any] | None` may be missing

mongo-python-driver (https://github.com/mongodb/mongo-python-driver)

pymongo/_version.py

[error] invalid-assignment - :28:9 - Object of type `list[int]` is not assignable to `list[int | str]`

tools/synchro.py

[error] invalid-return-type - :395:12 - Return type does not match returned value: expected `list[str]`, found `list[str & ~Literal["DOCSTRING_REMOVED"]]`

mypy (https://github.com/python/mypy)

mypy/errors.py

[error] invalid-return-type - :1068:16 - Return type does not match returned value: expected `set[str]`, found `set[Unknown & ~AlwaysFalsy]`

mypy/exprtotype.py

[error] invalid-argument-type - :194:13 - Argument to bound method `__init__` is incorrect: Expected `list[Type]`, found `list[ProperType]`

mypy/mro.py

[error] invalid-assignment - :50:9 - Object of type `list[list[TypeInfo] & ~AlwaysFalsy]` is not assignable to `list[list[TypeInfo]]`

mypy/plugins/attrs.py

[error] invalid-assignment - :918:5 - Object of type `list[(Instance & ~AlwaysFalsy) | AnyType]` is not assignable to `list[Type]`
[error] invalid-argument-type - :964:9 - Argument to bound method `__init__` is incorrect: Expected `list[Type]`, found `list[Instance]`
[error] invalid-argument-type - :977:13 - Argument to bound method `__init__` is incorrect: Expected `list[Type]`, found `list[Instance]`

mypy/plugins/dataclasses.py

[error] invalid-assignment - :383:13 - Object of type `list[LiteralType]` is not assignable to `list[Type]`

mypy/semanal_typeddict.py

[error] invalid-assignment - :210:13 - Object of type `list[AnyType]` is not assignable to `list[Type]`

mypyc/transform/spill.py

[error] invalid-argument-type - :31:44 - Argument to function `spill_regs` is incorrect: Expected `set[Value]`, found `set[Unknown & ~Register]`

mypy/checker.py

[error] invalid-assignment - :2925:13 - Object of type `list[Instance | AnyType]` is not assignable to `list[Type]`
[error] invalid-assignment - :2929:13 - Object of type `list[UninhabitedType | AnyType]` is not assignable to `list[Type]`
[error] invalid-argument-type - :4374:37 - Argument to bound method `__init__` is incorrect: Expected `list[Type]`, found `list[(Unknown & ~AlwaysFalsy) | UninhabitedType]`

mypy/checkexpr.py

[error] invalid-argument-type - :982:13 - Argument to bound method `__init__` is incorrect: Expected `list[ArgKind]`, found `list[Literal[ArgKind.ARG_NAMED, ArgKind.ARG_NAMED_OPT]]`
[error] invalid-argument-type - :2940:33 - Argument to function `all_same_types` is incorrect: Expected `list[Type]`, found `list[ProperType]`

mypy/fastparse.py

[error] invalid-assignment - :971:21 - Object of type `list[(Unknown & ~None) | AnyType]` is not assignable to `list[Type | None]`
[error] invalid-argument-type - :1205:13 - Argument to bound method `__init__` is incorrect: Expected `list[tuple[str, Expression]] | None`, found `list[tuple[str & ~AlwaysFalsy, Unknown]]`
[error] invalid-argument-type - :1646:13 - Argument to bound method `__init__` is incorrect: Expected `list[ArgKind]`, found `list[Literal[ArgKind.ARG_STAR2, ArgKind.ARG_NAMED, ArgKind.ARG_STAR, ArgKind.ARG_POS]]`

mypy/meet.py

[error] invalid-argument-type - :1067:40 - Argument to bound method `copy_modified` is incorrect: Expected `list[Type] | None`, found `list[ProperType]`

mypy/semanal.py

[error] invalid-argument-type - :5895:13 - Argument to bound method `__init__` is incorrect: Expected `list[tuple[Expression | None, Expression]]`, found `list[tuple[StrExpr | None, Unknown]]`

mypy/semanal_namedtuple.py

[error] invalid-assignment - :434:13 - Object of type `list[AnyType]` is not assignable to `list[Type]`
[error] invalid-assignment - :523:9 - Object of type `list[LiteralType]` is not assignable to `list[Type]`

mypy/stubgenc.py

[error] invalid-argument-type - :370:52 - Argument to function `infer_method_arg_types` is incorrect: Expected `list[str] | None`, found `list[(Unknown & ~AlwaysFalsy) | (str & ~AlwaysFalsy)]`

mypy/stubtest.py

[error] invalid-assignment - :2305:17 - Method `__setitem__` of type `bound method dict[str, Literal[False]].__setitem__(key: str, value: Literal[False], /) -> None` cannot be called with a key of type `Unknown | str` and a value of type `Literal[True]` on object of type `dict[str, Literal[False]]`
[error] invalid-assignment - :2310:21 - Method `__setitem__` of type `bound method dict[str, Literal[False]].__setitem__(key: str, value: Literal[False], /) -> None` cannot be called with a key of type `str` and a value of type `Literal[True]` on object of type `dict[str, Literal[False]]`

mypy/util.py

[error] invalid-assignment - :376:9 - Method `__setitem__` of type `bound method dict[type, list[str]].__setitem__(key: type, value: list[str], /) -> None` cannot be called with a key of type `type` and a value of type `list[@Todo & ~Literal["__weakref__"] & ~Literal["__dict__"]]` on object of type `dict[type, list[str]]`

mypyc/build.py

[error] invalid-assignment - :381:9 - Object of type `list[tuple[list[Unknown | BuildSource], None]]` is not assignable to `list[tuple[list[BuildSource], str | None]]`

mypyc/codegen/emitmodule.py

[error] invalid-return-type - :185:16 - Return type does not match returned value: expected `list[tuple[int, str, int]]`, found `list[tuple[Literal[10], Unknown, Literal[-1]]]`
[error] invalid-argument-type - :291:33 - Argument to function `load_scc_from_cache` is incorrect: Expected `list[MypyFile]`, found `list[Unknown & ~AlwaysFalsy] & ~AlwaysFalsy`
[error] invalid-argument-type - :293:40 - Argument to function `compile_scc_to_ir` is incorrect: Expected `list[MypyFile]`, found `list[Unknown & ~AlwaysFalsy] & ~AlwaysFalsy`

mypyc/irbuild/ll_builder.py

[error] invalid-assignment - :1250:21 - Object of type `list[Literal[ArgKind.ARG_POS]]` is not assignable to `list[ArgKind] | None`
[error] invalid-assignment - :1251:21 - Object of type `list[None]` is not assignable to `list[str | None] | None`

nox (https://github.com/wntrblm/nox)

nox/_option_set.py

[warning] unused-ignore-comment - :307:56 - Unused blanket `type: ignore` directive

openlibrary (https://github.com/internetarchive/openlibrary)

openlibrary/book_providers.py

[error] invalid-assignment - :738:5 - Object of type `dict[AbstractBookProvider[Unknown], int]` is not assignable to `dict[AbstractBookProvider[Unknown] | None, int]`
[error] invalid-return-type - :760:12 - Return type does not match returned value: expected `list[str]`, found `list[Unknown & ~AlwaysFalsy]`
[error] invalid-argument-type - :747:9 -
Old: Argument to function `multisort_best` is incorrect: Expected `list[tuple[Literal["min", "max"], (@Todo, /) -> int | float]]`, found `list[Unknown | tuple[str, (rec) -> Unknown]]`
New: Argument to function `multisort_best` is incorrect: Expected `list[tuple[Literal["min", "max"], (tuple[Edition, AbstractBookProvider[Unknown] | None], /) -> int | float]]`, found `list[Unknown | tuple[str, (rec) -> Unknown]]`

openlibrary/catalog/marc/parse.py

[error] invalid-return-type - :223:12 - Return type does not match returned value: expected `dict[str, str] | None`, found `dict[str, Any & ~AlwaysFalsy]`

openlibrary/core/lending.py

[error] invalid-assignment - :404:5 - Object of type `list[str & ~AlwaysFalsy]` is not assignable to `list[str]`
[error] invalid-argument-type - :533:53 - Argument to function `get_availability` is incorrect: Expected `list[str]`, found `list[Unknown & ~AlwaysFalsy]`
[error] invalid-argument-type - :563:61 - Argument to function `get_availability` is incorrect: Expected `list[str]`, found `list[Unknown & ~AlwaysFalsy]`
[error] invalid-return-type - :598:12 - Return type does not match returned value: expected `dict[str, Edition]`, found `dict[Unknown & ~AlwaysFalsy, Unknown]`

openlibrary/core/models.py

[error] invalid-return-type - :396:16 - Return type does not match returned value: expected `list[str]`, found `list[(Unknown & ~AlwaysFalsy) | (str & ~AlwaysFalsy)]`
[warning] possibly-missing-attribute - :702:20 - Attribute `split` on type `Unknown | dict[Unknown, Unknown]` may be missing

openlibrary/plugins/books/dynlinks.py

[warning] possibly-missing-attribute - :355:17 -
Old: Attribute `insert` on type `Unknown | str | list[@Todo] | None` may be missing
New: Attribute `insert` on type `Unknown | str | list[dict[Unknown | str, Unknown | str]] | ... omitted 3 union elements` may be missing
[error] invalid-argument-type - :399:33 -
Old: Argument to function `trim` is incorrect: Expected `dict[Unknown, Unknown]`, found `Unknown | str | list[@Todo] | None`
New: Argument to function `trim` is incorrect: Expected `dict[Unknown, Unknown]`, found `Unknown | str | list[dict[Unknown | str, Unknown | str]] | ... omitted 3 union elements`
[error] invalid-argument-type - :400:37 -
Old: Argument to function `trim` is incorrect: Expected `dict[Unknown, Unknown]`, found `Unknown | str | list[@Todo] | None`
New: Argument to function `trim` is incorrect: Expected `dict[Unknown, Unknown]`, found `Unknown | str | list[dict[Unknown | str, Unknown | str]] | ... omitted 3 union elements`

openlibrary/plugins/books/tests/test_dynlinks.py

[warning] unused-ignore-comment - :245:88 - Unused blanket `type: ignore` directive

openlibrary/plugins/openlibrary/lists.py

[error] invalid-assignment - :439:13 -
Old: Method `__setitem__` of type `Unknown | (bound method dict[Unknown | str, Unknown].__setitem__(key: Unknown | str, value: Unknown, /) -> None) | (Overload[(key: SupportsIndex, value: @Todo, /) -> None, (key: slice[Any, Any, Any], value: Iterable[@Todo], /) -> None])` cannot be called with a key of type `Literal["next"]` and a value of type `Unknown` on object of type `Unknown | dict[Unknown | str, Unknown] | int | list[@Todo]`
New: Method `__setitem__` of type `Unknown | (bound method dict[Unknown | str, Unknown].__setitem__(key: Unknown | str, value: Unknown, /) -> None) | (Overload[(key: SupportsIndex, value: Unknown, /) -> None, (key: slice[Any, Any, Any], value: Iterable[Unknown], /) -> None])` cannot be called with a key of type `Literal["next"]` and a value of type `Unknown` on object of type `Unknown | dict[Unknown | str, Unknown] | int | list[Unknown]`
[error] invalid-assignment - :443:13 -
Old: Method `__setitem__` of type `Unknown | (bound method dict[Unknown | str, Unknown].__setitem__(key: Unknown | str, value: Unknown, /) -> None) | (Overload[(key: SupportsIndex, value: @Todo, /) -> None, (key: slice[Any, Any, Any], value: Iterable[@Todo], /) -> None])` cannot be called with a key of type `Literal["prev"]` and a value of type `Unknown` on object of type `Unknown | dict[Unknown | str, Unknown] | int | list[@Todo]`
New: Method `__setitem__` of type `Unknown | (bound method dict[Unknown | str, Unknown].__setitem__(key: Unknown | str, value: Unknown, /) -> None) | (Overload[(key: SupportsIndex, value: Unknown, /) -> None, (key: slice[Any, Any, Any], value: Iterable[Unknown], /) -> None])` cannot be called with a key of type `Literal["prev"]` and a value of type `Unknown` on object of type `Unknown | dict[Unknown | str, Unknown] | int | list[Unknown]`

openlibrary/plugins/upstream/models.py

[error] invalid-argument-type - :749:63 - Argument to function `get_availability` is incorrect: Expected `list[str]`, found `list[Unknown & ~AlwaysFalsy]`

openlibrary/plugins/upstream/mybooks.py

[error] not-iterable - :193:58 - Object of type `Unknown | list[Unknown] | None` may not be iterable

openlibrary/plugins/upstream/utils.py

[error] invalid-assignment - :1655:9 - Object of type `list[str & ~AlwaysFalsy]` is not assignable to `list[str]`
[error] invalid-assignment - :1656:9 - Object of type `list[str & ~AlwaysFalsy]` is not assignable to `list[str]`

openlibrary/solr/updater/work.py

[error] invalid-return-type - :363:16 - Return type does not match returned value: expected `set[str]`, found `set[Unknown & ~AlwaysFalsy]`
[error] invalid-return-type - :413:16 - Return type does not match returned value: expected `set[str]`, found `set[Unknown & ~AlwaysFalsy]`
[error] invalid-return-type - :432:16 - Return type does not match returned value: expected `set[str]`, found `set[Unknown & ~AlwaysFalsy]`
[error] invalid-return-type - :444:16 - Return type does not match returned value: expected `set[str]`, found `set[str & ~AlwaysFalsy]`
[error] invalid-return-type - :600:16 - Return type does not match returned value: expected `set[str]`, found `set[Unknown & ~AlwaysFalsy]`

optuna (https://github.com/optuna/optuna)

optuna/cli.py

[error] invalid-assignment - :144:25 - Method `__setitem__` of type `bound method dict[Unknown, dict[Unknown, Unknown]].__setitem__(key: Unknown, value: dict[Unknown, Unknown], /) -> None` cannot be called with a key of type `str` and a value of type `list[Unknown]` on object of type `dict[Unknown, dict[Unknown, Unknown]]`
[error] unsupported-operator - :145:21 - Operator `+=` is unsupported between objects of type `dict[Unknown, Unknown]` and `list[Unknown | None]`

optuna/_gp/optim_mixed.py

[error] invalid-argument-type - :78:13 - Argument to function `batched_lbfgsb` is incorrect: Expected `list[tuple[int | float, int | float]] | None`, found `list[tuple[Literal[0], Any]]`

optuna/importance/_ped_anova/evaluator.py

[error] invalid-return-type - :214:20 - Return type does not match returned value: expected `dict[str, int | float]`, found `dict[str, float]`

optuna/storages/_grpc/client.py

[error] invalid-return-type - :193:16 - Return type does not match returned value: expected `list[StudyDirection]`, found `list[Literal[StudyDirection.MINIMIZE, StudyDirection.MAXIMIZE]]`

optuna/storages/_rdb/storage.py

[error] invalid-return-type - :366:16 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[Unknown | Column[Unknown], Any]`
[error] invalid-return-type - :375:16 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[Unknown | Column[Unknown], Any]`
[error] invalid-return-type - :385:16 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[Unknown | Column[Unknown], Any]`
[error] invalid-return-type - :395:16 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[Unknown | Column[Unknown], Any]`
[error] invalid-assignment - :879:13 - Object of type `list[Literal[0]]` is not assignable to `list[int | float] | None`
[warning] possibly-missing-implicit-call - :881:17 - Method `__setitem__` of type `list[int | float] | None` may be missing

optuna/study/_multi_objective.py

[error] invalid-argument-type - :27:16 -
Old: Argument to function `len` is incorrect: Expected `Sized`, found `@Todo | list[int | float] | None`
New: Argument to function `len` is incorrect: Expected `Sized`, found `Unknown | list[int | float] | None`
[error] invalid-argument-type - :33:50 -
Old: Argument to function `__new__` is incorrect: Expected `Iterable[Unknown]`, found `@Todo | list[int | float] | None`
New: Argument to function `__new__` is incorrect: Expected `Iterable[Unknown]`, found `Unknown | list[int | float] | None`

optuna/study/_tell.py

[error] invalid-return-type - :177:12 - Return type does not match returned value: expected `tuple[TrialState, list[int | float] | None, str | None]`, found `tuple[TrialState, None | list[float], None]`

optuna/visualization/_contour.py

[error] invalid-assignment - :373:9 - Object of type `list[str | None]` is not assignable to `list[str | int | float | None]`

optuna/visualization/_rank.py

[error] invalid-assignment - :216:9 - Object of type `list[str | None]` is not assignable to `list[str | int | float | None]`

tests/gp_tests/test_acqf.py

[error] invalid-argument-type - :41:24 - Argument to bound method `__init__` is incorrect: Expected `dict[str, BaseDistribution]`, found `dict[str, FloatDistribution]`

tests/gp_tests/test_search_space.py

[error] invalid-argument-type - :158:9 - Argument to bound method `__init__` is incorrect: Expected `dict[str, BaseDistribution]`, found `dict[Unknown | str, (Unknown & ~CategoricalDistribution) | (FloatDistribution & ~CategoricalDistribution) | (IntDistribution & ~CategoricalDistribution)]`

tests/pruners_tests/test_wilcoxon.py

[error] invalid-argument-type - :69:13 - Argument to function `create_trial` is incorrect: Expected `dict[int, int | float] | None`, found `dict[int, Literal[0]]`

tests/samplers_tests/test_qmc.py

[error] invalid-assignment - :189:5 - Object of type `dict[str, FloatDistribution]` is not assignable to `dict[str, BaseDistribution]`
[error] invalid-assignment - :219:5 - Object of type `dict[str, FloatDistribution]` is not assignable to `dict[str, BaseDistribution]`

paasta (https://github.com/yelp/paasta)

paasta_tools/instance/kubernetes.py

[error] invalid-return-type - :1146:12 -
Old: Return type does not match returned value: expected `KubernetesVersionDict`, found `dict[Unknown | str, Unknown | str | int | list[@Todo] | None]`
New: Return type does not match returned value: expected `KubernetesVersionDict`, found `dict[Unknown | str, Unknown | str | int | list[Mapping[str, Any]] | None]`

paasta_tools/kubernetes_tools.py

[error] invalid-return-type - :3765:12 - Return type does not match returned value: expected `Mapping[str, Sequence[Unknown]]`, found `dict[Unknown & ~AlwaysFalsy, list[Unknown]]`

paasta_tools/mesos_tools.py

[error] non-subscriptable - :893:16 - Cannot subscript object of type `int` with no `__getitem__` method

paasta_tools/setup_kubernetes_job.py

[warning] possibly-missing-attribute - :440:24 - Attribute `get_bounce_method` on type `Unknown | None | KubernetesDeploymentConfig` may be missing

paasta_tools/smartstack_tools.py

[error] invalid-assignment - :372:17 - Method `__setitem__` of type `bound method dict[str, Literal[False]].__setitem__(key: str, value: Literal[False], /) -> None` cannot be called with a key of type `str` and a value of type `Literal[True]` on object of type `dict[str, Literal[False]]`

pandas (https://github.com/pandas-dev/pandas)

pandas/tests/io/formats/test_to_excel.py

[error] invalid-argument-type - :464:13 - Argument to bound method `__init__` is incorrect: Expected `dict[tuple[int, int], list[tuple[str, Any]]] | None`, found `dict[tuple[Literal[0], int], Unknown]`

pandas/core/_numba/kernels/mean_.py

[error] invalid-return-type - :162:12 - Return type does not match returned value: expected `tuple[ndarray[@Todo, Unknown], list[int]]`, found `tuple[ndarray[tuple[int], dtype[Any]], list[Literal[0]]]`
[error] invalid-return-type - :198:12 - Return type does not match returned value: expected `tuple[ndarray[@Todo, Unknown], list[int]]`, found `tuple[Unknown, list[Literal[0]]]`

pandas/core/_numba/kernels/var_.py

[error] invalid-return-type - :168:12 - Return type does not match returned value: expected `tuple[ndarray[@Todo, Unknown], list[int]]`, found `tuple[ndarray[tuple[int], dtype[Any]], list[Literal[0]]]`
[error] invalid-return-type - :251:12 - Return type does not match returned value: expected `tuple[ndarray[@Todo, Unknown], list[int]]`, found `tuple[ndarray[tuple[int], dtype[Any]], list[Literal[0]]]`

pandas/core/common.py

[error] invalid-return-type - :654:12 - Return type does not match returned value: expected `list[Hashable]`, found `list[Hashable & ~None]`

pandas/core/computation/eval.py

[error] invalid-assignment - :335:9 - Object of type `list[str]` is not assignable to `list[str | BinOp]`

pandas/core/indexing.py

[error] invalid-assignment - :2647:5 - Object of type `list[slice[Any, Any, Any]]` is not assignable to `list[Hashable]`

pandas/core/internals/construction.py

[error] invalid-argument-type - :787:31 - Argument to function `_list_to_arrays` is incorrect: Expected `list[tuple[Unknown, ...] | list[Unknown]]`, found `list[tuple[Unknown, ...]]`

pandas/core/strings/accessor.py

[error] invalid-assignment - :3921:5 - Object of type `list[str | int]` is not assignable to `list[Hashable]`
[warning] possibly-missing-attribute - :396:30 -
Old: Attribute `dtype` on type `(Unknown & <Protocol with members 'ndim'> & <Protocol with members 'dtype'>) | dict[@Todo, @Todo] | list[@Todo]` may be missing
New: Attribute `dtype` on type `(Unknown & <Protocol with members 'ndim'> & <Protocol with members 'dtype'>) | dict[Unknown, ArrowExtensionArray] | list[Unknown]` may be missing

pandas/io/formats/printing.py

[error] unsupported-operator - :439:20 -
Old: Operator `+` is unsupported between objects of type `Unknown | tuple[str, ...]` and `LiteralString`
New: Operator `+` is unsupported between objects of type `Unknown | tuple[str, ...] | str` and `LiteralString`
[error] unsupported-operator - :448:20 -
Old: Operator `+` is unsupported between objects of type `@Todo | tuple[str, ...]` and `LiteralString`
New: Operator `+` is unsupported between objects of type `Unknown | tuple[str, ...] | str` and `LiteralString`
[error] invalid-argument-type - :452:53 -
Old: Argument to function `_extend_line` is incorrect: Expected `str`, found `@Todo | tuple[str, ...]`
New: Argument to function `_extend_line` is incorrect: Expected `str`, found `Unknown | tuple[str, ...] | str`

pandas/io/xml.py

[error] invalid-assignment - :234:17 - Object of type `list[dict[Any, (Any & ~AlwaysFalsy) | None]]` is not assignable to `list[dict[str, str | None]]`
[error] invalid-assignment - :240:13 - Object of type `list[dict[Any, (Any & ~AlwaysFalsy) | None]]` is not assignable to `list[dict[str, str | None]]`

pandas/tests/io/formats/style/test_style.py

[error] invalid-argument-type - :1326:20 -
Old: Argument to function `len` is incorrect: Expected `Sized`, found `Unknown | list[@Todo] | None`
New: Argument to function `len` is incorrect: Expected `Sized`, found `Unknown | list[dict[Unknown | str, Unknown | str | list[tuple[str, str | int | float]]]] | list[dict[Unknown | str, Unknown | list[tuple[str, str | int | float]]]] | None`

pandas/tests/io/test_sql.py

[error] invalid-argument-type - :733:48 - Argument to function `create_and_load_types_postgresql` is incorrect: Expected `list[dict[Unknown, Unknown]]`, found `list[tuple[Unknown, ...]]`
[error] invalid-argument-type - :891:51 - Argument to function `create_and_load_types_sqlite3` is incorrect: Expected `list[dict[Unknown, Unknown]]`, found `list[tuple[Unknown, ...]]`

pandas/tests/reshape/merge/test_merge_index_as_string.py

[error] unsupported-operator - :97:44 -
Old: Operator `not in` is not supported for types `@Todo` and `None`, in comparing `@Todo` with `Unknown | None`
New: Operator `not in` is not supported for types `Unknown` and `None`, in comparing `Unknown & ~None` with `Unknown | None`
[error] unsupported-operator - :101:46 -
Old: Operator `not in` is not supported for types `@Todo` and `None`, in comparing `@Todo` with `Unknown | None`
New: Operator `not in` is not supported for types `Unknown` and `None`, in comparing `Unknown & ~None` with `Unknown | None`
[error] unsupported-operator - :106:45 -
Old: Operator `in` is not supported for types `@Todo` and `None`, in comparing `@Todo` with `Unknown | None`
New: Operator `in` is not supported for types `Unknown` and `None`, in comparing `Unknown & ~None` with `Unknown | None`
[error] unsupported-operator - :110:47 -
Old: Operator `in` is not supported for types `@Todo` and `None`, in comparing `@Todo` with `Unknown | None`
New: Operator `in` is not supported for types `Unknown` and `None`, in comparing `Unknown & ~None` with `Unknown | None`

pandas-stubs (https://github.com/pandas-dev/pandas-stubs)

tests/test_frame.py

[error] type-assertion-failure - :4147:11 - Argument does not have asserted type `list[str]`

pandera (https://github.com/pandera-dev/pandera)

pandera/backends/pyspark/container.py

[warning] unused-ignore-comment - :603:34 - Unused blanket `type: ignore` directive

pandera/strategies/pandas_strategies.py

[error] invalid-argument-type - :1222:49 - Argument expression after ** must be a mapping with `str` key type: Found `Unknown | int`

pegen (https://github.com/we-like-parsers/pegen)

src/pegen/sccutils.py

[error] invalid-assignment - :116:5 - Object of type `dict[str, set[str]]` is not assignable to `dict[str, AbstractSet[str]]`

pip (https://github.com/pypa/pip)

src/pip/_vendor/rich/console.py

[error] invalid-assignment - :1581:13 - Object of type `list[Styled]` is not assignable to `list[ConsoleRenderable]`
[error] invalid-argument-type - :1987:36 - Argument to bound method `append` is incorrect: Expected `Styled`, found `ConsoleRenderable`

src/pip/_internal/models/link.py

[error] invalid-argument-type - :607:9 - Argument is incorrect: Expected `dict[str, str]`, found `dict[Literal["sha512", "sha384", "sha256", "sha224", "sha1", "md5"], Unknown | str]`

src/pip/_internal/operations/prepare.py

[warning] possibly-missing-attribute - :552:50 - Attribute `is_wheel` on type `Unknown | Link | None` may be missing
[error] invalid-argument-type - :554:49 - Argument to function `_check_download_dir` is incorrect: Expected `Link`, found `Unknown | Link | None`
[warning] possibly-missing-attribute - :556:38 - Attribute `url` on type `Unknown | Link | None` may be missing

src/pip/_vendor/resolvelib/resolvers/resolution.py

[error] invalid-assignment - :40:5 - Object of type `dict[int, KT@_build_result]` is not assignable to `dict[int, KT@_build_result | None]`

src/pip/_vendor/rich/table.py

[error] invalid-argument-type - :548:64 - Argument to function `ratio_distribute` is incorrect: Expected `list[int]`, found `list[(Unknown & ~AlwaysFalsy) | Literal[0]]`
[error] invalid-argument-type - :582:69 - Argument to function `ratio_distribute` is incorrect: Expected `list[int]`, found `list[(Unknown & ~AlwaysFalsy) | Literal[1]] | list[(Unknown & ~AlwaysFalsy) | Literal[0]]`
[error] invalid-return-type - :585:16 - Return type does not match returned value: expected `list[int]`, found `list[(Unknown & ~AlwaysFalsy) | Literal[1]] | list[(Unknown & ~AlwaysFalsy) | Literal[0]] | list[Unknown]`
[error] invalid-argument-type - :620:53 - Argument to function `ratio_reduce` is incorrect: Expected `list[int]`, found `list[Literal[1, 0]]`

src/pip/_vendor/urllib3/util/ssl_.py

[error] invalid-argument-type - :199:33 - Argument to bound method `get` is incorrect: Expected `Literal[32, 40, 64]`, found `int`

src/pip/_vendor/urllib3/util/url.py

[warning] possibly-missing-attribute - :373:26 - Attribute `groups` on type `Match[str] | None` may be missing

prefect (https://github.com/PrefectHQ/prefect)

src/prefect/cli/deploy/_schedules.py

[error] invalid-argument-type - :61:13 - Argument to bound method `__init__` is incorrect: Expected `str | None`, found `(Unknown & ~None) | timedelta | datetime`
[error] invalid-argument-type - :61:13 - Argument to bound method `__init__` is incorrect: Expected `timedelta`, found `(Unknown & ~None) | timedelta | datetime`

src/integrations/prefect-aws/prefect_aws/workers/ecs_worker.py

[error] invalid-argument-type - :1086:13 - Argument to function `_get_container` is incorrect: Expected `list[dict[str, Any]]`, found `list[Any & ~AlwaysFalsy]`
[error] invalid-argument-type - :1101:64 - Argument to bound method `append` is incorrect: Expected `Any & ~AlwaysFalsy`, found `dict[str, Any]`

src/integrations/prefect-azure/prefect_azure/ml_datastore.py

[error] invalid-assignment - :177:9 - Object of type `list[str]` is not assignable to `str | Path | list[str | Path]`

src/integrations/prefect-dbt/prefect_dbt/cli/commands.py

[error] invalid-argument-type - :164:21 - Argument to bound method `append` is incorrect: Expected `str & ~Literal["dbt"]`, found `Path | str`
[error] invalid-argument-type - :168:25 - Argument to bound method `append` is incorrect: Expected `str & ~Literal["dbt"]`, found `Path`
[error] invalid-argument-type - :172:29 - Argument to bound method `append` is incorrect: Expected `str & ~Literal["dbt"]`, found `str`

src/integrations/prefect-gcp/prefect_gcp/cloud_storage.py

[error] invalid-return-type - :973:16 - Return type does not match returned value: expected `list[str]`, found `list[str & ~Literal["."]]`

src/integrations/prefect-redis/prefect_redis/locking.py

[error] invalid-return-type - :76:16 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[Literal["host", "port", "db", "username", "password", "ssl"], Any]`

src/prefect/_vendor/croniter/croniter.py

[error] unsupported-operator - :1080:21 - Operator `+=` is unsupported between objects of type `list[LiteralString]` and `list[str | int]`

src/prefect/cli/cloud/__init__.py

[error] invalid-assignment - :375:5 - Object of type `list[tuple[Workspace, str]]` is not assignable to `list[tuple[Workspace | None, str]]`

src/prefect/cli/flow_run.py

[error] invalid-argument-type - :191:40 -
Old: Argument is incorrect: Expected `FlowFilterId | None`, found `dict[Unknown | str, Unknown | list[@Todo]]`
New: Argument is incorrect: Expected `FlowFilterId | None`, found `dict[Unknown | str, Unknown | list[UUID]]`

src/prefect/cli/transfer/_dag.py

[error] invalid-assignment - :153:13 - Method `__setitem__` of type `bound method dict[Unknown, Literal[0]].__setitem__(key: Unknown, value: Literal[0], /) -> None` cannot be called with a key of type `UUID` and a value of type `Literal[1]` on object of type `dict[Unknown, Literal[0]]`
[error] invalid-assignment - :157:13 - Method `__setitem__` of type `bound method dict[Unknown, Literal[0]].__setitem__(key: Unknown, value: Literal[0], /) -> None` cannot be called with a key of type `UUID` and a value of type `Literal[2]` on object of type `dict[Unknown, Literal[0]]`

src/prefect/cli/work_queue.py

[error] invalid-argument-type - :403:60 - Argument is incorrect: Expected `list[UUID] | None`, found `list[UUID | None]`
[error] invalid-argument-type - :414:21 - Method `__getitem__` of type `bound method dict[UUID, @Todo].__getitem__(key: UUID, /) -> @Todo` cannot be called with key of type `UUID | None` on object of type `dict[UUID, @Todo]`
[error] unsupported-operator - :533:20 - Operator `<` is not supported for types `None` and `datetime`, in comparing `@Todo | None` with `datetime`

src/prefect/cli/worker.py

[error] invalid-argument-type - :271:16 - Method `__getitem__` of type `bound method dict[Any & ~Literal["prefect-agent"], str].__getitem__(key: Any & ~Literal["prefect-agent"], /) -> str` cannot be called with key of type `str` on object of type `dict[Any & ~Literal["prefect-agent"], str]`

src/prefect/client/orchestration/_concurrency_limits/client.py

[error] invalid-assignment - :147:13 - Object of type `list[str]` is not assignable to `list[UUID | str] | None`
[error] invalid-assignment - :599:13 - Object of type `list[str]` is not assignable to `list[UUID | str] | None`

src/prefect/client/orchestration/_deployments/client.py

[error] invalid-assignment - :600:13 -
Old: Method `__setitem__` of type `bound method dict[str, list[@Todo]].__setitem__(key: str, value: list[@Todo], /) -> None` cannot be called with a key of type `Literal["scheduled_before"]` and a value of type `str` on object of type `dict[str, list[@Todo]]`
New: Method `__setitem__` of type `bound method dict[str, list[str]].__setitem__(key: str, value: list[str], /) -> None` cannot be called with a key of type `Literal["scheduled_before"]` and a value of type `str` on object of type `dict[str, list[str]]`
[error] invalid-assignment - :602:13 -
Old: Method `__setitem__` of type `bound method dict[str, list[@Todo]].__setitem__(key: str, value: list[@Todo], /) -> None` cannot be called with a key of type `Literal["limit"]` and a value of type `int & ~AlwaysFalsy` on object of type `dict[str, list[@Todo]]`
New: Method `__setitem__` of type `bound method dict[str, list[str]].__setitem__(key: str, value: list[str], /) -> None` cannot be called with a key of type `Literal["limit"]` and a value of type `int & ~AlwaysFalsy` on object of type `dict[str, list[str]]`
[error] invalid-assignment - :1273:13 -
Old: Method `__setitem__` of type `bound method dict[str, list[@Todo]].__setitem__(key: str, value: list[@Todo], /) -> None` cannot be called with a key of type `Literal["scheduled_before"]` and a value of type `str` on object of type `dict[str, list[@Todo]]`
New: Method `__setitem__` of type `bound method dict[str, list[str]].__setitem__(key: str, value: list[str], /) -> None` cannot be called with a key of type `Literal["scheduled_before"]` and a value of type `str` on object of type `dict[str, list[str]]`
[error] invalid-assignment - :1275:13 -
Old: Method `__setitem__` of type `bound method dict[str, list[@Todo]].__setitem__(key: str, value: list[@Todo], /) -> None` cannot be called with a key of type `Literal["limit"]` and a value of type `int & ~AlwaysFalsy` on object of type `dict[str, list[@Todo]]`
New: Method `__setitem__` of type `bound method dict[str, list[str]].__setitem__(key: str, value: list[str], /) -> None` cannot be called with a key of type `Literal["limit"]` and a value of type `int & ~AlwaysFalsy` on object of type `dict[str, list[str]]`

src/prefect/deployments/flow_runs.py

[error] invalid-argument-type - :167:13 - Argument to bound method `create_task_run` is incorrect: Expected `dict[str, list[TaskRunResult | FlowRunResult | Parameter | Constant]] | None`, found `dict[str | Unknown, set[TaskRunResult | FlowRunResult]]`

src/prefect/deployments/runner.py

[error] not-iterable - :626:26 - Object of type `Unknown | Iterable[int | float | timedelta] | int | ... omitted 5 union elements` may not be iterable
[error] invalid-argument-type - :619:25 -
Old: Argument to function `construct_schedule` is incorrect: Expected `int | float | timedelta | None`, found `Unknown | str | None | datetime`
New: Argument to function `construct_schedule` is incorrect: Expected `datetime | str | None`, found `Unknown | Iterable[int | float | timedelta] | int | ... omitted 5 union elements`
[error] invalid-argument-type - :619:25 -
Old: Argument to function `construct_schedule` is incorrect: Expected `str | None`, found `Unknown | str | None | datetime`
New: Argument to function `construct_schedule` is incorrect: Expected `datetime | str | None`, found `Unknown | Iterable[int | float | timedelta] | int | ... omitted 5 union elements`
[error] invalid-argument-type - :619:25 -
Old: Argument to function `construct_schedule` is incorrect: Expected `str | None`, found `Unknown | str | None | datetime`
New: Argument to function `construct_schedule` is incorrect: Expected `datetime | str | None`, found `Unknown | Iterable[int | float | timedelta] | int | ... omitted 5 union elements`
[error] invalid-argument-type - :619:25 -
Old: Argument to function `construct_schedule` is incorrect: Expected `str | None`, found `Unknown | str | None | datetime`
New: Argument to function `construct_schedule` is incorrect: Expected `datetime | str | None`, found `Unknown | Iterable[int | float | timedelta] | int | ... omitted 5 union elements`
[error] invalid-argument-type - :619:25 - Argument to function `construct_schedule` is incorrect: Expected `int | float | timedelta | None`, found `Unknown | Iterable[int | float | timedelta] | int | ... omitted 5 union elements`
[error] invalid-argument-type - :619:25 - Argument to function `construct_schedule` is incorrect: Expected `str | None`, found `Unknown | Iterable[int | float | timedelta] | int | ... omitted 5 union elements`
[error] invalid-argument-type - :619:25 - Argument to function `construct_schedule` is incorrect: Expected `str | None`, found `Unknown | Iterable[int | float | timedelta] | int | ... omitted 5 union elements`
[error] invalid-argument-type - :619:25 - Argument to function `construct_schedule` is incorrect: Expected `str | None`, found `Unknown | Iterable[int | float | timedelta] | int | ... omitted 5 union elements`

src/prefect/runner/submit.py

[error] invalid-assignment - :75:9 - Object of type `dict[str, list[TaskRunResult | FlowRunResult]]` is not assignable to `dict[str, list[TaskRunResult | FlowRunResult | Parameter | Constant]]`

src/prefect/server/models/block_documents.py

[error] invalid-argument-type - :427:47 -
Old: Argument is incorrect: Expected `BlockSchemaFilterId | None`, found `dict[str, list[@Todo]]`
New: Argument is incorrect: Expected `BlockSchemaFilterId | None`, found `dict[str, list[UUID]]`

src/prefect/server/schemas/states.py

[error] invalid-assignment - :158:9 - Object of type `dict[Unknown & ~Literal["data"], Any | None]` is not assignable to `dict[str, Any]`

src/prefect/tasks.py

[error] invalid-assignment - :916:17 - Method `__setitem__` of type `bound method dict[str, set[TaskRunResult | FlowRunResult]].__setitem__(key: str, value: set[TaskRunResult | FlowRunResult], /) -> None` cannot be called with a key of type `Literal["__parents__"]` and a value of type `list[TaskRunResult] & ~AlwaysFalsy` on object of type `dict[str, set[TaskRunResult | FlowRunResult]]`
[error] invalid-argument-type - :938:17 - Argument to bound method `create_task_run` is incorrect: Expected `dict[str, list[TaskRunResult | FlowRunResult | Parameter | Constant]] | None`, found `dict[str, set[TaskRunResult | FlowRunResult]]`
[error] invalid-assignment - :1021:17 - Method `__setitem__` of type `bound method dict[str, set[TaskRunResult | FlowRunResult]].__setitem__(key: str, value: set[TaskRunResult | FlowRunResult], /) -> None` cannot be called with a key of type `Literal["__parents__"]` and a value of type `list[TaskRunResult] & ~AlwaysFalsy` on object of type `dict[str, set[TaskRunResult | FlowRunResult]]`
[error] invalid-argument-type - :1057:17 - Argument is incorrect: Expected `dict[str, list[TaskRunResult | FlowRunResult | Parameter | Constant]]`, found `(dict[str, set[TaskRunResult | FlowRunResult]] & ~AlwaysFalsy) | dict[Unknown, Unknown]`

src/prefect/utilities/templating.py

[error] invalid-return-type - :323:16 -
Old: Return type does not match returned value: expected `T@resolve_block_document_references | dict[str, Any]`, found `list[@Todo]`
New: Return type does not match returned value: expected `T@resolve_block_document_references | dict[str, Any]`, found `list[Unknown]`
[error] invalid-return-type - :437:16 -
Old: Return type does not match returned value: expected `T@resolve_variables`, found `dict[@Todo, @Todo]`
New: Return type does not match returned value: expected `T@resolve_variables`, found `dict[object, Unknown]`
[error] invalid-return-type - :442:16 -
Old: Return type does not match returned value: expected `T@resolve_variables`, found `list[@Todo]`
New: Return type does not match returned value: expected `T@resolve_variables`, found `list[Unknown]`

psycopg (https://github.com/psycopg/psycopg)

tests/pq/test_pgconn.py

[error] no-matching-overload - :694:5 - No overload of bound method `update` matches arguments

pwndbg (https://github.com/pwndbg/pwndbg)

pwndbg/commands/killthreads.py

[error] not-iterable - :59:26 -
Old: Object of type `list[int] | None | list[@Todo]` may not be iterable
New: Object of type `list[int] | None` may not be iterable
[error] not-iterable - :72:62 -
Old: Object of type `list[int] | None | list[@Todo]` may not be iterable
New: Object of type `list[int] | None` may not be iterable

pwndbg/commands/ptmalloc2.py

[error] invalid-argument-type - :505:40 - Argument to bound method `contains_chunk` is incorrect: Expected `int`, found `int | None`

pwndbg/dbg/gdb/__init__.py

[error] invalid-return-type - :372:16 - Return type does not match returned value: expected `list[Thread]`, found `list[GDBThread]`
[error] invalid-return-type - :1135:16 - Return type does not match returned value: expected `list[Type] | None`, found `list[GDBType]`

pwndbg/dbg/lldb/__init__.py

[error] invalid-return-type - :411:16 - Return type does not match returned value: expected `list[Type] | None`, found `list[LLDBType]`
[error] invalid-return-type - :789:16 - Return type does not match returned value: expected `list[Thread]`, found `list[LLDBThread]`

pycryptodome (https://github.com/Legrandin/pycryptodome)

lib/Crypto/Cipher/_mode_kw.py

[error] invalid-return-type - :25:12 - Return type does not match returned value: expected `bytes`, found `bytes | bytearray | Unknown`
[error] invalid-return-type - :43:12 - Return type does not match returned value: expected `bytes`, found `bytes | bytearray | Unknown`

pydantic (https://github.com/pydantic/pydantic)

pydantic/json_schema.py

[error] invalid-return-type - :1497:16 - Return type does not match returned value: expected `list[tuple[str, bool, ComputedField]]`, found `list[tuple[str, Literal[True], ComputedField]]`

pydantic/v1/datetime_parse.py

[error] invalid-assignment - :166:5 - Object of type `dict[str, int]` is not assignable to `dict[str, None | int | timezone]`
[error] invalid-assignment - :204:5 - Object of type `dict[str, int]` is not assignable to `dict[str, None | int | timezone]`
[warning] unused-ignore-comment - :170:29 - Unused blanket `type: ignore` directive
[warning] unused-ignore-comment - :208:33 - Unused blanket `type: ignore` directive

pylint (https://github.com/pycqa/pylint)

pylint/checkers/classes/class_checker.py

[error] invalid-argument-type - :120:32 - Argument is incorrect: Expected `list[str]`, found `list[Unknown & ~Literal["self"]]`

pyodide (https://github.com/pyodide/pyodide)

pyodide-build/pyodide_build/vendor/_pypabuild.py

[error] invalid-return-type - :59:16 - Return type does not match returned value: expected `dict[str, str]`, found `dict[Unknown | str, Literal[""]]`
[error] invalid-return-type - :62:12 - Return type does not match returned value: expected `dict[str, str]`, found `dict[Unknown | str, Literal[""]]`

pytest (https://github.com/pytest-dev/pytest)

src/_pytest/assertion/rewrite.py

[error] invalid-assignment - :839:9 - Object of type `list[Constant]` is not assignable to `list[expr | None]`
[error] invalid-assignment - :936:17 - Object of type `list[Name]` is not assignable to `list[expr]`
[error] invalid-assignment - :963:13 - Object of type `list[Name]` is not assignable to `list[expr]`
[error] invalid-assignment - :1124:9 - Object of type `list[Name]` is not assignable to `list[expr]`

src/_pytest/pathlib.py

[error] invalid-return-type - :457:12 - Return type does not match returned value: expected `set[str]`, found `set[(str & ~AlwaysFalsy) | LiteralString]`

src/_pytest/python.py

[error] invalid-return-type - :1522:16 - Return type does not match returned value: expected `Scope`, found `Scope | Unknown | (((str, Config, /) -> @Todo) & ~(() -> object) & ~str)`

testing/test_assertion.py

[error] invalid-argument-type - :1365:49 - Argument to function `_truncate_explanation` is incorrect: Expected `list[str]`, found `list[Literal["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]]`
[error] invalid-argument-type - :1370:49 - Argument to function `_truncate_explanation` is incorrect: Expected `list[str]`, found `list[Literal[""]]`
[error] invalid-argument-type - :1382:49 - Argument to function `_truncate_explanation` is incorrect: Expected `list[str]`, found `list[Literal["a"]]`
[error] invalid-argument-type - :1393:49 - Argument to function `_truncate_explanation` is incorrect: Expected `list[str]`, found `list[Literal["a"]]`
[error] invalid-argument-type - :1425:49 - Argument to function `_truncate_explanation` is incorrect: Expected `list[str]`, found `list[Literal["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]]`
[error] invalid-argument-type - :1435:49 - Argument to function `_truncate_explanation` is incorrect: Expected `list[str]`, found `list[Literal["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]]`

python-chess (https://github.com/niklasf/python-chess)

chess/engine.py

[error] invalid-assignment - :1327:17 - Object of type `dict[Unknown | str, Literal[""]]` is not assignable to `dict[str, str]`

chess/syzygy.py

[error] invalid-assignment - :350:5 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: Literal[0], /) -> None, (key: slice[Any, Any, Any], value: Iterable[Literal[0]], /) -> None]` cannot be called with a key of type `int` and a value of type `int` on object of type `list[Literal[0]]`
[error] invalid-assignment - :644:9 - Object of type `list[Literal[0]]` is not assignable to attribute `symlen` of type `list[int]`
[error] invalid-assignment - :660:9 - Object of type `list[Literal[0]]` is not assignable to attribute `base` of type `list[int]`
[error] invalid-assignment - :1209:21 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: Literal[0], /) -> None, (key: slice[Any, Any, Any], value: Iterable[Literal[0]], /) -> None]` cannot be called with a key of type `Literal[0]` and a value of type `int` on object of type `list[Literal[0]]`
[error] invalid-assignment - :1223:17 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: Literal[0], /) -> None, (key: slice[Any, Any, Any], value: Iterable[Literal[0]], /) -> None]` cannot be called with a key of type `Literal[0]` and a value of type `int` on object of type `list[Literal[0]]`
[error] invalid-assignment - :1234:21 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: Literal[0], /) -> None, (key: slice[Any, Any, Any], value: Iterable[Literal[0]], /) -> None]` cannot be called with a key of type `Literal[0, 1]` and a value of type `int` on object of type `list[Literal[0]]`
[error] invalid-assignment - :1387:21 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: Literal[0], /) -> None, (key: slice[Any, Any, Any], value: Iterable[Literal[0]], /) -> None]` cannot be called with a key of type `Literal[0]` and a value of type `int` on object of type `list[Literal[0]]`
[error] invalid-assignment - :1412:17 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: Literal[0], /) -> None, (key: slice[Any, Any, Any], value: Iterable[Literal[0]], /) -> None]` cannot be called with a key of type `Literal[0]` and a value of type `int` on object of type `list[Literal[0]]`
[error] invalid-assignment - :1425:21 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: Literal[0], /) -> None, (key: slice[Any, Any, Any], value: Iterable[Literal[0]], /) -> None]` cannot be called with a key of type `Literal[0, 1]` and a value of type `int` on object of type `list[Literal[0]]`

pywin32 (https://github.com/mhammond/pywin32)

win32/Demos/win32console_demo.py

[error] no-matching-overload - :80:25 - No overload of bound method `get` matches arguments

com/win32com/demos/dump_clipboard.py

[error] invalid-argument-type - :31:33 -
Old: Argument to bound method `QueryGetData` is incorrect: Expected `PyFORMATETC`, found `tuple[Unknown, Unknown, Unknown, Unknown, @Todo]`
New: Argument to bound method `QueryGetData` is incorrect: Expected `PyFORMATETC`, found `tuple[Unknown, Unknown, Unknown, Unknown, Any]`
[error] invalid-argument-type - :36:37 -
Old: Argument to bound method `GetData` is incorrect: Expected `PyFORMATETC`, found `tuple[Unknown, Unknown, Unknown, Unknown, @Todo]`
New: Argument to bound method `GetData` is incorrect: Expected `PyFORMATETC`, found `tuple[Unknown, Unknown, Unknown, Unknown, Any]`

com/win32comext/shell/test/testSHFileOperation.py

[error] invalid-argument-type - :21:9 -
Old: Argument to function `SHFileOperation` is incorrect: Expected `SHFILEOPSTRUCT`, found `tuple[Literal[0], int, Unknown, Unknown, int]`
New: Argument to function `SHFileOperation` is incorrect: Expected `SHFILEOPSTRUCT`, found `tuple[Literal[0], int, str, str, int]`
[error] invalid-argument-type - :35:13 -
Old: Argument to function `SHFileOperation` is incorrect: Expected `SHFILEOPSTRUCT`, found `tuple[Literal[0], int, @Todo, None, int]`
New: Argument to function `SHFileOperation` is incorrect: Expected `SHFILEOPSTRUCT`, found `tuple[Literal[0], int, str, None, int]`
[error] invalid-argument-type - :56:9 -
Old: Argument to function `SHFileOperation` is incorrect: Expected `SHFILEOPSTRUCT`, found `tuple[Literal[0], int, Unknown, Unknown, int]`
New: Argument to function `SHFileOperation` is incorrect: Expected `SHFILEOPSTRUCT`, found `tuple[Literal[0], int, str, str, int]`

rich (https://github.com/Textualize/rich)

rich/console.py

[error] invalid-assignment - :1581:13 - Object of type `list[Styled]` is not assignable to `list[ConsoleRenderable]`
[error] invalid-argument-type - :1987:36 - Argument to bound method `append` is incorrect: Expected `Styled`, found `ConsoleRenderable`

rich/table.py

[error] invalid-argument-type - :548:64 - Argument to function `ratio_distribute` is incorrect: Expected `list[int]`, found `list[(Unknown & ~AlwaysFalsy) | Literal[0]]`
[error] invalid-argument-type - :582:69 - Argument to function `ratio_distribute` is incorrect: Expected `list[int]`, found `list[(Unknown & ~AlwaysFalsy) | Literal[1]] | list[(Unknown & ~AlwaysFalsy) | Literal[0]]`
[error] invalid-return-type - :585:16 - Return type does not match returned value: expected `list[int]`, found `list[(Unknown & ~AlwaysFalsy) | Literal[1]] | list[(Unknown & ~AlwaysFalsy) | Literal[0]] | list[Unknown]`
[error] invalid-argument-type - :620:53 - Argument to function `ratio_reduce` is incorrect: Expected `list[int]`, found `list[Literal[1, 0]]`

rotki (https://github.com/rotki/rotki)

rotkehlchen/chain/evm/decoding/paraswap/v5/decoder.py

[error] invalid-return-type - :61:16 - Return type does not match returned value: expected `dict[bytes, dict[bytes, (...) -> Unknown]]`, found `dict[Literal[b"\x0b\x86\xa4\xc1", b"\xf5f\x104", b"n\x91S\x8b", b"\xb2\xf1\xe6\xdb"], dict[Unknown | bytes, Unknown]]`

rotkehlchen/data_import/importers/cryptocom.py

[error] invalid-argument-type - :48:25 - Argument to function `hash_csv_row` is incorrect: Expected `Mapping[str, Any]`, found `dict[Any & ~Literal["_index"], Any]`

rotkehlchen/data_import/importers/binance.py

[error] invalid-argument-type - :58:25 - Argument to function `hash_csv_row` is incorrect: Expected `Mapping[str, Any]`, found `dict[str & ~Literal["_index"], Any]`

rotkehlchen/db/dbhandler.py

[error] invalid-assignment - :1502:9 - Object of type `list[tuple[@Todo, @Todo, Literal["tokens"], str]]` is not assignable to `list[tuple[@Todo, int, str, str | @Todo]]`

rotkehlchen/db/eth2.py

[warning] unused-ignore-comment - :354:40 - Unused blanket `type: ignore` directive

rotkehlchen/db/filtering.py

[error] invalid-argument-type - :825:57 - Argument is incorrect: Expected `list[DBFilter]`, found `list[DBNestedFilter]`

rotkehlchen/db/history_events.py

[error] invalid-assignment - :339:13 - Object of type `list[str]` is not assignable to `list[str | bytes]`

rotkehlchen/premium/premium.py

[error] invalid-return-type - :862:16 - Return type does not match returned value: expected `dict[str, bool]`, found `dict[Literal["eth_staking_view", "graphs_view", "event_analysis_view"], Unknown]`

rotkehlchen/rotkehlchen.py

[error] invalid-assignment - :1224:13 - Method `__setitem__` of type `(bound method dict[str, FVal].__setitem__(key: str, value: FVal, /) -> None) | Unknown` cannot be called with a key of type `Literal["percentage_of_net_value"]` and a value of type `@Todo | str` on object of type `dict[str, FVal] | Unknown`

rotkehlchen/tests/api/test_settings.py

[error] invalid-assignment - :215:13 - Object of type `list[str]` is not assignable to `str | list[str | dict[Unknown, Unknown]] | int | None`

rotkehlchen/tests/unit/globaldb/test_asset_updates.py

[error] invalid-argument-type - :577:13 - Argument to bound method `perform_update` is incorrect: Expected `dict[Asset, Literal["remote", "local"]] | None`, found `dict[Asset, Literal["remote"]]`

rotkehlchen/tests/unit/globaldb/test_globaldb_consistency.py

[error] invalid-argument-type - :136:13 - Argument to bound method `perform_update` is incorrect: Expected `dict[Asset, Literal["remote", "local"]] | None`, found `dict[Asset, Literal["remote"]]`

rotkehlchen/tests/unit/test_eth2.py

[error] invalid-assignment - :450:5 - Object of type `list[EthDepositEvent]` is not assignable to `list[HistoryBaseEntry[Unknown]]`

schema_salad (https://github.com/common-workflow-language/schema_salad)

schema_salad/dlang_codegen.py

[error] unsupported-operator - :226:21 - Operator `+=` is unsupported between objects of type `list[Unknown & ~Literal["None"]]` and `list[Unknown | str]`

schemathesis (https://github.com/schemathesis/schemathesis)

src/schemathesis/core/errors.py

[error] invalid-return-type - :462:12 - Return type does not match returned value: expected `list[str]`, found `list[str & ~AlwaysFalsy]`

src/schemathesis/graphql/loaders.py

[error] invalid-argument-type - :197:37 - Argument to function `_on_invalid_schema` is incorrect: Expected `list[str] | None`, found `list[str & ~AlwaysFalsy]`

src/schemathesis/openapi/loaders.py

[error] invalid-argument-type - :296:13 - Argument to bound method `__init__` is incorrect: Expected `list[str] | None`, found `list[str & ~AlwaysFalsy]`
[error] invalid-argument-type - :309:42 - Argument to bound method `__init__` is incorrect: Expected `list[str] | None`, found `list[str & ~AlwaysFalsy]`

src/schemathesis/pytest/lazy.py

[error] invalid-return-type - :289:12 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[str & ~Literal["case"], Unknown]`

src/schemathesis/specs/openapi/adapter/parameters.py

[error] invalid-assignment - :283:13 - Method `__setitem__` of type `bound method dict[str & ~Literal["schema"], Any].__setitem__(key: str & ~Literal["schema"], value: Any, /) -> None` cannot be called with a key of type `Literal["schema"]` and a value of type `@Todo` on object of type `dict[str & ~Literal["schema"], Any]`

scikit-build-core (https://github.com/scikit-build/scikit-build-core)

src/scikit_build_core/_vendor/pyproject_metadata/pyproject.py

[error] invalid-return-type - :153:16 - Return type does not match returned value: expected `list[tuple[str, str | None]]`, found `list[Never]`

scikit-learn (https://github.com/scikit-learn/scikit-learn)

sklearn/externals/array_api_extra/_lib/_lazy.py

[error] unresolved-attribute - :243:31 - Type `Array & ~int & ~float & ~complex` has no attribute `_meta`

scipy (https://github.com/scipy/scipy)

benchmarks/benchmarks/common.py

[warning] possibly-missing-attribute - :158:30 - Attribute `empty` on type `@Todo | ModuleType` may be missing
[error] unresolved-attribute - :158:30 - Type `object` has no attribute `empty`

scipy/_lib/_array_api_docs_tables.py

[error] invalid-return-type - :118:16 - Return type does not match returned value: expected `dict[str, dict[str, bool]]`, found `dict[Unknown | str, dict[Unknown | str, Literal[BackendSupportStatus.UNKNOWN]]]`
[error] invalid-return-type - :125:16 - Return type does not match returned value: expected `dict[str, dict[str, bool]]`, found `dict[Unknown | str, dict[Unknown | str, Literal[BackendSupportStatus.OUT_OF_SCOPE]]]`
[error] invalid-return-type - :158:12 - Return type does not match returned value: expected `dict[str, dict[str, bool]]`, found `dict[Unknown | str, dict[Unknown | str, Literal[BackendSupportStatus.YES, BackendSupportStatus.NO]]]`

scipy/_lib/array_api_extra/src/array_api_extra/_lib/_lazy.py

[error] unresolved-attribute - :243:31 - Type `Array & ~int & ~float & ~complex` has no attribute `_meta`

scipy/fft/_pocketfft/tests/test_real_transforms.py

[warning] possibly-missing-attribute - :65:9 -
Old: Attribute `close` on type `Any | dict[@Todo, @Todo]` may be missing
New: Attribute `close` on type `Any | dict[Any, Any]` may be missing

scipy/integrate/_ivp/ivp.py

[error] not-iterable - :734:46 -
Old: Object of type `list[@Todo] | None` may not be iterable
New: Object of type `list[list[Unknown]] | None` may not be iterable

scipy/linalg/blas.py

[error] no-matching-overload - :250:1 - No overload of bound method `update` matches arguments
[error] no-matching-overload - :254:1 - No overload of bound method `update` matches arguments

scipy/optimize/_minpack_py.py

[error] invalid-assignment - :178:9 - Method `__setitem__` of type `bound method dict[(Literal["nfev"] & Unknown) | (Literal["njev"] & Unknown) | (Literal["fjac"] & Unknown) | (Literal["r"] & Unknown) | (Literal["qtf"] & Unknown), Unknown].__setitem__(key: (Literal["nfev"] & Unknown) | (Literal["njev"] & Unknown) | (Literal["fjac"] & Unknown) | (Literal["r"] & Unknown) | (Literal["qtf"] & Unknown), value: Unknown, /) -> None` cannot be called with a key of type `Literal["fvec"]` and a value of type `Unknown` on object of type `dict[(Literal["nfev"] & Unknown) | (Literal["njev"] & Unknown) | (Literal["fjac"] & Unknown) | (Literal["r"] & Unknown) | (Literal["qtf"] & Unknown), Unknown]`

scipy/signal/_peak_finding.py

[error] unsupported-operator - :1087:13 - Operator `+=` is unsupported between objects of type `list[Unknown]` and `Literal[1]`
[error] non-subscriptable - :1092:37 - Cannot subscript object of type `int` with no `__getitem__` method
[warning] possibly-missing-attribute - :1107:17 - Attribute `append` on type `Unknown | list[Unknown] | int` may be missing
[warning] possibly-missing-attribute - :1108:17 - Attribute `append` on type `Unknown | list[Unknown] | int` may be missing

tools/check_python_h_first.py

[error] invalid-return-type - :209:12 - Return type does not match returned value: expected `list[str]`, found `list[str & ~AlwaysFalsy]`

scrapy (https://github.com/scrapy/scrapy)

scrapy/http/request/form.py

[error] invalid-assignment - :181:5 - Object of type `list[tuple[@Todo & ~AlwaysFalsy, Literal[""] | (@Todo & ~None)]]` is not assignable to `list[tuple[str, @Todo]]`

scrapy/spidermiddlewares/referer.py

[error] invalid-assignment - :290:1 - Object of type `dict[str, <class 'NoReferrerPolicy'> | <class 'NoReferrerWhenDowngradePolicy'> | <class 'SameOriginPolicy'> | ... omitted 6 union elements]` is not assignable to `dict[str, type[ReferrerPolicy]]`

scrapy/utils/python.py

[error] invalid-assignment - :247:9 - Object of type `dict[(Unknown & ~Literal["self"]) | (str & ~Literal["self"]), Unknown | Parameter]` is not assignable to `Mapping[str, Parameter]`
[error] invalid-return-type - :335:16 - Return type does not match returned value: expected `Iterable[_KT@without_none_values]`, found `dict[object, ~None]`

setuptools (https://github.com/pypa/setuptools)

setuptools/_distutils/version.py

[error] invalid-assignment - :322:17 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: Unknown & ~AlwaysFalsy & ~Literal["."], /) -> None, (key: slice[Any, Any, Any], value: Iterable[Unknown & ~AlwaysFalsy & ~Literal["."]], /) -> None]` cannot be called with a key of type `int` and a value of type `int` on object of type `list[Unknown & ~AlwaysFalsy & ~Literal["."]]`

setuptools/config/_validate_pyproject/__init__.py

[error] invalid-assignment - :20:1 - Object of type `dict[Any, Any & (() -> object)]` is not assignable to `dict[str, (str, /) -> bool]`

setuptools/_distutils/sysconfig.py

[error] invalid-return-type - :568:12 - Return type does not match returned value: expected `list[str | int] | dict[str, str | int]`, found `list[Any | None] | dict[str, Any]`

setuptools/_vendor/typeguard/_transformer.py

[error] invalid-argument-type - :799:21 - Argument to bound method `__init__` is incorrect: Expected `list[expr | None]`, found `list[Constant]`
[error] invalid-argument-type - :800:21 - Argument to bound method `__init__` is incorrect: Expected `list[expr]`, found `list[Tuple]`
[error] invalid-argument-type - :1127:25 - Argument to bound method `__init__` is incorrect: Expected `list[expr]`, found `list[Dict]`

setuptools/tests/test_wheel.py

[error] invalid-argument-type - :552:5 - Argument to bound method `__call__` is incorrect: Expected `Iterable[None | str | int | float] | ((Any, /) -> object) | None`, found `list[str | dict[Unknown | str, Unknown | dict[Unknown | str, Unknown | str]] | dict[str, list[Unknown | str]] | ... omitted 9 union elements]`

sockeye (https://github.com/awslabs/sockeye)

sockeye/data_io.py

[error] invalid-argument-type - :506:28 -
Old: Method `__getitem__` of type `Overload[(i: SupportsIndex, /) -> @Todo, (s: slice[Any, Any, Any], /) -> list[@Todo]]` cannot be called with key of type `int | None` on object of type `list[@Todo]`
New: Method `__getitem__` of type `Overload[(i: SupportsIndex, /) -> Literal[0], (s: slice[Any, Any, Any], /) -> list[Literal[0]]]` cannot be called with key of type `int | None` on object of type `list[Literal[0]]`
[error] invalid-argument-type - :508:17 -
Old: Method `__getitem__` of type `Overload[(i: SupportsIndex, /) -> @Todo, (s: slice[Any, Any, Any], /) -> list[@Todo]]` cannot be called with key of type `int | None` on object of type `list[@Todo]`
New: Method `__getitem__` of type `Overload[(i: SupportsIndex, /) -> Unknown, (s: slice[Any, Any, Any], /) -> list[Unknown]]` cannot be called with key of type `int | None` on object of type `list[Unknown]`
[error] invalid-argument-type - :513:21 -
Old: Method `__getitem__` of type `Overload[(i: SupportsIndex, /) -> @Todo, (s: slice[Any, Any, Any], /) -> list[@Todo]]` cannot be called with key of type `int | None` on object of type `list[@Todo]`
New: Method `__getitem__` of type `Overload[(i: SupportsIndex, /) -> Unknown, (s: slice[Any, Any, Any], /) -> list[Unknown]]` cannot be called with key of type `int | None` on object of type `list[Unknown]`
[error] invalid-argument-type - :517:21 -
Old: Method `__getitem__` of type `Overload[(i: SupportsIndex, /) -> @Todo, (s: slice[Any, Any, Any], /) -> list[@Todo]]` cannot be called with key of type `int | None` on object of type `list[@Todo]`
New: Method `__getitem__` of type `Overload[(i: SupportsIndex, /) -> Unknown, (s: slice[Any, Any, Any], /) -> list[Unknown]]` cannot be called with key of type `int | None` on object of type `list[Unknown]`
[error] invalid-argument-type - :519:17 -
Old: Method `__getitem__` of type `Overload[(i: SupportsIndex, /) -> @Todo, (s: slice[Any, Any, Any], /) -> list[@Todo]]` cannot be called with key of type `int | None` on object of type `list[@Todo]`
New: Method `__getitem__` of type `Overload[(i: SupportsIndex, /) -> Unknown, (s: slice[Any, Any, Any], /) -> list[Unknown]]` cannot be called with key of type `int | None` on object of type `list[Unknown]`
[error] invalid-argument-type - :522:13 -
Old: Method `__getitem__` of type `Overload[(i: SupportsIndex, /) -> @Todo, (s: slice[Any, Any, Any], /) -> list[@Todo]]` cannot be called with key of type `int | None` on object of type `list[@Todo]`
New: Method `__getitem__` of type `Overload[(i: SupportsIndex, /) -> Literal[0], (s: slice[Any, Any, Any], /) -> list[Literal[0]]]` cannot be called with key of type `int | None` on object of type `list[Literal[0]]`

sockeye/inference.py

[error] invalid-return-type - :1137:16 - Return type does not match returned value: expected `tuple[list[str], str, list[list[str]], list[str]]`, found `tuple[Unknown | list[Unknown], Unknown | Literal[""], list[Unknown] | list[list[Unknown]], list[Unknown] | list[Literal[""]]]`
[error] invalid-argument-type - :350:50 -
Old: Argument to function `len` is incorrect: Expected `Sized`, found `(Unknown & ~Top[list[Unknown]]) | None | list[@Todo]`
New: Argument to function `len` is incorrect: Expected `Sized`, found `(Unknown & ~Top[list[Unknown]]) | None | list[list[Unknown]]`
[error] invalid-argument-type - :352:34 -
Old: Argument to function `len` is incorrect: Expected `Sized`, found `(Unknown & ~Top[list[Unknown]]) | None | list[@Todo]`
New: Argument to function `len` is incorrect: Expected `Sized`, found `(Unknown & ~Top[list[Unknown]]) | None | list[list[Unknown]]`

sockeye/lr_scheduler.py

[error] invalid-return-type - :64:16 - Return type does not match returned value: expected `dict[str, Any]`, found `dict[Unknown & ~Literal["optimizer"], Unknown]`

sockeye/test_utils.py

[error] not-iterable - :105:101 -
Old: Object of type `None | list[@Todo]` may not be iterable
New: Object of type `None | list[list[str]]` may not be iterable

test/unit/test_data_io.py

[error] invalid-assignment - :304:9 - Object of type `list[None]` is not assignable to `list[int | None] | None`
[error] invalid-assignment - :305:5 - Object of type `list[int]` is not assignable to `list[int | None] | None`
[error] not-iterable - :306:41 - Object of type `list[int | None] | None` may not be iterable
[error] invalid-argument-type - :308:40 - Argument to function `__new__` is incorrect: Expected `Iterable[int | None]`, found `list[int | None] | None`
[error] invalid-argument-type - :310:40 - Argument to function `__new__` is incorrect: Expected `Iterable[int | None]`, found `list[int | None] | None`
[error] not-iterable - :311:78 - Object of type `list[int | None] | None` may not be iterable
[error] invalid-argument-type - :730:67 - Argument to function `_get_random_bucketed_data` is incorrect: Expected `list[int | None] | None`, found `list[Literal[20]]`
[error] invalid-argument-type - :732:67 - Argument to function `_get_random_bucketed_data` is incorrect: Expected `list[int | None] | None`, found `list[Literal[20]]`
[error] invalid-argument-type - :763:66 - Argument to function `_get_random_bucketed_data` is incorrect: Expected `list[int | None] | None`, found `list[Literal[20]]`
[error] invalid-return-type - :313:12 -
Old: Return type does not match returned value: expected `tuple[list[Unknown], list[Unknown], list[Unknown]]`, found `tuple[list[@Todo], list[@Todo], list[@Todo] | None]`
New: Return type does not match returned value: expected `tuple[list[Unknown], list[Unknown], list[Unknown]]`, found `tuple[list[Unknown], list[Unknown], list[Unknown] | None]`

spack (https://github.com/spack/spack)

lib/spack/spack/detection/common.py

[error] invalid-return-type - :428:12 - Return type does not match returned value: expected `list[str]`, found `list[Never]`

lib/spack/spack/detection/path.py

[error] invalid-assignment - :399:9 - Object of type `list[Pattern[str]]` is not assignable to `list[str]`
[error] unresolved-attribute - :403:20 - Type `str` has no attribute `search`

lib/spack/spack/repo.py

[error] invalid-argument-type - :683:13 - Argument to function `from_descriptors` is incorrect: Expected `dict[str, Any] | None`, found `dict[Unknown & ~Literal["all"], Unknown]`
[error] invalid-return-type - :878:16 - Return type does not match returned value: expected `list[str]`, found `list[Unknown & ~AlwaysFalsy]`

lib/spack/spack/solver/asp.py

[error] invalid-assignment - :4198:69 - Not enough values to unpack: Expected 3

lib/spack/spack/util/path.py

[error] invalid-argument-type - :207:22 - Argument to bound method `append` is incorrect: Expected `Literal["__spack_path_placeholder__"]`, found `LiteralString`

lib/spack/spack/vendor/attr/_make.py

[error] unresolved-attribute - :2653:33 - Type `Attribute` has no attribute `name`
[error] unresolved-attribute - :2655:29 - Type `Attribute` has no attribute `hash`
[error] unresolved-attribute - :2655:40 - Type `Attribute` has no attribute `name`

lib/spack/spack/vendor/jinja2/filters.py

[error] invalid-return-type - :1236:12 - Return type does not match returned value: expected `list[tuple[Any, list[V@sync_do_groupby]]]`, found `list[_GroupTuple]`
[error] invalid-return-type - :1250:12 - Return type does not match returned value: expected `list[tuple[Any, list[V@do_groupby]]]`, found `list[_GroupTuple]`

speedrun.com_global_scoreboard_webapp (https://github.com/Avasam/speedrun.com_global_scoreboard_webapp)

backend/services/utils.py

[error] invalid-assignment - :167:5 - Object of type `dict[str, str]` is not assignable to `dict[str, str | int]`

sphinx (https://github.com/sphinx-doc/sphinx)

sphinx/transforms/compact_bullet_list.py

[error] invalid-assignment - :35:9 - Object of type `list[Node & ~Invisible]` is not assignable to `list[Node]`

sphinx/util/_serialise.py

[error] invalid-return-type - :44:16 - Return type does not match returned value: expected `dict[str, Any] | list[Any] | str`, found `dict[dict[str, Any] | list[Any] | str, dict[str, Any] | list[Any] | str]`

sphinx/util/matching.py

[error] invalid-return-type - :66:12 - Return type does not match returned value: expected `list[(str, /) -> Match[str] | None]`, found `list[Overload[(string: str, pos: int = Literal[0], endpos: int = int) -> Match[str] | None, (string: @Todo, pos: int = Literal[0], endpos: int = int) -> Match[bytes] | None, (string: str, pos: int = Literal[0], endpos: int = int) -> Match[str] | None]]`

sphinx/domains/c/_symbol.py

[error] invalid-argument-type - :253:26 - Argument to bound method `__init__` is incorrect: Expected `Sequence[tuple[ASTIdentifier, str]]`, found `list[tuple[Unknown, None | Unknown]]`

sphinx/domains/cpp/_parser.py

[error] invalid-assignment - :2102:13 - Object of type `list[ASTTemplateParams]` is not assignable to `list[ASTTemplateParams | ASTTemplateIntroduction]`
[error] invalid-argument-type - :2106:38 -
Old: Argument to bound method `extend` is incorrect: Expected `Iterable[@Todo]`, found `Unknown | list[ASTTemplateParams | ASTTemplateIntroduction] | None`
New: Argument to bound method `extend` is incorrect: Expected `Iterable[ASTTemplateParams | ASTTemplateIntroduction]`, found `Unknown | list[ASTTemplateParams | ASTTemplateIntroduction] | None`

sphinx/ext/autodoc/importer.py

[error] invalid-return-type - :1261:20 - Return type does not match returned value: expected `list[tuple[str, str]]`, found `list[@Todo] | list[Unknown | tuple[str, str]] | list[tuple[Literal[""], @Todo | str]]`
[error] unsupported-operator - :1287:17 - Operator `+=` is unsupported between objects of type `list[tuple[Literal[""], @Todo | str]]` and `list[tuple[str, str]]`
[error] invalid-argument-type - :1306:35 - Argument to bound method `append` is incorrect: Expected `tuple[Literal[""], @Todo | str]`, found `tuple[str, str]`
[error] invalid-return-type - :1308:16 - Return type does not match returned value: expected `list[tuple[str, str]]`, found `list[@Todo] | list[Unknown | tuple[str, str]] | list[tuple[Literal[""], @Todo | str]]`
[error] invalid-argument-type - :1351:35 - Argument to bound method `append` is incorrect: Expected `tuple[Literal[""], @Todo | str]`, found `tuple[str, str]`
[error] invalid-return-type - :1352:20 - Return type does not match returned value: expected `list[tuple[str, str]]`, found `list[@Todo] | list[Unknown | tuple[str, str]] | list[tuple[Literal[""], @Todo | str]]`
[error] invalid-return-type - :1354:16 - Return type does not match returned value: expected `list[tuple[str, str]]`, found `list[@Todo] | list[Unknown | tuple[str, str]] | list[tuple[Literal[""], @Todo | str]]`
[error] invalid-return-type - :1370:20 - Return type does not match returned value: expected `list[tuple[str, str]]`, found `list[@Todo] | list[Unknown | tuple[str, str]] | list[tuple[Literal[""], @Todo | str]]`
[error] unsupported-operator - :1398:17 - Operator `+=` is unsupported between objects of type `list[tuple[Literal[""], @Todo | str]]` and `list[tuple[str, str]]`
[error] invalid-argument-type - :1428:35 - Argument to bound method `append` is incorrect: Expected `tuple[Literal[""], @Todo | str]`, found `tuple[str, str]`
[error] invalid-return-type - :1430:16 - Return type does not match returned value: expected `list[tuple[str, str]]`, found `list[@Todo] | list[Unknown | tuple[str, str]] | list[tuple[Literal[""], @Todo | str]]`
[error] invalid-return-type - :1432:12 - Return type does not match returned value: expected `list[tuple[str, str]]`, found `list[@Todo] | list[Unknown | tuple[str, str]] | list[tuple[Literal[""], @Todo | str]]`

sphinx/ext/inheritance_diagram.py

[error] invalid-return-type - :254:16 - Return type does not match returned value: expected `list[tuple[str, str, Sequence[str], str | None]]`, found `list[tuple[Unknown, Unknown, tuple[Unknown, ...], Unknown]]`

sphinx/ext/napoleon/docstring.py

[error] invalid-return-type - :152:12 - Return type does not match returned value: expected `list[str]`, found `list[str & ~AlwaysFalsy]`

sphinx/util/docutils.py

[error] invalid-argument-type - :870:32 - Argument to bound method `add_transforms` is incorrect: Expected `list[type[Transform]]`, found `list[type[Transform] & ~<class 'DanglingReferences'>]`

static-frame (https://github.com/static-frame/static-frame)

static_frame/core/container_util.py

[error] invalid-assignment - :1116:5 - Object of type `list[defaultdict[Unknown, Unknown]]` is not assignable to `list[dict[@Todo, int]]`

static_frame/core/frame.py

[error] invalid-assignment - :8375:29 - Method `__setitem__` of type `bound method dict[@Todo | None, Literal[False]].__setitem__(key: @Todo | None, value: Literal[False], /) -> None` cannot be called with a key of type `@Todo | None` and a value of type `Literal[True]` on object of type `dict[@Todo | None, Literal[False]]`

static_frame/core/store.py

[error] invalid-return-type - :98:16 - Return type does not match returned value: expected `tuple[None, dict[str, Any]]`, found `tuple[None, dict[Unknown & ~Literal["_weak_cache"], Any]]`

static_frame/test/property/strategies.py

[error] invalid-assignment - :745:9 - Object of type `list[None]` is not assignable to `list[Sequence[str] | None]`

static_frame/test/unit/test_loc_map.py

[error] invalid-argument-type - :238:79 - Argument to function `build_offsets_and_overflow` is incorrect: Expected `list[int]`, found `list[Literal[1048576]]`

static_frame/test/unit/test_type_blocks.py

[error] invalid-argument-type - :625:45 - Argument to bound method `from_element_items` is incorrect: Expected `Iterable[tuple[tuple[int, int], Any]]`, found `list[tuple[tuple[int, ...], Any]]`
[error] invalid-argument-type - :2265:45 - Argument to bound method `from_element_items` is incorrect: Expected `Iterable[tuple[tuple[int, int], Any]]`, found `list[tuple[tuple[int, ...], Any]]`

stone (https://github.com/dropbox/stone)

test/test_backend.py

[warning] possibly-missing-attribute - :373:29 -
Old: Attribute `fields` on type `@Todo | None` may be missing
New: Attribute `fields` on type `Unknown | None` may be missing
[warning] possibly-missing-attribute - :374:29 -
Old: Attribute `fields` on type `@Todo | None` may be missing
New: Attribute `fields` on type `Unknown | None` may be missing
[warning] possibly-missing-attribute - :376:17 -
Old: Attribute `fields` on type `@Todo | None` may be missing
New: Attribute `fields` on type `Unknown | None` may be missing
[warning] possibly-missing-attribute - :380:17 -
Old: Attribute `fields` on type `@Todo | None` may be missing
New: Attribute `fields` on type `Unknown | None` may be missing
[warning] possibly-missing-attribute - :469:30 -
Old: Attribute `fields` on type `@Todo | None` may be missing
New: Attribute `fields` on type `Unknown | None` may be missing
[warning] possibly-missing-attribute - :471:22 -
Old: Attribute `fields` on type `@Todo | None` may be missing
New: Attribute `fields` on type `Unknown | None` may be missing
[warning] possibly-missing-attribute - :495:30 -
Old: Attribute `fields` on type `@Todo | None` may be missing
New: Attribute `fields` on type `Unknown | None` may be missing
[warning] possibly-missing-attribute - :497:17 -
Old: Attribute `fields` on type `@Todo | None` may be missing
New: Attribute `fields` on type `Unknown | None` may be missing

strawberry (https://github.com/strawberry-graphql/strawberry)

strawberry/schema/validation_rules/one_of.py

[warning] unused-ignore-comment - :70:47 - Unused blanket `type: ignore` directive

strawberry/experimental/pydantic/error_type.py

[error] invalid-assignment - :107:9 - Object of type `list[tuple[Any, @Todo | type[list[Unknown]], dataclasses.Field[None]]]` is not assignable to `list[tuple[str, Any, Field[Unknown]]]`

strawberry/federation/schema.py

[error] invalid-assignment - :271:9 - Object of type `list[Link]` is not assignable to `list[object]`

sympy (https://github.com/sympy/sympy)

sympy/codegen/algorithms.py

[error] unsupported-operator - :92:9 - Operator `+=` is unsupported between objects of type `list[Assignment]` and `list[Unknown | While]`
[error] unsupported-operator - :93:5 - Operator `+=` is unsupported between objects of type `list[Assignment]` and `list[Unknown | AddAugmentedAssignment]`
[error] unsupported-operator - :98:9 - Operator `+=` is unsupported between objects of type `list[Assignment]` and `list[Unknown | Print]`
[error] invalid-argument-type - :105:24 - Argument to bound method `append` is incorrect: Expected `Assignment`, found `AddAugmentedAssignment`

sympy/logic/tests/test_inference.py

[error] invalid-assignment - :428:5 - Method `__setitem__` of type `bound method dict[Unknown, int & ~Literal[11] & ~Literal[12]].__setitem__(key: Unknown, value: int & ~Literal[11] & ~Literal[12], /) -> None` cannot be called with a key of type `Unknown` and a value of type `Literal[11]` on object of type `dict[Unknown, int & ~Literal[11] & ~Literal[12]]`
[error] invalid-assignment - :429:5 - Method `__setitem__` of type `bound method dict[Unknown, int & ~Literal[11] & ~Literal[12]].__setitem__(key: Unknown, value: int & ~Literal[11] & ~Literal[12], /) -> None` cannot be called with a key of type `Unknown` and a value of type `Literal[12]` on object of type `dict[Unknown, int & ~Literal[11] & ~Literal[12]]`

sympy/matrices/determinant.py

[error] invalid-assignment - :66:17 - Object of type `list[tuple[int, Zero]]` is not assignable to `list[tuple[int, Expr]]`

sympy/parsing/latex/__init__.py

[error] index-out-of-bounds - :117:12 - Index 3 is out of bounds for tuple `tuple[@Todo, @Todo]` with length 2
[error] index-out-of-bounds - :118:30 - Index 2 is out of bounds for tuple `tuple[@Todo, @Todo]` with length 2
[error] index-out-of-bounds - :120:59 - Index 3 is out of bounds for tuple `tuple[@Todo, @Todo]` with length 2
[error] index-out-of-bounds - :125:12 - Index 7 is out of bounds for tuple `tuple[@Todo, @Todo]` with length 2
[error] index-out-of-bounds - :126:30 - Index 2 is out of bounds for tuple `tuple[@Todo, @Todo]` with length 2
[error] index-out-of-bounds - :128:53 - Index 3 is out of bounds for tuple `tuple[@Todo, @Todo]` with length 2
[error] index-out-of-bounds - :133:43 - Index 3 is out of bounds for tuple `tuple[@Todo, @Todo]` with length 2
[error] index-out-of-bounds - :135:30 - Index 5 is out of bounds for tuple `tuple[@Todo, @Todo]` with length 2
[error] index-out-of-bounds - :136:12 - Index 7 is out of bounds for tuple `tuple[@Todo, @Todo]` with length 2
[error] index-out-of-bounds - :139:37 - Index 2 is out of bounds for tuple `tuple[@Todo, @Todo]` with length 2
[error] index-out-of-bounds - :140:30 - Index 6 is out of bounds for tuple `tuple[@Todo, @Todo]` with length 2
[error] index-out-of-bounds - :140:47 - Index 4 is out of bounds for tuple `tuple[@Todo, @Todo]` with length 2
[error] index-out-of-bounds - :141:65 - Index 5 is out of bounds for tuple `tuple[@Todo, @Todo]` with length 2

sympy/polys/fglmtools.py

[error] invalid-argument-type - :57:22 - Argument to bound method `extend` is incorrect: Expected `Iterable[tuple[int, Literal[0]]]`, found `list[tuple[int, int]]`

sympy/polys/matrices/linsolve.py

[error] invalid-assignment - :114:9 - Method `__setitem__` of type `bound method dict[Unknown, Add].__setitem__(key: Unknown, value: Add, /) -> None` cannot be called with a key of type `Unknown` and a value of type `Zero` on object of type `dict[Unknown, Add]`

sympy/tensor/array/expressions/from_array_to_indexed.py

[error] invalid-assignment - :36:21 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: None, /) -> None, (key: slice[Any, Any, Any], value: Iterable[None], /) -> None]` cannot be called with a key of type `Unknown` and a value of type `Dummy` on object of type `list[None]`

sympy/calculus/finite_diff.py

[error] invalid-assignment - :176:5 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: Literal[0], /) -> None, (key: slice[Any, Any, Any], value: Iterable[Literal[0]], /) -> None]` cannot be called with a key of type `Literal[0]` and a value of type `One` on object of type `list[Literal[0]]`
[error] invalid-argument-type - :400:12 -
Old: Argument to function `len` is incorrect: Expected `Sized`, found `Unknown | Literal[1] | list[@Todo]`
New: Argument to function `len` is incorrect: Expected `Sized`, found `Unknown | Literal[1] | list[Unknown]`
[error] not-iterable - :404:14 -
Old: Object of type `Unknown | Literal[1] | list[@Todo]` may not be iterable
New: Object of type `Unknown | Literal[1] | list[Unknown]` may not be iterable

sympy/combinatorics/galois.py

[error] invalid-argument-type - :476:49 - Argument to function `len` is incorrect: Expected `Sized`, found `int`

sympy/core/symbol.py

[error] invalid-argument-type - :870:43 - Argument to bound method `append` is incorrect: Expected `list[str]`, found `list[LiteralString]`

sympy/core/tests/test_function.py

[error] invalid-argument-type - :1053:18 -
Old: Argument to function `symbols` is incorrect: Expected `str`, found `list[@Todo]`
New: Argument to function `symbols` is incorrect: Expected `str`, found `list[str]`

sympy/diffgeom/diffgeom.py

[error] unsupported-operator - :495:28 - Operator `+` is unsupported between objects of type `Unknown | int | list[Unknown]` and `Literal[1]`
[error] invalid-argument-type - :498:49 - Argument to bound method `__init__` is incorrect: Expected `Iterable[Unknown]`, found `Unknown | int | list[Unknown]`
[warning] possibly-missing-attribute - :499:21 - Attribute `append` on type `Unknown | int | list[Unknown]` may be missing
[error] unsupported-operator - :507:20 - Operator `<` is not supported for types `int` and `list[Unknown]`, in comparing `Literal[0]` with `Unknown | int | list[Unknown]`
[error] unsupported-operator - :507:24 - Operator `<=` is not supported for types `int` and `list[Unknown]`, in comparing `Unknown | int | list[Unknown]` with `Unknown | int | list[Unknown]`
[warning] possibly-missing-attribute - :515:9 - Attribute `append` on type `Unknown | int | list[Unknown]` may be missing

sympy/functions/elementary/complexes.py

[error] invalid-argument-type - :790:28 - Argument to function `__new__` is incorrect: Expected `Expr | int | float | complex`, found `Basic`

sympy/holonomic/holonomic.py

[error] invalid-assignment - :1007:33 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: Literal[0], /) -> None, (key: slice[Any, Any, Any], value: Iterable[Literal[0]], /) -> None]` cannot be called with a key of type `int` and a value of type `binomial` on object of type `list[Literal[0]]`
[error] invalid-assignment - :1157:9 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: Zero, /) -> None, (key: slice[Any, Any, Any], value: Iterable[Zero], /) -> None]` cannot be called with a key of type `Literal[0]` and a value of type `One` on object of type `list[Zero]`
[error] not-iterable - :681:18 -
Old: Object of type `None | dict[Unknown | Zero, Unknown | list[@Todo]] | Unknown` may not be iterable
New: Object of type `None | dict[Unknown | Zero, Unknown | list[Unknown]] | Unknown` may not be iterable
[error] unsupported-operator - :684:16 -
Old: Operator `in` is not supported for types `Unknown` and `None`, in comparing `Unknown | Zero | list[@Todo]` with `None | Unknown | dict[Unknown | Zero, Unknown | list[@Todo]]`
New: Operator `in` is not supported for types `Unknown` and `None`, in comparing `Unknown | Zero | list[Unknown]` with `None | Unknown | dict[Unknown | Zero, Unknown | list[Unknown]]`
[error] not-iterable - :688:18 -
Old: Object of type `None | Unknown | dict[Unknown | Zero, Unknown | list[@Todo]]` may not be iterable
New: Object of type `None | Unknown | dict[Unknown | Zero, Unknown | list[Unknown]]` may not be iterable
[error] unsupported-operator - :689:16 -
Old: Operator `not in` is not supported for types `Unknown` and `None`, in comparing `Unknown | Zero | list[@Todo]` with `None | dict[Unknown | Zero, Unknown | list[@Todo]] | Unknown`
New: Operator `not in` is not supported for types `Unknown` and `None`, in comparing `Unknown | Zero | list[Unknown]` with `None | dict[Unknown | Zero, Unknown | list[Unknown]] | Unknown`
[error] not-iterable - :1054:18 -
Old: Object of type `None | dict[Unknown | Zero, Unknown | list[@Todo]] | Unknown` may not be iterable
New: Object of type `None | dict[Unknown | Zero, Unknown | list[Unknown]] | Unknown` may not be iterable
[error] not-iterable - :1055:22 -
Old: Object of type `None | Unknown | dict[Unknown | Zero, Unknown | list[@Todo]]` may not be iterable
New: Object of type `None | Unknown | dict[Unknown | Zero, Unknown | list[Unknown]]` may not be iterable

sympy/integrals/manualintegrate.py

[warning] unused-ignore-comment - :1257:36 - Unused blanket `type: ignore` directive

sympy/matrices/solvers.py

[error] unresolved-attribute - :631:12 -
Old: Type `list[@Todo]` has no attribute `reshape`
New: Type `list[Unknown]` has no attribute `reshape`

sympy/matrices/tests/test_eigen.py

[error] invalid-assignment - :178:9 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: Literal[0], /) -> None, (key: slice[Any, Any, Any], value: Iterable[Literal[0]], /) -> None]` cannot be called with a key of type `int` and a value of type `Symbol` on object of type `list[Literal[0]]`

sympy/physics/quantum/state.py

[error] invalid-assignment - :748:17 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: None, /) -> None, (key: slice[Any, Any, Any], value: Iterable[None], /) -> None]` cannot be called with a key of type `int` and a value of type `Tuple` on object of type `list[None]`

sympy/physics/secondquant.py

[warning] possibly-missing-attribute - :2663:12 - Attribute `get` on type `Unknown | property` may be missing
[warning] possibly-missing-attribute - :2665:14 - Attribute `get` on type `Unknown | property` may be missing

sympy/polys/densebasic.py

[error] invalid-return-type - :1214:12 - Return type does not match returned value: expected `dict[tuple[int, ...], Er@dup_to_dict]`, found `dict[tuple[int], Unknown & ~AlwaysFalsy]`
[error] invalid-return-type - :1235:12 - Return type does not match returned value: expected `dict[int, Er@dup_to_raw_dict]`, found `dict[int, Unknown & ~AlwaysFalsy]`

sympy/polys/distributedmodules.py

[error] non-subscriptable - :643:22 -
Old: Cannot subscript object of type `set[@Todo]` with no `__getitem__` method
New: Cannot subscript object of type `set[tuple[tuple[Unknown, ...], int]]` with no `__getitem__` method
[error] non-subscriptable - :644:22 -
Old: Cannot subscript object of type `set[@Todo]` with no `__getitem__` method
New: Cannot subscript object of type `set[tuple[tuple[Unknown, ...], int]]` with no `__getitem__` method
[warning] possibly-missing-attribute - :656:9 -
Old: Attribute `append` on type `list[Unknown] | set[@Todo]` may be missing
New: Attribute `append` on type `list[Unknown] | set[tuple[tuple[Unknown, ...], int]]` may be missing
[error] non-subscriptable - :665:48 -
Old: Cannot subscript object of type `set[@Todo]` with no `__getitem__` method
New: Cannot subscript object of type `set[tuple[tuple[Unknown, ...], int]]` with no `__getitem__` method
[error] non-subscriptable - :666:48 -
Old: Cannot subscript object of type `set[@Todo]` with no `__getitem__` method
New: Cannot subscript object of type `set[tuple[tuple[Unknown, ...], int]]` with no `__getitem__` method
[error] non-subscriptable - :673:64 -
Old: Cannot subscript object of type `set[@Todo]` with no `__getitem__` method
New: Cannot subscript object of type `set[tuple[tuple[Unknown, ...], int]]` with no `__getitem__` method
[error] non-subscriptable - :674:52 -
Old: Cannot subscript object of type `set[@Todo]` with no `__getitem__` method
New: Cannot subscript object of type `set[tuple[tuple[Unknown, ...], int]]` with no `__getitem__` method

sympy/polys/numberfields/galois_resolvents.py

[error] invalid-argument-type - :445:20 -
Old: Argument to function `symbols` is incorrect: Expected `str`, found `list[@Todo]`
New: Argument to function `symbols` is incorrect: Expected `str`, found `list[str]`

sympy/polys/polyclasses.py

[error] invalid-return-type - :2007:20 - Return type does not match returned value: expected `list[tuple[@Todo, Er@DUP_Flint]]`, found `list[tuple[tuple[int], Unknown & ~AlwaysFalsy]]`

sympy/polys/polyfuncs.py

[error] unsupported-operator - :84:20 -
Old: Operator `+` is unsupported between objects of type `list[Unknown] | Unknown` and `tuple[list[@Todo]]`
New: Operator `+` is unsupported between objects of type `list[Unknown] | Unknown` and `tuple[list[tuple[Unknown, Unknown]]]`

sympy/polys/polytools.py

[warning] possibly-missing-attribute - :6582:29 - Attribute `base` on type `Unknown | (Expr & ~<Protocol with members '_eval_factor'>)` may be missing

sympy/polys/puiseux.py

[warning] unused-ignore-comment - :364:75 - Unused blanket `type: ignore` directive

sympy/polys/tests/test_rootoftools.py

[error] invalid-argument-type - :164:17 - Argument to bound method `count` is incorrect: Expected `Equality`, found `Literal[True]`
[error] unresolved-attribute - :274:5 - Type `RootOf` has no attribute `_reset`
[error] unresolved-attribute - :276:13 - Type `RootOf` has no attribute `_get_interval`
[error] unresolved-attribute - :278:21 - Type `RootOf` has no attribute `_get_interval`
[error] unresolved-attribute - :279:9 - Type `RootOf` has no attribute `_reset`
[error] unresolved-attribute - :280:21 - Type `RootOf` has no attribute `_get_interval`

sympy/printing/smtlib.py

[error] unresolved-attribute - :564:57 - Type `property` has no attribute `is_Symbol`
[error] unresolved-attribute - :566:57 - Type `property` has no attribute `is_Symbol`
[error] unresolved-attribute - :574:16 - Type `property` has no attribute `is_Function`
[error] unresolved-attribute - :576:21 - Type `property` has no attribute `is_Boolean`
[error] unresolved-attribute - :577:20 - Type `property` has no attribute `is_integer`
[error] unresolved-attribute - :577:40 - Type `property` has no attribute `is_Integer`
[error] unresolved-attribute - :578:22 - Type `property` has no attribute `is_real`

sympy/series/order.py

[warning] possibly-missing-attribute - :209:45 -
Old: Attribute `items` on type `dict[@Todo, @Todo] | tuple[()]` may be missing
New: Attribute `items` on type `dict[Unknown, Unknown] | tuple[()]` may be missing

sympy/sets/sets.py

[error] invalid-argument-type - :1732:29 - Argument to bound method `append` is incorrect: Expected `FiniteSet`, found `Intersection`
[error] invalid-argument-type - :2523:20 - Argument to function `__new__` is incorrect: Expected `str`, found `str | Symbol`

sympy/simplify/_cse_diff.py

[error] invalid-argument-type - :162:32 - Argument to bound method `from_dok` is incorrect: Expected `dict[tuple[int, int], Expr]`, found `dict[tuple[Literal[0], int], (Unknown & ~Literal[0]) | Expr]`
[error] invalid-argument-type - :168:37 - Argument to bound method `from_dok` is incorrect: Expected `dict[tuple[int, int], Expr]`, found `dict[tuple[Literal[0], int], (Unknown & ~Literal[0]) | Expr]`
[error] invalid-argument-type - :173:37 - Argument to bound method `from_dok` is incorrect: Expected `dict[tuple[int, int], Expr]`, found `dict[tuple[Literal[0], int], (Unknown & ~Literal[0]) | Expr]`

sympy/simplify/radsimp.py

[error] invalid-assignment - :455:9 - Method `__setitem__` of type `bound method dict[Unknown, Add].__setitem__(key: Unknown, value: Add, /) -> None` cannot be called with a key of type `One` and a value of type `Zero | Unknown` on object of type `dict[Unknown, Add]`

sympy/simplify/simplify.py

[error] invalid-assignment - :224:9 - Method `__setitem__` of type `bound method dict[Unknown, list[Unknown]].__setitem__(key: Unknown, value: list[Unknown], /) -> None` cannot be called with a key of type `Unknown` and a value of type `Mul` on object of type `dict[Unknown, list[Unknown]]`
[error] unsupported-operator - :1937:27 -
Old: Operator `+` is unsupported between objects of type `tuple[@Todo | int]` and `Unknown | list[@Todo]`
New: Operator `+` is unsupported between objects of type `tuple[@Todo | int]` and `Unknown | list[Unknown]`

sympy/solvers/ode/lie_group.py

[error] invalid-argument-type - :698:38 - Argument to function `__new__` is incorrect: Expected `Expr | int | float | complex`, found `Basic`

sympy/solvers/ode/ode.py

[error] unsupported-operator - :2714:16 - Operator `-` is unsupported between objects of type `Unknown | Basic` and `Unknown | Basic`

sympy/solvers/recurr.py

[warning] possibly-missing-attribute - :828:20 - Attribute `is_Function` on type `Unknown | int` may be missing
[warning] possibly-missing-attribute - :828:38 - Attribute `func` on type `Unknown | int` may be missing
[warning] possibly-missing-attribute - :829:29 - Attribute `args` on type `Unknown | int` may be missing

sympy/solvers/simplex.py

[error] invalid-argument-type - :1068:84 -
Old: Argument to function `__new__` is incorrect: Expected `Iterable[Unknown]`, found `None | @Todo`
New: Argument to function `__new__` is incorrect: Expected `Iterable[Unknown]`, found `None | MutableDenseMatrix`
[error] invalid-argument-type - :1068:47 - Argument to function `__new__` is incorrect: Expected `Iterable[Unknown]`, found `Unknown | MutableDenseMatrix`
[error] invalid-argument-type - :1069:34 -
Old: Argument to function `__new__` is incorrect: Expected `Iterable[Unknown]`, found `Unknown | None`
New: Argument to function `__new__` is incorrect: Expected `Iterable[Unknown]`, found `Unknown | None | list[Unknown] | list[Unknown | tuple[int, None]]`

sympy/stats/joint_rv.py

[error] invalid-assignment - :103:17 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: list[Unknown | Symbol], /) -> None, (key: slice[Any, Any, Any], value: Iterable[list[Unknown | Symbol]], /) -> None]` cannot be called with a key of type `Literal[0]` and a value of type `tuple[Unknown | Symbol, ...]` on object of type `list[list[Unknown | Symbol]]`

sympy/tensor/array/expressions/from_array_to_matrix.py

[error] invalid-assignment - :668:17 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: Literal[False], /) -> None, (key: slice[Any, Any, Any], value: Iterable[Literal[False]], /) -> None]` cannot be called with a key of type `Unknown` and a value of type `Literal[True]` on object of type `list[Literal[False]]`
[error] invalid-assignment - :679:17 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: Literal[False], /) -> None, (key: slice[Any, Any, Any], value: Iterable[Literal[False]], /) -> None]` cannot be called with a key of type `Unknown` and a value of type `Literal[True]` on object of type `list[Literal[False]]`

sympy/tensor/tensor.py

[error] invalid-assignment - :3687:13 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: None, /) -> None, (key: slice[Any, Any, Any], value: Iterable[None], /) -> None]` cannot be called with a key of type `int` and a value of type `Tensor` on object of type `list[None]`
[error] invalid-assignment - :3704:17 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: None, /) -> None, (key: slice[Any, Any, Any], value: Iterable[None], /) -> None]` cannot be called with a key of type `int` and a value of type `Literal[0]` on object of type `list[None]`

sympy/testing/runtests.py

[error] invalid-argument-type - :1190:36 - Argument to bound method `__init__` is incorrect: Expected `list[expr]`, found `list[Name]`
[error] invalid-argument-type - :1193:71 - Argument to bound method `__init__` is incorrect: Expected `list[expr]`, found `list[Name]`
[error] invalid-argument-type - :1195:63 - Argument to bound method `__init__` is incorrect: Expected `list[expr]`, found `list[Name]`

sympy/utilities/codegen.py

[error] unsupported-operator - :1335:23 - Operator `-` is unsupported between objects of type `set[Basic]` and `set[property]`
[error] unsupported-operator - :1547:23 - Operator `-` is unsupported between objects of type `set[Basic]` and `set[property]`
[error] unsupported-operator - :638:19 - Operator `-` is unsupported between objects of type `set[Basic]` and `set[Unknown] | set[property]`
[error] unsupported-operator - :1780:19 -
Old: Operator `-` is unsupported between objects of type `set[Basic]` and `set[<class 'Indexed'>]`
New: Operator `-` is unsupported between objects of type `set[Basic]` and `set[property]`

tornado (https://github.com/tornadoweb/tornado)

tornado/netutil.py

[error] invalid-return-type - :436:16 - Return type does not match returned value: expected `list[tuple[int, Any]]`, found `list[tuple[AddressFamily, tuple[str, int] | tuple[str, int, int, int]]]`

trio (https://github.com/python-trio/trio)

src/trio/_tests/test_file_io.py

[error] unsupported-operator - :129:5 - Operator `+=` is unsupported between objects of type `list[tuple[str, Literal["async"]]]` and `list[tuple[str, Literal["sync"]]]`

src/trio/_tests/test_highlevel_open_tcp_listeners.py

[error] invalid-return-type - :265:16 - Return type does not match returned value: expected `list[tuple[AddressFamily, SocketKind, int, str, tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes]]]`, found `list[tuple[Unknown, Literal[SocketKind.SOCK_STREAM], Literal[0], Literal[""], tuple[Unknown, int]]]`

urllib3 (https://github.com/urllib3/urllib3)

src/urllib3/util/response.py

[error] invalid-argument-type - :88:34 - Argument to bound method `__init__` is incorrect: Expected `list[MessageDefect]`, found `list[MessageDefect & ~StartBoundaryNotFoundDefect & ~MultipartInvariantViolationDefect]`

src/urllib3/contrib/pyopenssl.py

[error] invalid-return-type - :271:12 - Return type does not match returned value: expected `list[tuple[str, str]]`, found `list[tuple[Literal["DNS"], Unknown & ~None]]`

src/urllib3/util/ssl_.py

[error] invalid-argument-type - :169:33 - Argument to bound method `get` is incorrect: Expected `Literal[32, 40, 64]`, found `int`

src/urllib3/util/url.py

[warning] unused-ignore-comment - :423:67 - Unused blanket `type: ignore` directive

test/with_dummyserver/test_https.py

[error] invalid-argument-type - :1159:33 - Argument to bound method `setitem` is incorrect: Expected `Mapping[int, Any | None]`, found `dict[Literal[32, 40, 64], Any | None]`

vision (https://github.com/pytorch/vision)

references/optical_flow/train.py

[warning] possibly-missing-attribute - :91:26 - Attribute `to` on type `Unknown | None` may be missing
[warning] possibly-missing-attribute - :91:45 - Attribute `to` on type `Unknown | None` may be missing

test/test_datasets_download.py

[error] invalid-assignment - :67:17 - Method `__setitem__` of type `bound method dict[Literal["data", "headers", "origin_req_host", "unverifiable"], Any].__setitem__(key: Literal["data", "headers", "origin_req_host", "unverifiable"], value: Any, /) -> None` cannot be called with a key of type `Literal["method"]` and a value of type `(Unknown & str) | (Unknown & None)` on object of type `dict[Literal["data", "headers", "origin_req_host", "unverifiable"], Any]`

test/test_transforms_v2.py

[error] invalid-argument-type - :3512:35 -
Old: Argument to bound method `__init__` is incorrect: Expected `Literal["constant", "edge", "reflect", "symmetric"]`, found `list[@Todo] | Unknown`
New: Argument to bound method `__init__` is incorrect: Expected `Literal["constant", "edge", "reflect", "symmetric"]`, found `list[Unknown] | Unknown`

torchvision/prototype/datasets/_builtin/pcam.py

[error] invalid-return-type - :104:16 - Return type does not match returned value: expected `list[OnlineResource]`, found `list[GDriveResource]`

torchvision/transforms/autoaugment.py

[error] invalid-argument-type - :279:92 - Argument to function `_apply_op` is incorrect: Expected `list[int | float] | None`, found `Unknown | list[Unknown | float] | list[float]`
[error] invalid-argument-type - :363:88 - Argument to function `_apply_op` is incorrect: Expected `list[int | float] | None`, found `Unknown | list[Unknown | float] | list[float]`
[error] invalid-argument-type - :453:85 - Argument to function `_apply_op` is incorrect: Expected `list[int | float] | None`, found `Unknown | list[Unknown | float] | list[float]`
[error] invalid-argument-type - :595:92 - Argument to function `_apply_op` is incorrect: Expected `list[int | float] | None`, found `Unknown | list[Unknown | float] | list[float]`

torchvision/transforms/transforms.py

[error] invalid-argument-type - :805:83 - Argument to function `perspective` is incorrect: Expected `list[int | float] | None`, found `Unknown | list[Unknown | float] | list[float]`
[error] invalid-argument-type - :1372:83 - Argument to function `rotate` is incorrect: Expected `list[int | float] | None`, found `Unknown | list[Unknown | float] | list[float]`
[error] invalid-argument-type - :1529:70 - Argument to function `affine` is incorrect: Expected `list[int | float] | None`, found `Unknown | list[Unknown | float] | list[float]`

torchvision/transforms/v2/functional/_geometry.py

[error] invalid-assignment - :664:13 - Object of type `list[float]` is not assignable to `list[int | float] | None`
[error] invalid-argument-type - :926:58 - Argument to function `_get_inverse_affine_matrix` is incorrect: Expected `list[int | float]`, found `list[float]`

torchvision/utils.py

[warning] unused-ignore-comment - :765:71 - Unused blanket `type: ignore` directive
[warning] unused-ignore-comment - :766:20 - Unused blanket `type: ignore` directive

werkzeug (https://github.com/pallets/werkzeug)

src/werkzeug/routing/rules.py

[error] invalid-assignment - :770:13 - Object of type `list[Call | Constant]` is not assignable to `list[expr]`

tests/test_routing.py

[warning] possibly-missing-attribute - :601:5 -
Old: Attribute `add` on type `Unknown | None | set[@Todo]` may be missing
New: Attribute `add` on type `Unknown | None | set[str]` may be missing
[warning] possibly-missing-attribute - :603:5 -
Old: Attribute `discard` on type `Unknown | None | set[@Todo]` may be missing
New: Attribute `discard` on type `Unknown | None | set[str]` may be missing

xarray (https://github.com/pydata/xarray)

properties/test_properties.py

[error] invalid-argument-type - :59:39 - Argument to function `find_independent_seasons` is incorrect: Expected `Sequence[str]`, found `list[list[Unknown]]`

xarray/computation/fit.py

[error] invalid-argument-type - :506:13 - Argument to bound method `extend` is incorrect: Expected `Iterable[list[Unknown] & ~AlwaysFalsy]`, found `list[list[Unknown]]`

xarray/computation/rolling.py

[error] invalid-return-type - :243:24 - Return type does not match returned value: expected `list[_T@_mapping_to_list]`, found `list[_T@_mapping_to_list | None]`

xarray/core/common.py

[error] invalid-return-type - :518:16 - Return type does not match returned value: expected `dict[Hashable, T@_calc_assign_results]`, found `dict[Any, @Todo | (T@_calc_assign_results & ~(() -> object)) | (((C@_calc_assign_results, /) -> T@_calc_assign_results) & ~(() -> object))]`

xarray/core/dataarray.py

[error] invalid-assignment - :164:21 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: str, /) -> None, (key: slice[Any, Any, Any], value: Iterable[str], /) -> None]` cannot be called with a key of type `int` and a value of type `Hashable` on object of type `list[str]`

xarray/core/dataset.py

[error] invalid-assignment - :3018:9 - Object of type `list[(list[int] & ~AlwaysFalsy) | (@Todo & ~slice[object, object, object] & ~AlwaysFalsy)]` is not assignable to `list[list[int]]`
[error] invalid-argument-type - :6947:13 - Argument to function `merge_coordinates_without_align` is incorrect: Expected `list[Coordinates]`, found `list[DataArrayCoordinates[Unknown]]`

xarray/plot/facetgrid.py

[error] invalid-assignment - :235:13 - Object of type `list[dict[Unknown | (Hashable & ~AlwaysFalsy), Unknown]]` is not assignable to `list[dict[Hashable, Any] | None]`
[error] invalid-assignment - :238:13 - Object of type `list[None]` is not assignable to `list[dict[Hashable, Any] | None]`

xarray/tests/test_indexing.py

[error] invalid-assignment - :714:9 - Method `__setitem__` of type `Overload[(key: SupportsIndex, value: slice[Any, Any, Any], /) -> None, (key: slice[Any, Any, Any], value: Iterable[slice[Any, Any, Any]], /) -> None]` cannot be called with a key of type `Literal[0]` and a value of type `Literal[3]` on object of type `list[slice[Any, Any, Any]]`

xarray/util/generate_aggregations.py

[error] invalid-argument-type - :443:33 - Argument to bound method `append` is incorrect: Expected `Unknown & ~AlwaysFalsy`, found `str`
[error] invalid-argument-type - :501:33 - Argument to bound method `append` is incorrect: Expected `Unknown & ~AlwaysFalsy`, found `str`

zulip (https://github.com/zulip/zulip)

zerver/lib/server_initialization.py

[error] invalid-argument-type - :94:16 - Argument to function `bulk_create_users` is incorrect: Expected `set[tuple[str, str, bool]]`, found `set[tuple[str, str, Literal[True]]]`

analytics/views/stats.py

[error] invalid-argument-type - :540:21 - Argument to function `get_time_series_by_subgroup` is incorrect: Expected `dict[str | None, str]`, found `dict[str | None, str] | Unknown | dict[Unknown | str, Unknown | str] | dict[str, Unknown] | dict[Unknown | None, Unknown | str]`
[error] invalid-assignment - :566:5 - Object of type `dict[str, int]` is not assignable to `dict[str, int | float]`

zerver/actions/message_send.py

[error] unresolved-attribute - :939:21 - Type `Message` has no attribute `realm_id`
[warning] possibly-missing-attribute - :1014:24 - Attribute `realm_id` on type `Stream | (Unknown & ~None)` may be missing
[warning] possibly-missing-attribute - :1027:35 - Attribute `id` on type `Stream | (Unknown & ~None)` may be missing
[warning] possibly-missing-attribute - :1068:31 - Attribute `id` on type `Stream | (Unknown & ~None)` may be missing
[error] unresolved-attribute - :1110:21 - Type `Message` has no attribute `sender_id`
[warning] possibly-missing-attribute - :1225:37 - Attribute `realm_id` on type `Stream | (Unknown & ~None)` may be missing
[warning] possibly-missing-attribute - :1252:73 - Attribute `id` on type `Stream | (Unknown & ~None)` may be missing
[error] unresolved-attribute - :1283:39 - Type `Message` has no attribute `sender_id`

zerver/actions/streams.py

[error] unresolved-attribute - :1112:30 - Type `Subscription` has no attribute `id`
[error] unresolved-attribute - :1117:38 - Type `Stream` has no attribute `id`
[error] unresolved-attribute - :1152:41 - Type `Stream` has no attribute `id`

zerver/data_import/slack.py

[error] invalid-argument-type - :1355:26 - Method `__getitem__` of type `bound method dict[str, str].__getitem__(key: str, /) -> str` cannot be called with key of type `Unknown | int` on object of type `dict[str, str]`
[error] not-iterable - :1371:30 - Object of type `Unknown | int` may not be iterable

zerver/lib/bulk_create.py

[error] invalid-argument-type - :253:30 - Argument to function `bulk_create_users` is incorrect: Expected `set[tuple[str, str, bool]]`, found `set[tuple[str, str, Literal[True]]]`

zerver/lib/import_realm.py

[error] invalid-assignment - :1017:17 - Method `__setitem__` of type `bound method dict[Any, Literal[False]].__setitem__(key: Any, value: Literal[False], /) -> None` cannot be called with a key of type `Any` and a value of type `Literal[True]` on object of type `dict[Any, Literal[False]]`

zerver/lib/message_cache.py

[error] invalid-assignment - :474:9 -
Old: Method `__setitem__` of type `bound method dict[str, int | str].__setitem__(key: str, value: int | str, /) -> None` cannot be called with a key of type `Literal["reactions"]` and a value of type `list[@Todo]` on object of type `dict[str, int | str]`
New: Method `__setitem__` of type `bound method dict[str, int | str].__setitem__(key: str, value: int | str, /) -> None` cannot be called with a key of type `Literal["reactions"]` and a value of type `list[dict[str, Any]]` on object of type `dict[str, int | str]`

zerver/lib/recipient_users.py

[warning] possibly-missing-attribute - :67:16 - Attribute `recipient_id` on type `@Todo | UserProfile` may be missing
[error] unresolved-attribute - :67:16 - Type `UserProfile` has no attribute `recipient_id`

zerver/lib/sessions.py

[error] invalid-return-type - :44:12 - Return type does not match returned value: expected `list[Session]`, found `list[typing.Self]`

zerver/lib/streams.py

[error] unresolved-attribute - :1473:32 - Type `Stream` has no attribute `id`

zerver/lib/subscription_info.py

[error] unresolved-attribute - :721:27 - Type `Stream` has no attribute `id`
[error] unresolved-attribute - :739:55 - Type `Stream` has no attribute `id`
[error] unresolved-attribute - :740:28 - Type `Stream` has no attribute `id`
[error] unresolved-attribute - :741:31 - Type `Stream` has no attribute `id`
[error] unresolved-attribute - :744:68 - Type `Stream` has no attribute `id`

zerver/lib/user_groups.py

[error] unresolved-attribute - :350:28 - Type `NamedUserGroup` has no attribute `id`

zerver/management/commands/export_search.py

[error] unresolved-attribute - :231:40 - Type `Stream` has no attribute `recipient_id`

zerver/tests/test_audit_log.py

[error] unresolved-attribute - :1368:31 - Type `NamedUserGroup` has no attribute `id`
[error] unresolved-attribute - :1394:31 - Type `NamedUserGroup` has no attribute `id`

zerver/tests/test_auth_backends.py

[error] unresolved-attribute - :1677:27 - Type `Stream` has no attribute `id`

zerver/tests/test_invite.py

[error] unresolved-attribute - :3330:23 - Type `Stream` has no attribute `id`
[error] unresolved-attribute - :3467:23 - Type `Stream` has no attribute `id`

zerver/views/alert_words.py

[error] invalid-return-type - :19:12 - Return type does not match returned value: expected `list[str]`, found `list[str & ~Literal[""]]`

zerver/views/streams.py

[error] invalid-assignment - :936:9 -
Old: Method `__setitem__` of type `bound method dict[str, defaultdict[Unknown, Unknown]].__setitem__(key: str, value: defaultdict[Unknown, Unknown], /) -> None` cannot be called with a key of type `Literal["unauthorized"]` and a value of type `list[@Todo]` on object of type `dict[str, defaultdict[Unknown, Unknown]]`
New: Method `__setitem__` of type `bound method dict[str, defaultdict[Unknown, Unknown]].__setitem__(key: str, value: defaultdict[Unknown, Unknown], /) -> None` cannot be called with a key of type `Literal["unauthorized"]` and a value of type `list[Unknown]` on object of type `dict[str, defaultdict[Unknown, Unknown]]`