WIP: try to exclude outer context from overload selection process entirely? - #20047

hydpy (https://github.com/hydpy-dev/hydpy)
+ hydpy/core/devicetools.py:2626: error: No overload variant of "__add__" of "Index" matches argument type "timedelta"  [operator]
+ hydpy/core/devicetools.py:2626: note: Possible overload variants:
+ hydpy/core/devicetools.py:2626: note:     def __add__(self, str, /) -> Never
+ hydpy/core/devicetools.py:2626: note:     def __add__(self, complex | ExtensionArray | ndarray[tuple[Any, ...], dtype[Any]] | dict[str, ndarray[tuple[Any, ...], dtype[Any]]] | SequenceNotStr[Any] | Index[Any], /) -> Index[Any]
+ hydpy/core/devicetools.py:2626: note:     def __add__(self, Index[Never], /) -> Index[Any]
+ hydpy/core/devicetools.py:2626: note:     def [T_COMPLEX: complex] __add__(self, T_COMPLEX | Sequence[T_COMPLEX] | Index[T_COMPLEX], /) -> Index[T_COMPLEX]
+ hydpy/core/devicetools.py:2626: note:     def __add__(self, ndarray[tuple[Any, ...], dtype[numpy.bool[builtins.bool]]], /) -> Index[bool]
+ hydpy/core/devicetools.py:2626: note:     def __add__(self, ndarray[tuple[Any, ...], dtype[integer[Any]]], /) -> Index[int]
+ hydpy/core/devicetools.py:2626: note:     def __add__(self, ndarray[tuple[Any, ...], dtype[floating[Any]]], /) -> Index[float]
+ hydpy/core/devicetools.py:2626: note:     def __add__(self, ndarray[tuple[Any, ...], dtype[complexfloating[Any, Any]]], /) -> Index[complex]
+ hydpy/core/devicetools.py:2626: note:     def __add__(self, builtins.bool | Sequence[builtins.bool] | ndarray[tuple[Any, ...], dtype[numpy.bool[builtins.bool]]] | ndarray[tuple[Any, ...], dtype[integer[Any]]] | Index[builtins.bool], /) -> Index[int]
+ hydpy/core/devicetools.py:2626: note:     def [T_INT: int] __add__(self, int | Sequence[int] | ndarray[tuple[Any, ...], dtype[numpy.bool[builtins.bool]]] | ndarray[tuple[Any, ...], dtype[integer[Any]]] | ndarray[tuple[Any, ...], dtype[floating[Any]]] | Index[T_INT], /) -> Index[float]
+ hydpy/core/devicetools.py:2626: note:     def [T_COMPLEX: complex] __add__(self, T_COMPLEX | Sequence[T_COMPLEX] | ndarray[tuple[Any, ...], dtype[numpy.bool[builtins.bool]]] | ndarray[tuple[Any, ...], dtype[integer[Any]]] | ndarray[tuple[Any, ...], dtype[floating[Any]]] | ndarray[tuple[Any, ...], dtype[complexfloating[Any, Any]]] | Index[T_COMPLEX], /) -> Index[complex]
+ hydpy/core/devicetools.py:2626: note:     def __add__(self, ndarray[tuple[Any, ...], dtype[numpy.bool[builtins.bool]]] | ndarray[tuple[Any, ...], dtype[integer[Any]]] | ndarray[tuple[Any, ...], dtype[floating[Any]]] | ndarray[tuple[Any, ...], dtype[complexfloating[Any, Any]]], /) -> Never
+ hydpy/core/devicetools.py:2626: note:     def __add__(self, str | Sequence[str] | ndarray[tuple[Any, ...], dtype[str_]] | Index[str], /) -> Index[str]

optuna (https://github.com/optuna/optuna)
+ tests/samplers_tests/test_nsgaii.py:939: error: Argument 1 to "full" has incompatible type "Any | None"; expected "SupportsIndex"  [arg-type]

prefect (https://github.com/PrefectHQ/prefect)
- src/prefect/utilities/callables.py:579: error: Incompatible types in assignment (expression has type "list[None]", variable has type "list[Optional[expr]]")  [assignment]
- src/prefect/utilities/callables.py:579: note: "list" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance
- src/prefect/utilities/callables.py:579: note: Consider using "Sequence" instead, which is covariant

pydantic (https://github.com/pydantic/pydantic)
- pydantic/aliases.py:29: error: Incompatible types in assignment (expression has type "list[str]", variable has type "list[int | str]")  [assignment]
- pydantic/aliases.py:29: note: "list" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance
- pydantic/aliases.py:29: note: Consider using "Sequence" instead, which is covariant
- pydantic/aliases.py:29: error: Argument 1 to "list" has incompatible type "tuple[str | int, ...]"; expected "Iterable[str]"  [arg-type]
+ pydantic/aliases.py:29: error: Argument 1 to "list" has incompatible type "tuple[str | int, ...]"; expected "Iterable[int]"  [arg-type]

colour (https://github.com/colour-science/colour)
+ colour/utilities/tests/test_array.py:1745: error: Argument 1 to "tile" has incompatible type "ndarray[tuple[Any, ...], dtype[float64]]"; expected "_SupportsArray[dtype[signedinteger[Any]]] | _NestedSequence[_SupportsArray[dtype[signedinteger[Any]]]]"  [arg-type]

altair (https://github.com/vega/altair)
+ altair/utils/data.py:203: error: No overload variant of "from_native" matches argument types "NativeDataFrame | narwhals.stable.v1.typing.DataFrameLike | SupportsGeoInterface | altair.utils.core.DataFrameLike", "bool"  [call-overload]
+ altair/utils/data.py:203: note: Possible overload variants:
+ altair/utils/data.py:203: note:     def [SeriesT: Series[Any]] from_native(native_object: SeriesT, **kwds: Any) -> SeriesT
+ altair/utils/data.py:203: note:     def [DataFrameT: DataFrame[Any]] from_native(native_object: DataFrameT, **kwds: Any) -> DataFrameT
+ altair/utils/data.py:203: note:     def [LazyFrameT: LazyFrame[Any]] from_native(native_object: LazyFrameT, **kwds: Any) -> LazyFrameT
+ altair/utils/data.py:203: note:     def [DataFrameT: DataFrame[Any], LazyFrameT: LazyFrame[Any]] from_native(native_object: DataFrameT | LazyFrameT, **kwds: Any) -> DataFrameT | LazyFrameT
+ altair/utils/data.py:203: note:     def [IntoDataFrameT: NativeDataFrame | DataFrameLike, IntoSeriesT: NativeSeries] from_native(native_object: IntoDataFrameT | IntoSeriesT, *, strict: Literal[False], eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[True], series_only: Literal[False] = ..., allow_series: Literal[True]) -> DataFrame[IntoDataFrameT] | Series[IntoSeriesT]
+ altair/utils/data.py:203: note:     def [IntoDataFrameT: NativeDataFrame | DataFrameLike, IntoSeriesT: NativeSeries] from_native(native_object: IntoDataFrameT | IntoSeriesT, *, strict: Literal[False], eager_only: Literal[True], eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: Literal[True]) -> DataFrame[IntoDataFrameT] | Series[IntoSeriesT]
+ altair/utils/data.py:203: note:     def [IntoDataFrameT: NativeDataFrame | DataFrameLike] from_native(native_object: IntoDataFrameT, *, strict: Literal[False], eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[True], series_only: Literal[False] = ..., allow_series: None = ...) -> DataFrame[IntoDataFrameT]
+ altair/utils/data.py:203: note:     def [T] from_native(native_object: T, *, strict: Literal[False], eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[True], series_only: Literal[False] = ..., allow_series: None = ...) -> T
+ altair/utils/data.py:203: note:     def [IntoDataFrameT: NativeDataFrame | DataFrameLike] from_native(native_object: IntoDataFrameT, *, strict: Literal[False], eager_only: Literal[True], eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: None = ...) -> DataFrame[IntoDataFrameT]
+ altair/utils/data.py:203: note:     def [T] from_native(native_object: T, *, strict: Literal[False], eager_only: Literal[True], eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: None = ...) -> T
+ altair/utils/data.py:203: note:     def [IntoDataFrameT: NativeDataFrame | DataFrameLike, IntoLazyFrameT: NativeLazyFrame, IntoSeriesT: NativeSeries] from_native(native_object: IntoDataFrameT | IntoLazyFrameT | IntoSeriesT, *, strict: Literal[False], eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: Literal[True]) -> DataFrame[IntoDataFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT]
+ altair/utils/data.py:203: note:     def [IntoSeriesT: NativeSeries] from_native(native_object: IntoSeriesT, *, strict: Literal[False], eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[False] = ..., series_only: Literal[True], allow_series: None = ...) -> Series[IntoSeriesT]
+ altair/utils/data.py:203: note:     def [IntoDataFrameT: NativeDataFrame | DataFrameLike] from_native(native_object: IntoDataFrameT, *, strict: Literal[False], eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: None = ...) -> DataFrame[IntoDataFrameT]
+ altair/utils/data.py:203: note:     def [IntoLazyFrameT: NativeLazyFrame] from_native(native_object: IntoLazyFrameT, *, strict: Literal[False], eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: None = ...) -> LazyFrame[IntoLazyFrameT]
+ altair/utils/data.py:203: note:     def [T] from_native(native_object: T, *, strict: Literal[False], eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: None = ...) -> T
+ altair/utils/data.py:203: note:     def [IntoDataFrameT: NativeDataFrame | DataFrameLike] from_native(native_object: IntoDataFrameT, *, strict: Literal[True] | None = ..., eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[True], series_only: Literal[False] = ..., allow_series: None = ...) -> DataFrame[IntoDataFrameT]
+ altair/utils/data.py:203: note:     def [IntoLazyFrameT: NativeLazyFrame] from_native(native_object: IntoLazyFrameT, *, strict: Literal[True] | None = ..., eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: None = ...) -> LazyFrame[IntoLazyFrameT]
+ altair/utils/data.py:203: note:     def [IntoDataFrameT: NativeDataFrame | DataFrameLike] from_native(native_object: IntoDataFrameT, *, strict: Literal[True] | None = ..., eager_only: Literal[True], eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: None = ...) -> DataFrame[IntoDataFrameT]
+ altair/utils/data.py:203: note:     def from_native(native_object: NativeDataFrame | NativeLazyFrame | NativeIbis | NativeSeries, *, strict: Literal[True] | None = ..., eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: Literal[True]) -> DataFrame[Any] | LazyFrame[Any] | Series[Any]
+ altair/utils/data.py:203: note:     def [IntoSeriesT: NativeSeries] from_native(native_object: IntoSeriesT, *, strict: Literal[True] | None = ..., eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[False] = ..., series_only: Literal[True], allow_series: None = ...) -> Series[IntoSeriesT]
+ altair/utils/data.py:203: note:     def [IntoDataFrameT: NativeDataFrame | DataFrameLike] from_native(native_object: IntoDataFrameT, *, strict: Literal[True] | None = ..., eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: None = ...) -> DataFrame[IntoDataFrameT]
+ altair/utils/data.py:203: note:     def [IntoDataFrameT: NativeDataFrame | DataFrameLike] from_native(native_object: IntoDataFrameT | NativeSeries, *, pass_through: Literal[True], eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[True], series_only: Literal[False] = ..., allow_series: Literal[True]) -> DataFrame[IntoDataFrameT]
+ altair/utils/data.py:203: note:     def [IntoDataFrameT: NativeDataFrame | DataFrameLike, IntoSeriesT: NativeSeries] from_native(native_object: IntoDataFrameT | IntoSeriesT, *, pass_through: Literal[True], eager_only: Literal[True], eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: Literal[True]) -> DataFrame[IntoDataFrameT] | Series[IntoSeriesT]
+ altair/utils/data.py:203: note:     def [IntoDataFrameT: NativeDataFrame | DataFrameLike] from_native(native_object: IntoDataFrameT, *, pass_through: Literal[True], eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[True], series_only: Literal[False] = ..., allow_series: None = ...) -> DataFrame[IntoDataFrameT]
+ altair/utils/data.py:203: note:     def [T] from_native(native_object: T, *, pass_through: Literal[True], eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[True], series_only: Literal[False] = ..., allow_series: None = ...) -> T
+ altair/utils/data.py:203: note:     def [IntoDataFrameT: NativeDataFrame | DataFrameLike] from_native(native_object: IntoDataFrameT, *, pass_through: Literal[True], eager_only: Literal[True], eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: None = ...) -> DataFrame[IntoDataFrameT]
+ altair/utils/data.py:203: note:     def [T] from_native(native_object: T, *, pass_through: Literal[True], eager_only: Literal[True], eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: None = ...) -> T
+ altair/utils/data.py:203: note:     def [IntoDataFrameT: NativeDataFrame | DataFrameLike, IntoLazyFrameT: NativeLazyFrame, IntoSeriesT: NativeSeries] from_native(native_object: IntoDataFrameT | IntoLazyFrameT | IntoSeriesT, *, pass_through: Literal[True], eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: Literal[True]) -> DataFrame[IntoDataFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT]
+ altair/utils/data.py:203: note:     def [IntoSeriesT: NativeSeries] from_native(native_object: IntoSeriesT, *, pass_through: Literal[True], eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[False] = ..., series_only: Literal[True], allow_series: None = ...) -> Series[IntoSeriesT]
+ altair/utils/data.py:203: note:     def [IntoDataFrameT: NativeDataFrame | DataFrameLike, IntoLazyFrameT: NativeLazyFrame] from_native(native_object: IntoDataFrameT | IntoLazyFrameT, *, pass_through: Literal[True], eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: None = ...) -> DataFrame[IntoDataFrameT] | LazyFrame[IntoLazyFrameT]
+ altair/utils/data.py:203: note:     def [T] from_native(native_object: T, *, pass_through: Literal[True], eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: None = ...) -> T
+ altair/utils/data.py:203: note:     def [IntoDataFrameT: NativeDataFrame | DataFrameLike] from_native(native_object: IntoDataFrameT, *, pass_through: Literal[False] = ..., eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[True], series_only: Literal[False] = ..., allow_series: None = ...) -> DataFrame[IntoDataFrameT]
+ altair/utils/data.py:203: note:     def [IntoDataFrameT: NativeDataFrame | DataFrameLike] from_native(native_object: IntoDataFrameT, *, pass_through: Literal[False] = ..., eager_only: Literal[True], eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: None = ...) -> DataFrame[IntoDataFrameT]
+ altair/utils/data.py:203: note:     def from_native(native_object: NativeDataFrame | NativeLazyFrame | NativeIbis | NativeSeries, *, pass_through: Literal[False] = ..., eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: Literal[True]) -> DataFrame[Any] | LazyFrame[Any] | Series[Any]
+ altair/utils/data.py:203: note:     def [IntoSeriesT: NativeSeries] from_native(native_object: IntoSeriesT, *, pass_through: Literal[False] = ..., eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[False] = ..., series_only: Literal[True], allow_series: None = ...) -> Series[IntoSeriesT]
+ altair/utils/data.py:203: note:     def [IntoDataFrameT: NativeDataFrame | DataFrameLike] from_native(native_object: IntoDataFrameT, *, pass_through: Literal[False] = ..., eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: None = ...) -> DataFrame[IntoDataFrameT]
+ altair/utils/data.py:203: note:     def [IntoLazyFrameT: NativeLazyFrame] from_native(native_object: IntoLazyFrameT, *, pass_through: Literal[False] = ..., eager_only: Literal[False] = ..., eager_or_interchange_only: Literal[False] = ..., series_only: Literal[False] = ..., allow_series: None = ...) -> LazyFrame[IntoLazyFrameT]
+ altair/utils/data.py:203: note:     def from_native(native_object: Any, *, pass_through: bool, eager_only: bool, eager_or_interchange_only: bool = ..., series_only: bool, allow_series: bool | None) -> Any
+ altair/utils/data.py:208: error: Unsupported operand types for * ("float" and "int")  [operator]
+ altair/utils/data.py:208: error: Argument 1 to "len" has incompatible type "dict[Any, Any] | NativeDataFrame | narwhals.stable.v1.typing.DataFrameLike | SupportsGeoInterface | altair.utils.core.DataFrameLike | Any"; expected "Sized"  [arg-type]
+ altair/utils/data.py:209: error: Argument 1 to "len" has incompatible type "dict[Any, Any] | NativeDataFrame | narwhals.stable.v1.typing.DataFrameLike | SupportsGeoInterface | altair.utils.core.DataFrameLike | Any"; expected "Sized"  [arg-type]
+ altair/utils/data.py:210: error: Value of type "dict[Any, Any] | NativeDataFrame | narwhals.stable.v1.typing.DataFrameLike | SupportsGeoInterface | altair.utils.core.DataFrameLike | Any" is not indexable  [index]

scrapy (https://github.com/scrapy/scrapy)
+ tests/test_pipeline_images.py:312: error: Argument "default" has incompatible type "type[list[_T]]"; expected "list[str]"  [arg-type]
+ tests/test_pipeline_images.py:313: error: Argument "default" has incompatible type "type[list[_T]]"; expected "list[dict[str, str]]"  [arg-type]
+ tests/test_pipeline_images.py:315: error: Argument "default" has incompatible type "type[list[_T]]"; expected "list[str]"  [arg-type]
+ tests/test_pipeline_images.py:316: error: Argument "default" has incompatible type "type[list[_T]]"; expected "list[dict[str, str]]"  [arg-type]
+ tests/test_pipeline_files.py:368: error: Argument "default" has incompatible type "type[list[_T]]"; expected "list[str]"  [arg-type]
+ tests/test_pipeline_files.py:369: error: Argument "default" has incompatible type "type[list[_T]]"; expected "list[dict[str, str]]"  [arg-type]
+ tests/test_pipeline_files.py:371: error: Argument "default" has incompatible type "type[list[_T]]"; expected "list[str]"  [arg-type]
+ tests/test_pipeline_files.py:372: error: Argument "default" has incompatible type "type[list[_T]]"; expected "list[dict[str, str]]"  [arg-type]

core (https://github.com/home-assistant/core)
+ homeassistant/components/ambient_network/config_flow.py:80: error: "bytes" has no attribute "get"  [attr-defined]

pytest (https://github.com/pytest-dev/pytest)
+ src/_pytest/config/argparsing.py:476: error: Argument 2 to "parse_known_args" of "ArgumentParser" has incompatible type "Namespace | None"; expected "Namespace"  [arg-type]

pandas (https://github.com/pandas-dev/pandas)
+ pandas/core/arrays/arrow/array.py:2753: error: Argument 1 to "reshape" of "ndarray" has incompatible type "tuple[int, int]"; expected "tuple[int]"  [arg-type]
+ pandas/io/parsers/python_parser.py:440: error: Argument 1 to "view" of "ndarray" has incompatible type "type[unsignedinteger[_8Bit]]"; expected "type[numpy.bool[builtins.bool]] | dtype[numpy.bool[builtins.bool]] | _SupportsDType[dtype[numpy.bool[builtins.bool]]]"  [arg-type]
+ pandas/io/parsers/python_parser.py:440: note: Only class variables allowed for class object access on protocols, dtype is an instance variable of "unsignedinteger"

trio (https://github.com/python-trio/trio)
+ src/trio/_core/_tests/test_run.py:2424: error: Unused "type: ignore" comment  [unused-ignore]
+ src/trio/_core/_tests/test_run.py:2425: error: Argument 1 to "acapture" has incompatible type "Callable[[Outcome[object]], Coroutine[Any, Any, object]]"; expected "Callable[[Outcome[object]], Awaitable[str]]"  [arg-type]

jax (https://github.com/google/jax)
+ jax/_src/dtypes.py:228: error: Argument 1 to "dtype" has incompatible type "type[floating[_32Bit]]"; expected "type[float64] | dtype[float64] | _SupportsDType[dtype[float64]]"  [arg-type]
+ jax/_src/dtypes.py:228: note: Only class variables allowed for class object access on protocols, dtype is an instance variable of "floating"

scipy (https://github.com/scipy/scipy)
+ scipy/sparse/tests/test_coo.py:1239: error: Argument 1 to "reshape" of "ndarray" has incompatible type "tuple[int, int, int]"; expected "tuple[int, int]"  [arg-type]
+ scipy/sparse/tests/test_coo.py:1283: error: Argument 1 to "reshape" of "ndarray" has incompatible type "tuple[int, int, int, int, int]"; expected "tuple[int, int]"  [arg-type]

dedupe (https://github.com/dedupeio/dedupe)
+ dedupe/convenience.py:44: error: Argument "dtype" to "array" has incompatible type "type[unsignedinteger[_64Bit]]"; expected "type[signedinteger[Any]] | dtype[signedinteger[Any]] | _SupportsDType[dtype[signedinteger[Any]]]"  [arg-type]
+ dedupe/convenience.py:44: note: Only class variables allowed for class object access on protocols, dtype is an instance variable of "unsignedinteger"

materialize (https://github.com/MaterializeInc/materialize)
+ misc/python/materialize/cli/mzcompose.py:948: error: Argument 2 to "parse_known_args" of "ArgumentParser" has incompatible type "Namespace | None"; expected "Namespace"  [arg-type]

static-frame (https://github.com/static-frame/static-frame)
+ static_frame/core/util.py:1417: error: Argument "dtype" to "__call__" of "_ConstructorEmpty" has incompatible type "dtype[Any] | None"; expected "None"  [arg-type]
+ static_frame/core/series_mapping.py:76: error: Argument 1 to "iter" has incompatible type "IndexBase"; expected "SupportsIter[Iterator[TVKeys]]"  [arg-type]
+ static_frame/core/series_mapping.py:76: note: Following member(s) of "IndexBase" have conflicts:
+ static_frame/core/series_mapping.py:76: note:     Expected:
+ static_frame/core/series_mapping.py:76: note:         def __iter__(self) -> Iterator[TVKeys]
+ static_frame/core/series_mapping.py:76: note:     Got:
+ static_frame/core/series_mapping.py:76: note:         def __iter__(self) -> Iterator[TLabel]

openlibrary (https://github.com/internetarchive/openlibrary)
+ openlibrary/solr/data_provider.py: note: In member "get_work_reading_log" of class "LegacyDataProvider":
+ openlibrary/solr/data_provider.py:309: error: Argument 1 to "sum" has incompatible type "dict_values[str, object]"; expected "Iterable[bool]"  [arg-type]

nox (https://github.com/wntrblm/nox)
+ nox/_option_set.py:64: error: Argument "validator" to "field" has incompatible type "Callable[[Any, Attribute[Optional[str]], Optional[str]], Any]"; expected "Union[Callable[[Any, Attribute[Optional[Literal['auto', 'never', 'always']]], Optional[Literal['auto', 'never', 'always']]], Any], Sequence[Callable[[Any, Attribute[Optional[Literal['auto', 'never', 'always']]], Optional[Literal['auto', 'never', 'always']]], Any]], None]"  [arg-type]
+ nox/_option_set.py:75: error: Argument "validator" to "field" has incompatible type "Callable[[Any, Attribute[Optional[str]], Optional[str]], Any]"; expected "Union[Callable[[Any, Attribute[Optional[Literal['no', 'yes', 'never', 'always']]], Optional[Literal['no', 'yes', 'never', 'always']]], Any], Sequence[Callable[[Any, Attribute[Optional[Literal['no', 'yes', 'never', 'always']]], Optional[Literal['no', 'yes', 'never', 'always']]], Any]], None]"  [arg-type]