Use both sides of type context for generic type inference (part 1) by ilevkivskyi · Pull Request #22286 · python/mypy

ilevkivskyi · 2026-10-23T15:27:39Z

Ref #22063

Fixes #4150
Fixes #5311
Fixes #5874
Fixes #5971
Fixes #8861
Fixes #10105
Fixes #12760
Fixes #15087
Fixes #15462
Fixes #15569
Fixes #16310
Fixes #16376
Fixes #16953
Fixes #17025
Fixes #17694
Fixes #18233
Fixes #18236
Fixes #18267
Fixes #18427
Fixes #18689
Fixes #19259
Fixes #19304
Fixes #20219
Fixes #20648
Fixes #21532
Fixes #21796
Fixes #21809

I think this is the right thing to do, even though this unfortunately (but unsurprisingly) causes some visible slow-down (because we infer 2-3x more constraints):

master                    4.013s (0.0%)  | stdev 0.011s 
new-inference             4.081s (+1.7%) | stdev 0.005s

I add couple micro-optimizations in relevant code paths to minimize the impact.

The implementation is generally straightforward: use both sides buy default, and only fall back to outer context if there are problems (to give consistent type errors). My plan is to split the change into few smaller things:

Basic implementation of the idea (this PR).
Targeted improvements of meet/join (as needed).
Targeted improvements to the solver such us meet sorting and/or priming.
Update the second pass of argument inference in the same manner.
Remove (most of) existing special-casing (depends on step 4).
Fix false-negative bug due to Any leaking from partial context. This is present on master and quite benign, but may happen more often with the new logic.
Implement some targeted performance optimizations (like removing pre_validate_solutions hack, and making protocol checks faster).

For now I added just a few test to illustrate the core idea (plus one test case that I find amusing). I will investigate the mypy_primer and mypy-issues, and probably will add some more tests.

cc @JukkaL @hauntsaninja

ilevkivskyi · 2026-10-23T15:40:16Z

I will also run the primer with performance impact reported, I skimmed through logs and found that optuna got ~6x slower. I will investigate that first.

ilevkivskyi · 2026-10-23T15:45:52Z

After quick look at mypy-issues this fixes ~25 bugs. I will take a more detailed look on the weekend. Btw to clarify, this PR should handle ~90% of all potential fixes (as well as ~90% of all performance impact).

ilevkivskyi · 2026-10-23T15:55:41Z

Oh, it looks like I forgot to refresh formal_to_actual somewhere, likely an easy fix. Otherwise the primer looks good, there are a handful of new errors, I will take a look at those as well.

ilevkivskyi · 2026-10-23T16:00:17Z

Btw, it looks like django-stubs is crashing on master.

django-stubs (https://github.com/typeddjango/django-stubs)
  error: INTERNAL ERROR -- Please try using mypy master on GitHub:
- version: 2.5.0+dev.8fdf43736393353c6c7291d1cd33c7d9dc112acc
+ version: 2.5.0+dev.831e3d19a4e84cd8dee8b4456534a995f6ca4227

ilevkivskyi · 2026-10-23T16:03:13Z

The error is ModuleNotFoundError: No module named 'psycopg2' so likely a problem with dependencies config in mypy_primer.

Otherwise mypy plugin crashes, see python/mypy#22286

ilevkivskyi · 2026-10-24T01:24:28Z

OK, some updates:

Performance issue in optuna I mentioned before was caused by a crash, all looks OK now. There are some real regressions, but they are few percent.
Looks like majority of fixes in the primer are from list[OneType] + list[OtherType], which was previously rejected.
Couple new Returning "Any" errors may be caused by items 5a I mentioned in PR description (pre-existing bug exposed by this PR)
There are half a dozen new errors where a join of type objects and/or complex callables is wrong (i.e. not actually a join). They all come from pytest.mark.parametrize(), where type context is Iterable[object] so it used to work before, i.e. this is item 2 from PR description. I will try to fix.
There are half a dozen errors in homeassistant related to recursive types. I think I know what is going on there, likely caused by one of my micro-optimizations.

Otherwise mypy plugin crashes, see python/mypy#22286

ilevkivskyi · 2026-10-24T21:54:55Z

Hm, this issue with join of type objects is actually quite bad. To be clear, it also exists on master, for example this fails with a bizarre error on master:

class B:
    def __init__(self, *, y=None) -> None: ...
class C1(B):
    def __init__(self, *, x) -> None: ...
class C2(B): ...

x = [C1, C2]  # E: List item 0 has incompatible type "type[C1]"; expected "type[B]"

But as I expected, some meet/join bugs become more prominent. I tried a conservative fix, but it only fixes the problem partially. We may need to re-think how we join type objects. I think the only potential option may be to use TypeType (not CallableType as now) as a join of two type objects. This will have an issues if someone will try to call an items of the list (they will get supertype signature), but this is kind of consistent with how join behaves in the classic "join vs union" debate.

I am still not sure whether to put the TypeType thing into a separate PR (it is small, but there may be non-trivial fallout).

Fixes #9756 Fixes #10160 Fixes #13182 Fixes #14443 This is needed to de-risk #22286

github-actions · 2026-10-26T22:39:49Z

Diff from mypy_primer, showing the effect of this PR on open source code:

kornia (https://github.com/kornia/kornia)
- kornia/models/efficient_vit/nn/act.py:36: error: Dict entry 4 has incompatible type "str": "partial[Any]"; expected "str": "type[Any]"  [dict-item]

spark (https://github.com/apache/spark)
- python/pyspark/pandas/groupby.py:3530: error: Argument 2 to "zip" has incompatible type "list[Any | tuple[Any, ...]] | Hashable"; expected "Iterable[Any | tuple[Any, ...]]"  [arg-type]
+ python/pyspark/pandas/groupby.py:3530: error: Argument 2 to "zip" has incompatible type "list[Hashable | Any] | Hashable | list[Any | tuple[Any, ...]]"; expected "Iterable[Hashable | Any]"  [arg-type]
+ python/pyspark/ml/util.py:1169: error: Unused "type: ignore" comment  [unused-ignore]
+ python/pyspark/ml/classification.py:3990: error: Unused "type: ignore" comment  [unused-ignore]

prefect (https://github.com/PrefectHQ/prefect)
- src/prefect/utilities/callables/__init__.py:768: error: Incompatible types in assignment (expression has type "list[None]", variable has type "list[expr | None]")  [assignment]
- src/prefect/utilities/callables/__init__.py:768: note: "list" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance
- src/prefect/utilities/callables/__init__.py:768: note: Consider using "Sequence" instead, which is covariant
- src/prefect/utilities/callables/__init__.py:770: error: Unsupported operand types for + ("list[None]" and "list[expr | None]")  [operator]
+ src/prefect/client/orchestration/__init__.py:1186: error: Function does not return a value (it only ever returns None)  [func-returns-value]
+ src/prefect/server/events/jinja_filters.py:86: error: Unused "type: ignore" comment  [unused-ignore]
- src/prefect/flow_engine.py:2402: error: Unsupported operand types for | ("dict[str, str]" and "dict[str, str | None]")  [operator]
- src/prefect/cli/deploy/_core.py:402: error: Incompatible types in assignment (expression has type "Any | None", variable has type "bool")  [assignment]

operator (https://github.com/canonical/operator)
- ops/model.py:2985: error: Argument 2 to "_list_recursive" of "Container" has incompatible type "str | Path"; expected "Path"  [arg-type]
- ops/model.py:3068: error: Argument 2 to "_list_recursive" of "Container" has incompatible type "str | Path"; expected "Path"  [arg-type]
- ops/_private/harness.py:4051: error: Argument 3 to "_notice_matches" of "_TestingPebbleClient" has incompatible type "set[NoticeType | str] | None"; expected "set[str] | None"  [arg-type]

zulip (https://github.com/zulip/zulip)
- zerver/lib/display_recipient.py:84: error: Argument 1 to "list" has incompatible type "QuerySet[Any, dict[str, Any]]"; expected "Iterable[UserDisplayRecipient]"  [arg-type]
+ zerver/lib/display_recipient.py:84: error: Argument 1 to "list" has incompatible type "QuerySet[Any, dict[str, Any]]"; expected "Iterable[TypedDict({'email': str, 'full_name': str, 'id': int, 'is_mirror_dummy': bool})]"  [arg-type]

scrapy (https://github.com/scrapy/scrapy)
+ tests/test_pipeline_files.py:1058: error: Unused "type: ignore" comment  [unused-ignore]
+ scrapy/commands/parse.py:159: error: Returning Any from function declared to return "Iterable[Any] | Deferred[Any]"  [no-any-return]
+ scrapy/commands/parse.py:160: error: Returning Any from function declared to return "Iterable[Any] | Deferred[Any]"  [no-any-return]

antidote (https://github.com/Finistere/antidote)
+ tests/lib/interface/test_custom.py:434: error: Unused "type: ignore" comment  [unused-ignore]
+ tests/lib/interface/test_custom.py:437: error: Unused "type: ignore" comment  [unused-ignore]
+ tests/lib/interface/test_custom.py:440: error: Unused "type: ignore" comment  [unused-ignore]
+ tests/lib/interface/test_custom.py:443: error: Unused "type: ignore" comment  [unused-ignore]
+ tests/lib/interface/test_custom.py:446: error: Unused "type: ignore" comment  [unused-ignore]
+ tests/lib/interface/test_custom.py:449: error: Unused "type: ignore" comment  [unused-ignore]

core (https://github.com/home-assistant/core)
- homeassistant/components/energieleser/const.py:25: error: Returning Any from function declared to return "str"  [no-any-return]
- homeassistant/components/zonneplan/coordinator.py:179: error: Returning Any from function declared to return "tuple[Any | None, Any | None]"  [no-any-return]
- homeassistant/components/zonneplan/coordinator.py:192: error: Returning Any from function declared to return "tuple[Any | None, Any | None]"  [no-any-return]
+ homeassistant/components/device_automation/__init__.py:245: error: Unused "type: ignore" comment  [unused-ignore]
+ homeassistant/components/device_automation/__init__.py:245: error: Incompatible return value type (got "list[Any | BaseException]", expected "list[list[dict[str, Any]] | Exception]")  [return-value]
+ homeassistant/components/device_automation/__init__.py:245: note: Error code "return-value" not covered by "type: ignore[no-any-return]" comment
+ homeassistant/components/airos/coordinator.py:128: error: Returning Any from function declared to return "dict[str, Any]"  [no-any-return]
+ homeassistant/components/tplink_omada/diagnostics.py:73: error: Returning Any from function declared to return "dict[str, Any]"  [no-any-return]
+ homeassistant/components/amcrest/camera.py:156: error: Returning Any from function declared to return "bytes | None"  [no-any-return]
+ homeassistant/components/knx/storage/entity_store_validation.py:68: error: Returning Any from function declared to return "dict[Any, Any]"  [no-any-return]
+ homeassistant/components/airzone_cloud/diagnostics.py:132: error: Returning Any from function declared to return "dict[str, Any]"  [no-any-return]
+ homeassistant/components/husqvarna_automower/diagnostics.py:48: error: Returning Any from function declared to return "dict[str, Any]"  [no-any-return]
+ homeassistant/components/motioneye/media_source.py:229: error: Unused "type: ignore" comment  [unused-ignore]
- homeassistant/components/esphome/serial_proxy.py:108: error: Item "None" of "Any | None" has no attribute "_loop"  [union-attr]
- homeassistant/components/uptimerobot/sensor.py:73: error: Returning Any from function declared to return "str | None"  [no-any-return]
+ homeassistant/components/lametric/diagnostics.py:26: error: Returning Any from function declared to return "dict[str, Any]"  [no-any-return]
+ homeassistant/components/open_meteo/diagnostics.py:22: error: Returning Any from function declared to return "dict[str, Any]"  [no-any-return]
+ homeassistant/components/velux/cover.py:111: error: Item "None" of "str | None" has no attribute "upper"  [union-attr]

pytest-robotframework (https://github.com/detachhead/pytest-robotframework)
- pytest_robotframework/_internal/robot/utils.py:249: error: Argument 1 to "reduce" has incompatible type "Callable[[Mapping[str, object], Mapping[str, object]], dict[str, object]]"; expected "Callable[[SupportsKeysAndGetItem[str, object], Mapping[str, object]], SupportsKeysAndGetItem[str, object]]"  [arg-type]

pandera (https://github.com/pandera-dev/pandera)
- tests/ibis/test_ibis_dtypes.py:81: error: Unsupported operand types for + ("list[type[String] | type[_PhysicalNumber]]" and "list[type[Map]]")  [operator]
- tests/ibis/test_ibis_dtypes.py:92: error: Unsupported operand types for + ("list[type[String] | type[_PhysicalNumber]]" and "list[type[Map]]")  [operator]

werkzeug (https://github.com/pallets/werkzeug)
+ src/werkzeug/local.py:59: error: Returning Any from function declared to return "Iterator[tuple[str, Any]]"  [no-any-return]
+ tests/test_exceptions.py:123: error: Unused "type: ignore" comment  [unused-ignore]

pydantic (https://github.com/pydantic/pydantic)
- pydantic/fields.py:844: note:     def Field(default, default: EllipsisType, *, alias: str | None = ..., alias_priority: int | None = ..., validation_alias: str | AliasPath | AliasChoices | None = ..., serialization_alias: str | None = ..., title: str | None = ..., field_title_generator: Callable[[str, FieldInfo], str] | None = ..., description: str | None = ..., examples: list[Any] | None = ..., exclude: bool | None = ..., exclude_if: Callable[[Any], bool] | None = ..., discriminator: str | Discriminator | None = ..., deprecated: deprecated | str | bool | None = ..., json_schema_extra: JsonDict | Callable[[JsonDict], None] | None = ..., frozen: bool | None = ..., validate_default: bool | None = ..., repr: bool = ..., init: bool | None = ..., init_var: bool | None = ..., kw_only: bool | None = ..., pattern: str | Pattern[str] | None = ..., strict: bool | None = ..., coerce_numbers_to_str: bool | None = ..., gt: SupportsGt | None = ..., ge: SupportsGe | None = ..., lt: SupportsLt | None = ..., le: SupportsLe | None = ..., multiple_of: float | None = ..., allow_inf_nan: bool | None = ..., max_digits: int | None = ..., decimal_places: int | None = ..., min_length: int | None = ..., max_length: int | None = ..., union_mode: Literal['smart', 'left_to_right'] = ..., fail_fast: bool | None = ...) -> Any
+ pydantic/fields.py:844: note:     def Field(default: EllipsisType, *, alias: str | None = ..., alias_priority: int | None = ..., validation_alias: str | AliasPath | AliasChoices | None = ..., serialization_alias: str | None = ..., title: str | None = ..., field_title_generator: Callable[[str, FieldInfo], str] | None = ..., description: str | None = ..., examples: list[Any] | None = ..., exclude: bool | None = ..., exclude_if: Callable[[Any], bool] | None = ..., discriminator: str | Discriminator | None = ..., deprecated: deprecated | str | bool | None = ..., json_schema_extra: JsonDict | Callable[[JsonDict], None] | None = ..., frozen: bool | None = ..., validate_default: bool | None = ..., repr: bool = ..., init: bool | None = ..., init_var: bool | None = ..., kw_only: bool | None = ..., pattern: str | Pattern[str] | None = ..., strict: bool | None = ..., coerce_numbers_to_str: bool | None = ..., gt: SupportsGt | None = ..., ge: SupportsGe | None = ..., lt: SupportsLt | None = ..., le: SupportsLe | None = ..., multiple_of: float | None = ..., allow_inf_nan: bool | None = ..., max_digits: int | None = ..., decimal_places: int | None = ..., min_length: int | None = ..., max_length: int | None = ..., union_mode: Literal['smart', 'left_to_right'] = ..., fail_fast: bool | None = ...) -> Any
- pydantic/fields.py:844: note:     def Field(default, default: Any, *, alias: str | None = ..., alias_priority: int | None = ..., validation_alias: str | AliasPath | AliasChoices | None = ..., serialization_alias: str | None = ..., title: str | None = ..., field_title_generator: Callable[[str, FieldInfo], str] | None = ..., description: str | None = ..., examples: list[Any] | None = ..., exclude: bool | None = ..., exclude_if: Callable[[Any], bool] | None = ..., discriminator: str | Discriminator | None = ..., deprecated: deprecated | str | bool | None = ..., json_schema_extra: JsonDict | Callable[[JsonDict], None] | None = ..., frozen: bool | None = ..., validate_default: Literal[True], repr: bool = ..., init: bool | None = ..., init_var: bool | None = ..., kw_only: bool | None = ..., pattern: str | Pattern[str] | None = ..., strict: bool | None = ..., coerce_numbers_to_str: bool | None = ..., gt: SupportsGt | None = ..., ge: SupportsGe | None = ..., lt: SupportsLt | None = ..., le: SupportsLe | None = ..., multiple_of: float | None = ..., allow_inf_nan: bool | None = ..., max_digits: int | None = ..., decimal_places: int | None = ..., min_length: int | None = ..., max_length: int | None = ..., union_mode: Literal['smart', 'left_to_right'] = ..., fail_fast: bool | None = ...) -> Any
+ pydantic/fields.py:844: note:     def Field(default: Any, *, alias: str | None = ..., alias_priority: int | None = ..., validation_alias: str | AliasPath | AliasChoices | None = ..., serialization_alias: str | None = ..., title: str | None = ..., field_title_generator: Callable[[str, FieldInfo], str] | None = ..., description: str | None = ..., examples: list[Any] | None = ..., exclude: bool | None = ..., exclude_if: Callable[[Any], bool] | None = ..., discriminator: str | Discriminator | None = ..., deprecated: deprecated | str | bool | None = ..., json_schema_extra: JsonDict | Callable[[JsonDict], None] | None = ..., frozen: bool | None = ..., validate_default: Literal[True], repr: bool = ..., init: bool | None = ..., init_var: bool | None = ..., kw_only: bool | None = ..., pattern: str | Pattern[str] | None = ..., strict: bool | None = ..., coerce_numbers_to_str: bool | None = ..., gt: SupportsGt | None = ..., ge: SupportsGe | None = ..., lt: SupportsLt | None = ..., le: SupportsLe | None = ..., multiple_of: float | None = ..., allow_inf_nan: bool | None = ..., max_digits: int | None = ..., decimal_places: int | None = ..., min_length: int | None = ..., max_length: int | None = ..., union_mode: Literal['smart', 'left_to_right'] = ..., fail_fast: bool | None = ...) -> Any
- pydantic/fields.py:844: note:     def [_T] Field(default, default: _T, *, alias: str | None = ..., alias_priority: int | None = ..., validation_alias: str | AliasPath | AliasChoices | None = ..., serialization_alias: str | None = ..., title: str | None = ..., field_title_generator: Callable[[str, FieldInfo], str] | None = ..., description: str | None = ..., examples: list[Any] | None = ..., exclude: bool | None = ..., exclude_if: Callable[[Any], bool] | None = ..., discriminator: str | Discriminator | None = ..., deprecated: deprecated | str | bool | None = ..., json_schema_extra: JsonDict | Callable[[JsonDict], None] | None = ..., frozen: bool | None = ..., validate_default: Literal[False] = ..., repr: bool = ..., init: bool | None = ..., init_var: bool | None = ..., kw_only: bool | None = ..., pattern: str | Pattern[str] | None = ..., strict: bool | None = ..., coerce_numbers_to_str: bool | None = ..., gt: SupportsGt | None = ..., ge: SupportsGe | None = ..., lt: SupportsLt | None = ..., le: SupportsLe | None = ..., multiple_of: float | None = ..., allow_inf_nan: bool | None = ..., max_digits: int | None = ..., decimal_places: int | None = ..., min_length: int | None = ..., max_length: int | None = ..., union_mode: Literal['smart', 'left_to_right'] = ..., fail_fast: bool | None = ...) -> _T
+ pydantic/fields.py:844: note:     def [_T] Field(default: _T, *, alias: str | None = ..., alias_priority: int | None = ..., validation_alias: str | AliasPath | AliasChoices | None = ..., serialization_alias: str | None = ..., title: str | None = ..., field_title_generator: Callable[[str, FieldInfo], str] | None = ..., description: str | None = ..., examples: list[Any] | None = ..., exclude: bool | None = ..., exclude_if: Callable[[Any], bool] | None = ..., discriminator: str | Discriminator | None = ..., deprecated: deprecated | str | bool | None = ..., json_schema_extra: JsonDict | Callable[[JsonDict], None] | None = ..., frozen: bool | None = ..., validate_default: Literal[False] = ..., repr: bool = ..., init: bool | None = ..., init_var: bool | None = ..., kw_only: bool | None = ..., pattern: str | Pattern[str] | None = ..., strict: bool | None = ..., coerce_numbers_to_str: bool | None = ..., gt: SupportsGt | None = ..., ge: SupportsGe | None = ..., lt: SupportsLt | None = ..., le: SupportsLe | None = ..., multiple_of: float | None = ..., allow_inf_nan: bool | None = ..., max_digits: int | None = ..., decimal_places: int | None = ..., min_length: int | None = ..., max_length: int | None = ..., union_mode: Literal['smart', 'left_to_right'] = ..., fail_fast: bool | None = ...) -> _T
- pydantic/fields.py:844: note:     def Field(default_factory, *, default_factory: Callable[[], Any] | Callable[[dict[str, Any]], Any], alias: str | None = ..., alias_priority: int | None = ..., validation_alias: str | AliasPath | AliasChoices | None = ..., serialization_alias: str | None = ..., title: str | None = ..., field_title_generator: Callable[[str, FieldInfo], str] | None = ..., description: str | None = ..., examples: list[Any] | None = ..., exclude: bool | None = ..., exclude_if: Callable[[Any], bool] | None = ..., discriminator: str | Discriminator | None = ..., deprecated: deprecated | str | bool | None = ..., json_schema_extra: JsonDict | Callable[[JsonDict], None] | None = ..., frozen: bool | None = ..., validate_default: Literal[True], repr: bool = ..., init: bool | None = ..., init_var: bool | None = ..., kw_only: bool | None = ..., pattern: str | Pattern[str] | None = ..., strict: bool | None = ..., coerce_numbers_to_str: bool | None = ..., gt: SupportsGt | None = ..., ge: SupportsGe | None = ..., lt: SupportsLt | None = ..., le: SupportsLe | None = ..., multiple_of: float | None = ..., allow_inf_nan: bool | None = ..., max_digits: int | None = ..., decimal_places: int | None = ..., min_length: int | None = ..., max_length: int | None = ..., union_mode: Literal['smart', 'left_to_right'] = ..., fail_fast: bool | None = ...) -> Any
+ pydantic/fields.py:844: note:     def Field(*, default_factory: Callable[[], Any] | Callable[[dict[str, Any]], Any], alias: str | None = ..., alias_priority: int | None = ..., validation_alias: str | AliasPath | AliasChoices | None = ..., serialization_alias: str | None = ..., title: str | None = ..., field_title_generator: Callable[[str, FieldInfo], str] | None = ..., description: str | None = ..., examples: list[Any] | None = ..., exclude: bool | None = ..., exclude_if: Callable[[Any], bool] | None = ..., discriminator: str | Discriminator | None = ..., deprecated: deprecated | str | bool | None = ..., json_schema_extra: JsonDict | Callable[[JsonDict], None] | None = ..., frozen: bool | None = ..., validate_default: Literal[True], repr: bool = ..., init: bool | None = ..., init_var: bool | None = ..., kw_only: bool | None = ..., pattern: str | Pattern[str] | None = ..., strict: bool | None = ..., coerce_numbers_to_str: bool | None = ..., gt: SupportsGt | None = ..., ge: SupportsGe | None = ..., lt: SupportsLt | None = ..., le: SupportsLe | None = ..., multiple_of: float | None = ..., allow_inf_nan: bool | None = ..., max_digits: int | None = ..., decimal_places: int | None = ..., min_length: int | None = ..., max_length: int | None = ..., union_mode: Literal['smart', 'left_to_right'] = ..., fail_fast: bool | None = ...) -> Any
- pydantic/fields.py:844: note:     def [_T] Field(default_factory, *, default_factory: Callable[[], _T] | Callable[[dict[str, Any]], _T], alias: str | None = ..., alias_priority: int | None = ..., validation_alias: str | AliasPath | AliasChoices | None = ..., serialization_alias: str | None = ..., title: str | None = ..., field_title_generator: Callable[[str, FieldInfo], str] | None = ..., description: str | None = ..., examples: list[Any] | None = ..., exclude: bool | None = ..., exclude_if: Callable[[Any], bool] | None = ..., discriminator: str | Discriminator | None = ..., deprecated: deprecated | str | bool | None = ..., json_schema_extra: JsonDict | Callable[[JsonDict], None] | None = ..., frozen: bool | None = ..., validate_default: Literal[False] | None = ..., repr: bool = ..., init: bool | None = ..., init_var: bool | None = ..., kw_only: bool | None = ..., pattern: str | Pattern[str] | None = ..., strict: bool | None = ..., coerce_numbers_to_str: bool | None = ..., gt: SupportsGt | None = ..., ge: SupportsGe | None = ..., lt: SupportsLt | None = ..., le: SupportsLe | None = ..., multiple_of: float | None = ..., allow_inf_nan: bool | None = ..., max_digits: int | None = ..., decimal_places: int | None = ..., min_length: int | None = ..., max_length: int | None = ..., union_mode: Literal['smart', 'left_to_right'] = ..., fail_fast: bool | None = ...) -> _T
+ pydantic/fields.py:844: note:     def [_T] Field(*, default_factory: Callable[[], _T] | Callable[[dict[str, Any]], _T], alias: str | None = ..., alias_priority: int | None = ..., validation_alias: str | AliasPath | AliasChoices | None = ..., serialization_alias: str | None = ..., title: str | None = ..., field_title_generator: Callable[[str, FieldInfo], str] | None = ..., description: str | None = ..., examples: list[Any] | None = ..., exclude: bool | None = ..., exclude_if: Callable[[Any], bool] | None = ..., discriminator: str | Discriminator | None = ..., deprecated: deprecated | str | bool | None = ..., json_schema_extra: JsonDict | Callable[[JsonDict], None] | None = ..., frozen: bool | None = ..., validate_default: Literal[False] | None = ..., repr: bool = ..., init: bool | None = ..., init_var: bool | None = ..., kw_only: bool | None = ..., pattern: str | Pattern[str] | None = ..., strict: bool | None = ..., coerce_numbers_to_str: bool | None = ..., gt: SupportsGt | None = ..., ge: SupportsGe | None = ..., lt: SupportsLt | None = ..., le: SupportsLe | None = ..., multiple_of: float | None = ..., allow_inf_nan: bool | None = ..., max_digits: int | None = ..., decimal_places: int | None = ..., min_length: int | None = ..., max_length: int | None = ..., union_mode: Literal['smart', 'left_to_right'] = ..., fail_fast: bool | None = ...) -> _T
- pydantic/fields.py:844: note:     def Field(alias, *, alias: str | None = ..., alias_priority: int | None = ..., validation_alias: str | AliasPath | AliasChoices | None = ..., serialization_alias: str | None = ..., title: str | None = ..., field_title_generator: Callable[[str, FieldInfo], str] | None = ..., description: str | None = ..., examples: list[Any] | None = ..., exclude: bool | None = ..., exclude_if: Callable[[Any], bool] | None = ..., discriminator: str | Discriminator | None = ..., deprecated: deprecated | str | bool | None = ..., json_schema_extra: JsonDict | Callable[[JsonDict], None] | None = ..., frozen: bool | None = ..., validate_default: bool | None = ..., repr: bool = ..., init: bool | None = ..., init_var: bool | None = ..., kw_only: bool | None = ..., pattern: str | Pattern[str] | None = ..., strict: bool | None = ..., coerce_numbers_to_str: bool | None = ..., gt: SupportsGt | None = ..., ge: SupportsGe | None = ..., lt: SupportsLt | None = ..., le: SupportsLe | None = ..., multiple_of: float | None = ..., allow_inf_nan: bool | None = ..., max_digits: int | None = ..., decimal_places: int | None = ..., min_length: int | None = ..., max_length: int | None = ..., union_mode: Literal['smart', 'left_to_right'] = ..., fail_fast: bool | None = ...) -> Any
+ pydantic/fields.py:844: note:     def Field(*, alias: str | None = ..., alias_priority: int | None = ..., validation_alias: str | AliasPath | AliasChoices | None = ..., serialization_alias: str | None = ..., title: str | None = ..., field_title_generator: Callable[[str, FieldInfo], str] | None = ..., description: str | None = ..., examples: list[Any] | None = ..., exclude: bool | None = ..., exclude_if: Callable[[Any], bool] | None = ..., discriminator: str | Discriminator | None = ..., deprecated: deprecated | str | bool | None = ..., json_schema_extra: JsonDict | Callable[[JsonDict], None] | None = ..., frozen: bool | None = ..., validate_default: bool | None = ..., repr: bool = ..., init: bool | None = ..., init_var: bool | None = ..., kw_only: bool | None = ..., pattern: str | Pattern[str] | None = ..., strict: bool | None = ..., coerce_numbers_to_str: bool | None = ..., gt: SupportsGt | None = ..., ge: SupportsGe | None = ..., lt: SupportsLt | None = ..., le: SupportsLe | None = ..., multiple_of: float | None = ..., allow_inf_nan: bool | None = ..., max_digits: int | None = ..., decimal_places: int | None = ..., min_length: int | None = ..., max_length: int | None = ..., union_mode: Literal['smart', 'left_to_right'] = ..., fail_fast: bool | None = ...) -> Any

scipy (https://github.com/scipy/scipy)
- scipy/stats/tests/test_sampling.py:155: error: Unsupported operand types for + ("list[tuple[tuple[int, ...], type[ValueError], str] | tuple[tuple[int, int], type[UNURANError], str]]" and "list[tuple[tuple[float, float], type[ValueError], str]]")  [operator]

pandas-stubs (https://github.com/pandas-dev/pandas-stubs)
+ tests/indexes/test_indexes.py:181: error: Unused "type: ignore" comment  [unused-ignore]

rotki (https://github.com/rotki/rotki)
+ rotkehlchen/chain/evm/decoding/stakedao/decoder.py:316: error: Unused "type: ignore" comment  [unused-ignore]

scikit-learn (https://github.com/scikit-learn/scikit-learn)
- sklearn/externals/array_api_compat/numpy/linalg.py:185: error: Incompatible types in assignment (expression has type "Callable[..., float64]", variable has type overloaded function)  [assignment]
- sklearn/preprocessing/tests/test_polynomial.py:663: error: Unsupported operand types for + ("list[ABCMeta | None]" and "list[ABCMeta]")  [operator]
- sklearn/preprocessing/tests/test_polynomial.py:734: error: Unsupported operand types for + ("list[ABCMeta | None]" and "list[ABCMeta]")  [operator]
- sklearn/preprocessing/tests/test_function_transformer.py:124: error: Unsupported operand types for + ("list[ABCMeta | None]" and "list[ABCMeta]")  [operator]
- sklearn/metrics/tests/test_pairwise.py:946: error: Unsupported operand types for + ("list[overloaded function]" and "list[ABCMeta]")  [operator]
- sklearn/metrics/tests/test_pairwise.py:951: error: Unsupported operand types for + ("list[overloaded function]" and "list[ABCMeta]")  [operator]
- sklearn/metrics/tests/test_pairwise.py:964: error: Unsupported operand types for + ("list[overloaded function]" and "list[ABCMeta]")  [operator]
- sklearn/metrics/tests/test_pairwise.py:1052: error: Unsupported operand types for + ("list[overloaded function]" and "list[ABCMeta]")  [operator]
- sklearn/metrics/tests/test_pairwise.py:1057: error: Unsupported operand types for + ("list[overloaded function]" and "list[ABCMeta]")  [operator]
- sklearn/metrics/tests/test_pairwise.py:1083: error: Unsupported operand types for + ("list[overloaded function]" and "list[ABCMeta]")  [operator]
- sklearn/metrics/tests/test_pairwise.py:1107: error: Unsupported operand types for + ("list[overloaded function]" and "list[ABCMeta]")  [operator]
- sklearn/metrics/tests/test_pairwise.py:1112: error: Unsupported operand types for + ("list[overloaded function]" and "list[ABCMeta]")  [operator]
- sklearn/metrics/tests/test_pairwise.py:1138: error: Unsupported operand types for + ("list[overloaded function]" and "list[ABCMeta]")  [operator]
- sklearn/_loss/tests/test_loss.py:224: error: Unsupported operand types for + ("list[tuple[BaseLoss, list[float], list[float]]]" and "list[tuple[BaseLoss, object, list[Any]]]")  [operator]
- sklearn/_loss/tests/test_loss.py:236: error: Unsupported operand types for + ("list[tuple[BaseLoss, list[float], list[float]]]" and "list[tuple[BaseLoss, list[float], object]]")  [operator]
- sklearn/feature_selection/tests/test_variance_threshold.py:14: error: Unsupported operand types for + ("list[ABCMeta | None]" and "list[ABCMeta]")  [operator]
- sklearn/feature_selection/tests/test_variance_threshold.py:31: error: Unsupported operand types for + ("list[None]" and "list[ABCMeta]")  [operator]
- sklearn/feature_selection/tests/test_variance_threshold.py:47: error: Unsupported operand types for + ("list[ABCMeta | None]" and "list[ABCMeta]")  [operator]
- sklearn/feature_selection/tests/test_variance_threshold.py:61: error: Unsupported operand types for + ("list[ABCMeta | None]" and "list[ABCMeta]")  [operator]
- sklearn/utils/tests/test_sparsefuncs.py:451: error: No overload variant of "hstack" matches argument types "list[Any]", "str"  [call-overload]
- sklearn/utils/tests/test_sparsefuncs.py:451: note: Possible overload variants:
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def [T] hstack(blocks: Sequence[_CanStack[T]], format: None = ..., dtype: None = ...) -> T
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def [ScalarT: number[Any, Any] | numpy.bool[builtins.bool]] hstack(blocks: Sequence[sparray[ScalarT, tuple[int, int]]], format: Literal['bsr'], dtype: None = ...) -> bsr_array[ScalarT]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def [ScalarT: number[Any, Any] | numpy.bool[builtins.bool]] hstack(blocks: Sequence[sparray[ScalarT, tuple[int, int]]], format: Literal['coo'], dtype: None = ...) -> coo_array[ScalarT, tuple[int, int]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def [ScalarT: number[Any, Any] | numpy.bool[builtins.bool]] hstack(blocks: Sequence[sparray[ScalarT, tuple[int, int]]], format: Literal['csc'], dtype: None = ...) -> csc_array[ScalarT]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def [ScalarT: number[Any, Any] | numpy.bool[builtins.bool]] hstack(blocks: Sequence[sparray[ScalarT, tuple[int, int]]], format: Literal['csr'], dtype: None = ...) -> csr_array[ScalarT, tuple[int, int]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def [ScalarT: number[Any, Any] | numpy.bool[builtins.bool]] hstack(blocks: Sequence[sparray[ScalarT, tuple[int, int]]], format: Literal['dia'], dtype: None = ...) -> dia_array[ScalarT]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def [ScalarT: number[Any, Any] | numpy.bool[builtins.bool]] hstack(blocks: Sequence[sparray[ScalarT, tuple[int, int]]], format: Literal['dok'], dtype: None = ...) -> dok_array[ScalarT, tuple[int, int]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def [ScalarT: number[Any, Any] | numpy.bool[builtins.bool]] hstack(blocks: Sequence[sparray[ScalarT, tuple[int, int]]], format: Literal['lil'], dtype: None = ...) -> lil_array[ScalarT]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def [T] hstack(blocks: Sequence[_CanStackAs[numpy.bool[builtins.bool], T]], format: None = ..., *, dtype: type[builtins.bool] | type[numpy.bool[builtins.bool]] | dtype[numpy.bool[builtins.bool]] | HasDType[dtype[numpy.bool[builtins.bool]]] | Literal['bool', 'bool_', 'b1', '|b1', '?']) -> T
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['bsr'], dtype: type[builtins.bool] | type[numpy.bool[builtins.bool]] | dtype[numpy.bool[builtins.bool]] | HasDType[dtype[numpy.bool[builtins.bool]]] | Literal['bool', 'bool_', 'b1', '|b1', '?']) -> bsr_array[numpy.bool[builtins.bool]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['coo'], dtype: type[builtins.bool] | type[numpy.bool[builtins.bool]] | dtype[numpy.bool[builtins.bool]] | HasDType[dtype[numpy.bool[builtins.bool]]] | Literal['bool', 'bool_', 'b1', '|b1', '?']) -> coo_array[numpy.bool[builtins.bool], tuple[int, int]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['csc'], dtype: type[builtins.bool] | type[numpy.bool[builtins.bool]] | dtype[numpy.bool[builtins.bool]] | HasDType[dtype[numpy.bool[builtins.bool]]] | Literal['bool', 'bool_', 'b1', '|b1', '?']) -> csc_array[numpy.bool[builtins.bool]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['csr'], dtype: type[builtins.bool] | type[numpy.bool[builtins.bool]] | dtype[numpy.bool[builtins.bool]] | HasDType[dtype[numpy.bool[builtins.bool]]] | Literal['bool', 'bool_', 'b1', '|b1', '?']) -> csr_array[numpy.bool[builtins.bool], tuple[int, int]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['dia'], dtype: type[builtins.bool] | type[numpy.bool[builtins.bool]] | dtype[numpy.bool[builtins.bool]] | HasDType[dtype[numpy.bool[builtins.bool]]] | Literal['bool', 'bool_', 'b1', '|b1', '?']) -> dia_array[numpy.bool[builtins.bool]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['dok'], dtype: type[builtins.bool] | type[numpy.bool[builtins.bool]] | dtype[numpy.bool[builtins.bool]] | HasDType[dtype[numpy.bool[builtins.bool]]] | Literal['bool', 'bool_', 'b1', '|b1', '?']) -> dok_array[numpy.bool[builtins.bool], tuple[int, int]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['lil'], dtype: type[builtins.bool] | type[numpy.bool[builtins.bool]] | dtype[numpy.bool[builtins.bool]] | HasDType[dtype[numpy.bool[builtins.bool]]] | Literal['bool', 'bool_', 'b1', '|b1', '?']) -> lil_array[numpy.bool[builtins.bool]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def [T] hstack(blocks: Sequence[_CanStackAs[signedinteger[_32Bit | _64Bit], T]], format: None = ..., *, dtype: type[JustInt] | type[signedinteger[_64Bit]] | dtype[signedinteger[_64Bit]] | HasDType[dtype[signedinteger[_64Bit]]] | Literal['int_', 'int', 'intp', 'n', '<n', '>n']) -> T
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['bsr'], dtype: type[JustInt] | type[signedinteger[_64Bit]] | dtype[signedinteger[_64Bit]] | HasDType[dtype[signedinteger[_64Bit]]] | Literal['int_', 'int', 'intp', 'n', '<n', '>n']) -> bsr_array[signedinteger[_32Bit | _64Bit]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['coo'], dtype: type[JustInt] | type[signedinteger[_64Bit]] | dtype[signedinteger[_64Bit]] | HasDType[dtype[signedinteger[_64Bit]]] | Literal['int_', 'int', 'intp', 'n', '<n', '>n']) -> coo_array[signedinteger[_32Bit | _64Bit], tuple[int, int]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['csc'], dtype: type[JustInt] | type[signedinteger[_64Bit]] | dtype[signedinteger[_64Bit]] | HasDType[dtype[signedinteger[_64Bit]]] | Literal['int_', 'int', 'intp', 'n', '<n', '>n']) -> csc_array[signedinteger[_32Bit | _64Bit]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['csr'], dtype: type[JustInt] | type[signedinteger[_64Bit]] | dtype[signedinteger[_64Bit]] | HasDType[dtype[signedinteger[_64Bit]]] | Literal['int_', 'int', 'intp', 'n', '<n', '>n']) -> csr_array[signedinteger[_32Bit | _64Bit], tuple[int, int]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['dia'], dtype: type[JustInt] | type[signedinteger[_64Bit]] | dtype[signedinteger[_64Bit]] | HasDType[dtype[signedinteger[_64Bit]]] | Literal['int_', 'int', 'intp', 'n', '<n', '>n']) -> dia_array[signedinteger[_32Bit | _64Bit]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['dok'], dtype: type[JustInt] | type[signedinteger[_64Bit]] | dtype[signedinteger[_64Bit]] | HasDType[dtype[signedinteger[_64Bit]]] | Literal['int_', 'int', 'intp', 'n', '<n', '>n']) -> dok_array[signedinteger[_32Bit | _64Bit], tuple[int, int]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['lil'], dtype: type[JustInt] | type[signedinteger[_64Bit]] | dtype[signedinteger[_64Bit]] | HasDType[dtype[signedinteger[_64Bit]]] | Literal['int_', 'int', 'intp', 'n', '<n', '>n']) -> lil_array[signedinteger[_32Bit | _64Bit]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def [T] hstack(blocks: Sequence[_CanStackAs[float64, T]], format: None = ..., *, dtype: type[JustFloat] | type[floating[_64Bit]] | dtype[floating[_64Bit]] | HasDType[dtype[floating[_64Bit]]] | Literal['float64', 'double', 'float', 'f8', '<f8', '>f8', 'd']) -> T
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['bsr'], dtype: type[JustFloat] | type[floating[_64Bit]] | dtype[floating[_64Bit]] | HasDType[dtype[floating[_64Bit]]] | Literal['float64', 'double', 'float', 'f8', '<f8', '>f8', 'd']) -> bsr_array[float64]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['coo'], dtype: type[JustFloat] | type[floating[_64Bit]] | dtype[floating[_64Bit]] | HasDType[dtype[floating[_64Bit]]] | Literal['float64', 'double', 'float', 'f8', '<f8', '>f8', 'd']) -> coo_array[float64, tuple[int, int]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['csc'], dtype: type[JustFloat] | type[floating[_64Bit]] | dtype[floating[_64Bit]] | HasDType[dtype[floating[_64Bit]]] | Literal['float64', 'double', 'float', 'f8', '<f8', '>f8', 'd']) -> csc_array[float64]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['csr'], dtype: type[JustFloat] | type[floating[_64Bit]] | dtype[floating[_64Bit]] | HasDType[dtype[floating[_64Bit]]] | Literal['float64', 'double', 'float', 'f8', '<f8', '>f8', 'd']) -> csr_array[float64, tuple[int, int]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['dia'], dtype: type[JustFloat] | type[floating[_64Bit]] | dtype[floating[_64Bit]] | HasDType[dtype[floating[_64Bit]]] | Literal['float64', 'double', 'float', 'f8', '<f8', '>f8', 'd']) -> dia_array[float64]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['dok'], dtype: type[JustFloat] | type[floating[_64Bit]] | dtype[floating[_64Bit]] | HasDType[dtype[floating[_64Bit]]] | Literal['float64', 'double', 'float', 'f8', '<f8', '>f8', 'd']) -> dok_array[float64, tuple[int, int]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['lil'], dtype: type[JustFloat] | type[floating[_64Bit]] | dtype[floating[_64Bit]] | HasDType[dtype[floating[_64Bit]]] | Literal['float64', 'double', 'float', 'f8', '<f8', '>f8', 'd']) -> lil_array[float64]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def [T] hstack(blocks: Sequence[_CanStackAs[complex128, T]], format: None = ..., *, dtype: type[JustComplex] | type[complexfloating[_64Bit, _64Bit]] | dtype[complexfloating[_64Bit, _64Bit]] | HasDType[dtype[complexfloating[_64Bit, _64Bit]]] | Literal['complex', 'complex128', 'cdouble', 'c16', '<c16', '>c16', 'D']) -> T
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['bsr'], dtype: type[JustComplex] | type[complexfloating[_64Bit, _64Bit]] | dtype[complexfloating[_64Bit, _64Bit]] | HasDType[dtype[complexfloating[_64Bit, _64Bit]]] | Literal['complex', 'complex128', 'cdouble', 'c16', '<c16', '>c16', 'D']) -> bsr_array[complex128]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['coo'], dtype: type[JustComplex] | type[complexfloating[_64Bit, _64Bit]] | dtype[complexfloating[_64Bit, _64Bit]] | HasDType[dtype[complexfloating[_64Bit, _64Bit]]] | Literal['complex', 'complex128', 'cdouble', 'c16', '<c16', '>c16', 'D']) -> coo_array[complex128, tuple[int, int]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['csc'], dtype: type[JustComplex] | type[complexfloating[_64Bit, _64Bit]] | dtype[complexfloating[_64Bit, _64Bit]] | HasDType[dtype[complexfloating[_64Bit, _64Bit]]] | Literal['complex', 'complex128', 'cdouble', 'c16', '<c16', '>c16', 'D']) -> csc_array[complex128]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['csr'], dtype: type[JustComplex] | type[complexfloating[_64Bit, _64Bit]] | dtype[complexfloating[_64Bit, _64Bit]] | HasDType[dtype[complexfloating[_64Bit, _64Bit]]] | Literal['complex', 'complex128', 'cdouble', 'c16', '<c16', '>c16', 'D']) -> csr_array[complex128, tuple[int, int]]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['dia'], dtype: type[JustComplex] | type[complexfloating[_64Bit, _64Bit]] | dtype[complexfloating[_64Bit, _64Bit]] | HasDType[dtype[complexfloating[_64Bit, _64Bit]]] | Literal['complex', 'complex128', 'cdouble', 'c16', '<c16', '>c16', 'D']) -> dia_array[complex128]
- sklearn/utils/tests/test_sparsefuncs.py:451: note:     def hstack(blocks: Sequence[sparray[Any, tuple[Any, ...]]], format: Literal['dok'], dtype: type[JustComplex] | type[complexfloating[_64Bit, _64Bit]] | dtype[complexfloating[_64Bit, _64Bit]] | HasDType[dtype[complexfloating[_64Bit, _64Bit]]] | Literal['complex', 'complex128', 'cdouble', 'c16', '<c16', '>c16', 'D']) -> dok_array[complex128, tuple[int, int]]

... (truncated 55 lines) ...

sympy (https://github.com/sympy/sympy)
+ sympy/core/add.py:396: error: Unused "type: ignore" comment  [unused-ignore]
+ sympy/polys/compatibility.py:402: error: Unused "type: ignore" comment  [unused-ignore]

pandas (https://github.com/pandas-dev/pandas)
+ pandas/tests/dtypes/test_missing.py:858: error: Unused "type: ignore" comment  [unused-ignore]
+ pandas/tests/dtypes/test_missing.py:880: error: Unused "type: ignore" comment  [unused-ignore]
+ pandas/conftest.py:1658: error: Unused "type: ignore" comment  [unused-ignore]

cvxpy (https://github.com/cvxpy/cvxpy)
+ cvxpy/transforms/scalarize.py:33: error: Incompatible return value type (got "Any | Literal[0]", expected "Minimize | Maximize")  [return-value]

pytensor (https://github.com/pymc-devs/pytensor)
+ pytensor/tensor/einsum.py:297: error: No overload variant of "__setitem__" of "list" matches argument types "int", "list[int]"  [call-overload]
+ pytensor/tensor/einsum.py:297: note: Possible overload variants:
+ pytensor/tensor/einsum.py:297: note:     def __setitem__(self, SupportsIndex, tuple[int, ...], /) -> None
+ pytensor/tensor/einsum.py:297: note:     def __setitem__(self, slice[SupportsIndex | None, SupportsIndex | None, SupportsIndex | None], Iterable[tuple[int, ...]], /) -> None
+ pytensor/tensor/linalg/dtype_utils.py:42: error: Returning Any from function declared to return "dtype[Any]"  [no-any-return]

xarray (https://github.com/pydata/xarray)
+ xarray/core/dataarray.py: note: In function "_infer_coords_and_dims":
+ xarray/core/dataarray.py:196: error: Incompatible types in assignment (expression has type "Hashable", variable has type "str")  [assignment]
+ xarray/core/dataarray.py: note: At top level:
+ xarray/tests/test_dataarray.py:442: error: Unused "type: ignore" comment  [unused-ignore]

jax (https://github.com/google/jax)
- jax/_src/lax/control_flow/conditionals.py:181: error: Incompatible types in assignment (expression has type "tuple[tuple[str, ...] | None, ...]", target has type "tuple[Jaxpr, ...]")  [assignment]
+ jax/_src/numpy/lax_numpy.py:2230: error: Unsupported operand types for - ("Sequence[int | Any]" and "int")  [operator]
+ jax/_src/numpy/lax_numpy.py:2230: note: Left operand is of type "Sequence[int | Any] | int | Any"

ibis (https://github.com/ibis-project/ibis)
- ibis/expr/operations/udf.py:144: error: Dict entry 1 has incompatible type "str": "InputType"; expected "str": "Argument"  [dict-item]
- ibis/expr/operations/udf.py:147: error: Dict entry 2 has incompatible type "str": "property"; expected "str": "Argument"  [dict-item]
- ibis/expr/operations/udf.py:148: error: Dict entry 3 has incompatible type "str": "FrozenDict[Never, Never]"; expected "str": "Argument"  [dict-item]
- ibis/expr/operations/udf.py:149: error: Dict entry 4 has incompatible type "str": "Namespace"; expected "str": "Argument"  [dict-item]
- ibis/expr/operations/udf.py:150: error: Dict entry 5 has incompatible type "str": "str"; expected "str": "Argument"  [dict-item]
- ibis/expr/operations/udf.py:151: error: Dict entry 6 has incompatible type "str": "str"; expected "str": "Argument"  [dict-item]

dd-trace-py (https://github.com/DataDog/dd-trace-py)
+ ddtrace/internal/assembly.py:280: error: Returning Any from function declared to return "Iterator[Any]"  [no-any-return]
- ddtrace/llmobs/_integrations/pydantic_ai.py:132: error: Incompatible return value type (got "tuple[Any | str, Any | None]", expected "tuple[str, str]")  [return-value]
+ ddtrace/llmobs/_integrations/pydantic_ai.py:132: error: Incompatible return value type (got "tuple[Any | str, str | Any | None]", expected "tuple[str, str]")  [return-value]
- ddtrace/testing/internal/pytest/plugin.py:1544: error: Unsupported operand types for + ("list[tuple[str, object]]" and "list[tuple[str, bool]]")  [operator]

meson (https://github.com/mesonbuild/meson)
- mesonbuild/backend/ninjabackend.py:2364:40: error: Incompatible types in assignment (expression has type "list[str]", variable has type "list[Program | BuildTarget | CustomTarget | CustomTargetIndex | File | str]")  [assignment]
- mesonbuild/backend/ninjabackend.py:2364:40: note: "list" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance
- mesonbuild/backend/ninjabackend.py:2364:40: note: Consider using "Sequence" instead, which is covariant
- mesonbuild/backend/ninjabackend.py:2364:78: error: Unsupported operand types for + ("list[str]" and "list[Program | BuildTarget | CustomTarget | CustomTargetIndex | File | str]")  [operator]

static-frame (https://github.com/static-frame/static-frame)
+ static_frame/core/util.py:2514: error: Returning Any from function declared to return "timedelta64[Any]"  [no-any-return]
+ static_frame/core/store.py:202: error: Argument 1 to "extend" of "list" has incompatible type "Sequence[TLabel]"; expected "Iterable[tuple[str, ...]]"  [arg-type]
+ static_frame/core/store.py:204: error: Argument 1 to "extend" of "list" has incompatible type "range"; expected "Iterable[tuple[str, ...]]"  [arg-type]
+ static_frame/core/store.py:204: note: Following member(s) of "range" have conflicts:
+ static_frame/core/store.py:204: note:     Expected:
+ static_frame/core/store.py:204: note:         def __iter__(self) -> Iterator[tuple[str, ...]]
+ static_frame/core/store.py:204: note:     Got:
+ static_frame/core/store.py:204: note:         def __iter__(self) -> Iterator[int]

mongo-python-driver (https://github.com/mongodb/mongo-python-driver)
+ pymongo/synchronous/encryption.py:133: error: Redundant cast to "Collection[RawBSONDocument]"  [redundant-cast]
+ pymongo/asynchronous/encryption.py:134: error: Redundant cast to "AsyncCollection[RawBSONDocument]"  [redundant-cast]

alectryon (https://github.com/cpitclaudel/alectryon)
- alectryon/core.py:251: error: Argument 3 to "ungroup_by" has incompatible type "Callable[[T], K | None]"; expected "Callable[[T | U], K | None]"  [arg-type]

ilevkivskyi · 2026-10-26T22:47:25Z

OK, I think this is ready for review:

I updated the PR description with the precise list of fixed issues.
I checked ~all new errors, they all look reasonable (mostly from scenario in testReturnAnyGeneric)
I have couple more ideas on how to reduce performance impact to ~0. But I want to try them in separate PRs, since some of them may be not no-ops semantically.

@hauntsaninja Since Jukka is on vacation now, can you take a look? (Note I didn't add regression tests for all issues fixes, and I don't think we need them all, but if you think I missed something important, please let me know.)

hauntsaninja

This is awesome! Thank you for working on it.

I went through the mypy_primer and agree with your take

I wasn't able to spot issues in the PR, but I think I need to spend a little more time with it

I asked AI to investigate it, and it found two issues I thought were concerning

False negative on:

def foo(a: Any):
    xs: list[int] = [a, "oops"]

Is this item 6 in your PR description?

Crash on:

def pack[*Ts](*args: *Ts) -> tuple[*Ts]: ...
x: tuple[int, str] = pack(1, "a")

I think this one is formal_to_actual being wrong

It also found a few more issues that I thought were minor:

one new case where you get exponential blow up when you didn't previously (there are pre-existing cases like this with lambda, so I thought this was fine)
one bad but niche false negative with a walrus assignment to a different type for an arg used twice
one false positive in complicated generic solving

ilevkivskyi · 2026-10-28T11:44:14Z

@hauntsaninja Thanks! The formal_to_actual crash is an obvious blunder (and trivial to fix), I am surprised it wasn't caught by existing tests. But the problem with Any is not item 6, it is kind of intentional(?) The point is, on current master we allow both of these:

from typing import Any

def foo(a: Any) -> list[int]:
    tmp = [a, "oops"]
    xs: list[int] = tmp  # Used to be allowed since ~forever
    return [a, "oops"]  # Allowed since ~year ago, see #19767

So this PR simply makes the existing false negative to fail more consistently. The root cause is that currently we use join(Any, X) = Any. Possible solutions here are:

Just live with this until people will actually complain (FWIW I am not aware of anyone complaining about the above two cases)
Use join(Any, X) = Any | X (which is the most technically correct join). Possible downsides of this are a bit of performance impact, and more non-deterministic join (can be partially mitigated by improving _join_sorted_key). If we prefer this way, I would make it a separate PR (since this will fix the existing false negatives as well).
Add some special-casing, e.g. do not use inner/argument context if any of arguments is a plain Any. Not a huge fan of this approach TBH, since this simply cements the current (inconsistent) behavior. But also can accept this if others feel strongly.

Btw, could you please share more details on the minor issues? There is a chance there may be a simple fix for some of them.

ilevkivskyi added 11 commits October 23, 2026 14:04

Some experiments

7879d75

Some more experiments

672cc5a

Re-shuffle

c8b6c75

One more guard

e710f71

Perf + random

1c02b02

Postpone solver change; fix tests

3d1ccdf

Cleanup

3c52b8e

Tune expression cache

b71998f

Postpone low-pri optimization

0204991

Cosmetics

e3879a7

Add some tests

1cacab7

github-actions Bot mentioned this pull request Oct 23, 2026

Check #22286 sterliakov/mypy-issues#315

Open