diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 22cfd261b..729c0352d 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -18,6 +18,6 @@ repos: hooks: - id: isort - repo: https://github.com/psf/black - rev: 25.9.0 + rev: 25.11.0 hooks: - id: black diff --git a/pandas-stubs/__init__.pyi b/pandas-stubs/__init__.pyi index 99a93825e..e10dfb293 100644 --- a/pandas-stubs/__init__.pyi +++ b/pandas-stubs/__init__.pyi @@ -1,3 +1,5 @@ +import sys + from pandas import ( api as api, arrays as arrays, @@ -47,7 +49,6 @@ from pandas.core.api import ( UInt16Dtype as UInt16Dtype, UInt32Dtype as UInt32Dtype, UInt64Dtype as UInt64Dtype, - array as array, bdate_range as bdate_range, date_range as date_range, factorize as factorize, @@ -100,13 +101,11 @@ from pandas.io.api import ( HDFStore as HDFStore, read_clipboard as read_clipboard, read_csv as read_csv, - read_excel as read_excel, read_feather as read_feather, read_fwf as read_fwf, read_hdf as read_hdf, read_html as read_html, read_json as read_json, - read_orc as read_orc, read_parquet as read_parquet, read_pickle as read_pickle, read_sas as read_sas, @@ -118,8 +117,21 @@ from pandas.io.api import ( read_table as read_table, read_xml as read_xml, ) +from pandas.io.api import ( + read_excel as read_excel, # pyright: ignore[reportUnknownVariableType] +) +from pandas.io.api import ( + read_orc as read_orc, # pyright: ignore[reportUnknownVariableType] +) from pandas.io.json._normalize import json_normalize as json_normalize from pandas.tseries import offsets as offsets from pandas.tseries.api import infer_freq as infer_freq +if sys.version_info >= (3, 11): + from pandas.core.construction import array as array +else: + from pandas.core.construction import ( + array as array, # pyright: ignore[reportUnknownVariableType] + ) + __version__: str diff --git a/pandas-stubs/_typing.pyi b/pandas-stubs/_typing.pyi index 794923014..b0de940da 100644 --- a/pandas-stubs/_typing.pyi +++ b/pandas-stubs/_typing.pyi @@ -182,7 +182,7 @@ Level: TypeAlias = Hashable Shape: TypeAlias = tuple[int, ...] Suffixes: TypeAlias = tuple[str | None, str | None] | list[str | None] Ordered: TypeAlias = bool | None -JSONSerializable: TypeAlias = PythonScalar | list[Any] | dict +JSONSerializable: TypeAlias = PythonScalar | list[Any] | dict[str, Any] Frequency: TypeAlias = str | BaseOffset PeriodFrequency: TypeAlias = ( str @@ -967,9 +967,7 @@ ListLikeExceptSeriesAndStr: TypeAlias = ( MutableSequence[Any] | np_1darray | tuple[Any, ...] | Index ) ListLikeU: TypeAlias = Sequence[Any] | np_1darray | Series | Index -ListLikeHashable: TypeAlias = ( - MutableSequence[HashableT] | np_1darray | tuple[HashableT, ...] | range -) +ListLikeHashable: TypeAlias = SequenceNotStr[HashableT] | np_1darray | range class SupportsDType(Protocol[GenericT_co]): @property diff --git a/pandas-stubs/core/api.pyi b/pandas-stubs/core/api.pyi index f6f2f9a2e..a2984981d 100644 --- a/pandas-stubs/core/api.pyi +++ b/pandas-stubs/core/api.pyi @@ -1,3 +1,5 @@ +import sys + from pandas.core.algorithms import ( factorize as factorize, unique as unique, @@ -20,7 +22,6 @@ from pandas.core.arrays.integer import ( UInt64Dtype as UInt64Dtype, ) from pandas.core.arrays.string_ import StringDtype as StringDtype -from pandas.core.construction import array as array from pandas.core.frame import DataFrame as DataFrame from pandas.core.groupby import ( Grouper as Grouper, @@ -75,3 +76,10 @@ from pandas.core.dtypes.missing import ( from pandas.io.formats.format import set_eng_float_format as set_eng_float_format from pandas.tseries.offsets import DateOffset as DateOffset + +if sys.version_info >= (3, 11): + from pandas.core.construction import array as array +else: + from pandas.core.construction import ( + array as array, # pyright: ignore[reportUnknownVariableType] + ) diff --git a/pandas-stubs/core/computation/eval.pyi b/pandas-stubs/core/computation/eval.pyi index b1bb890e4..e374c50d6 100644 --- a/pandas-stubs/core/computation/eval.pyi +++ b/pandas-stubs/core/computation/eval.pyi @@ -21,7 +21,7 @@ def eval( engine: Literal["python", "numexpr"] | None = ..., local_dict: dict[str, Any] | None = None, global_dict: dict[str, Any] | None = None, - resolvers: list[Mapping] | None = ..., + resolvers: list[Mapping[Any, Any]] | None = ..., level: int = 0, target: object | None = None, inplace: bool = False, diff --git a/pandas-stubs/core/frame.pyi b/pandas-stubs/core/frame.pyi index aaaa8461a..fccd510c3 100644 --- a/pandas-stubs/core/frame.pyi +++ b/pandas-stubs/core/frame.pyi @@ -1174,7 +1174,7 @@ class DataFrame(NDFrame, OpsMixin, _GetItemHack): @overload def sort_values( self, - by: _str | Sequence[_str], + by: _str | SequenceNotStr[_str], *, axis: Axis = 0, ascending: _bool | Sequence[_bool] = ..., @@ -1187,7 +1187,7 @@ class DataFrame(NDFrame, OpsMixin, _GetItemHack): @overload def sort_values( self, - by: _str | Sequence[_str], + by: _str | SequenceNotStr[_str], *, axis: Axis = 0, ascending: _bool | Sequence[_bool] = ..., @@ -1394,7 +1394,7 @@ class DataFrame(NDFrame, OpsMixin, _GetItemHack): @overload def groupby( # type: ignore[overload-overlap] # pyright: ignore reportOverlappingOverload self, - by: MultiIndex | GroupByObjectNonScalar | None = ..., + by: MultiIndex | GroupByObjectNonScalar[Any] | None = ..., level: IndexLabel | None = ..., as_index: Literal[True] = True, sort: _bool = ..., @@ -1405,7 +1405,7 @@ class DataFrame(NDFrame, OpsMixin, _GetItemHack): @overload def groupby( # type: ignore[overload-overlap] self, - by: MultiIndex | GroupByObjectNonScalar | None = ..., + by: MultiIndex | GroupByObjectNonScalar[Any] | None = ..., level: IndexLabel | None = ..., as_index: Literal[False] = False, sort: _bool = ..., @@ -1862,7 +1862,7 @@ class DataFrame(NDFrame, OpsMixin, _GetItemHack): @overload def boxplot( self, - by: Hashable | ListLikeHashable, + by: Hashable | ListLikeHashable[Hashable], ax: PlotAxes | None = None, fontsize: float | _str | None = None, rot: float = 0, @@ -1877,7 +1877,7 @@ class DataFrame(NDFrame, OpsMixin, _GetItemHack): @overload def boxplot( self, - by: Hashable | ListLikeHashable, + by: Hashable | ListLikeHashable[Hashable], ax: PlotAxes | None = None, fontsize: float | _str | None = None, rot: float = 0, diff --git a/pandas-stubs/core/reshape/pivot.pyi b/pandas-stubs/core/reshape/pivot.pyi index b88deca97..e526645d3 100644 --- a/pandas-stubs/core/reshape/pivot.pyi +++ b/pandas-stubs/core/reshape/pivot.pyi @@ -35,7 +35,7 @@ from pandas._typing import ( _PivotAggCallable: TypeAlias = Callable[[Series], ScalarT] _PivotAggFunc: TypeAlias = ( - _PivotAggCallable + _PivotAggCallable[ScalarT] | np.ufunc | Literal["mean", "sum", "count", "min", "max", "median", "std", "var"] ) @@ -67,11 +67,17 @@ _Values: TypeAlias = SequenceNotStr[Any] | _ExtendedAnyArrayLike @overload def pivot_table( data: DataFrame, - values: _PivotTableValuesTypes = None, - index: _PivotTableIndexTypes = None, - columns: _PivotTableColumnsTypes = None, + values: _PivotTableValuesTypes[ + Hashable # ty: ignore[invalid-type-arguments] + ] = None, + index: _PivotTableIndexTypes[Hashable] = None, # ty: ignore[invalid-type-arguments] + columns: _PivotTableColumnsTypes[ + Hashable # ty: ignore[invalid-type-arguments] + ] = None, aggfunc: ( - _PivotAggFunc | Sequence[_PivotAggFunc] | Mapping[Hashable, _PivotAggFunc] + _PivotAggFunc[Any] + | Sequence[_PivotAggFunc[Any]] + | Mapping[Hashable, _PivotAggFunc[Any]] ) = "mean", fill_value: Scalar | None = None, margins: bool = False, @@ -85,12 +91,20 @@ def pivot_table( @overload def pivot_table( data: DataFrame, - values: _PivotTableValuesTypes = None, + values: _PivotTableValuesTypes[ + Hashable # ty: ignore[invalid-type-arguments] + ] = None, *, index: Grouper, - columns: _PivotTableColumnsTypes | np_ndarray | Index[Any] = None, + columns: ( + _PivotTableColumnsTypes[Hashable] # ty: ignore[invalid-type-arguments] + | np_ndarray + | Index[Any] + ) = None, aggfunc: ( - _PivotAggFunc | Sequence[_PivotAggFunc] | Mapping[Hashable, _PivotAggFunc] + _PivotAggFunc[Any] + | Sequence[_PivotAggFunc[Any]] + | Mapping[Hashable, _PivotAggFunc[Any]] ) = "mean", fill_value: Scalar | None = None, margins: bool = False, @@ -102,12 +116,20 @@ def pivot_table( @overload def pivot_table( data: DataFrame, - values: _PivotTableValuesTypes = None, - index: _PivotTableIndexTypes | np_ndarray | Index[Any] = None, + values: _PivotTableValuesTypes[ + Hashable # ty: ignore[invalid-type-arguments] + ] = None, + index: ( + _PivotTableIndexTypes[Hashable] # ty: ignore[invalid-type-arguments] + | np_ndarray + | Index[Any] + ) = None, *, columns: Grouper, aggfunc: ( - _PivotAggFunc | Sequence[_PivotAggFunc] | Mapping[Hashable, _PivotAggFunc] + _PivotAggFunc[Any] + | Sequence[_PivotAggFunc[Any]] + | Mapping[Hashable, _PivotAggFunc[Any]] ) = "mean", fill_value: Scalar | None = None, margins: bool = False, diff --git a/pandas-stubs/core/reshape/tile.pyi b/pandas-stubs/core/reshape/tile.pyi index 9f237fd64..510ff0911 100644 --- a/pandas-stubs/core/reshape/tile.pyi +++ b/pandas-stubs/core/reshape/tile.pyi @@ -1,5 +1,6 @@ from collections.abc import Sequence from typing import ( + Any, Literal, overload, ) @@ -102,7 +103,7 @@ def cut( include_lowest: bool = ..., duplicates: Literal["raise", "drop"] = ..., ordered: bool = ..., -) -> tuple[Series, IntervalIndex]: ... +) -> tuple[Series, IntervalIndex[Any]]: ... @overload def cut( x: Sequence[float] | np_ndarray_anyint | np_ndarray_float | Index, @@ -132,7 +133,9 @@ def cut( @overload def cut( x: Sequence[float] | np_ndarray_anyint | np_ndarray_float | Index, - bins: int | Sequence[float] | Index[int] | Index[float] | IntervalIndex | Series, + bins: ( + int | Sequence[float] | Index[int] | Index[float] | IntervalIndex[Any] | Series + ), right: bool = ..., *, labels: Literal[False], @@ -163,7 +166,9 @@ def cut( @overload def cut( x: Series, - bins: int | Sequence[float] | Index[int] | Index[float] | IntervalIndex | Series, + bins: ( + int | Sequence[float] | Index[int] | Index[float] | IntervalIndex[Any] | Series + ), right: bool = ..., labels: Literal[False] | Sequence[Label] | None = ..., retbins: Literal[False] = False, @@ -175,7 +180,9 @@ def cut( @overload def cut( x: Sequence[float] | np_ndarray_anyint | np_ndarray_float | Index, - bins: int | Sequence[float] | Index[int] | Index[float] | IntervalIndex | Series, + bins: ( + int | Sequence[float] | Index[int] | Index[float] | IntervalIndex[Any] | Series + ), right: bool = ..., labels: Sequence[Label] | None = ..., retbins: Literal[False] = False, diff --git a/pandas-stubs/core/tools/timedeltas.pyi b/pandas-stubs/core/tools/timedeltas.pyi index 3057ce808..895e7cfc2 100644 --- a/pandas-stubs/core/tools/timedeltas.pyi +++ b/pandas-stubs/core/tools/timedeltas.pyi @@ -1,4 +1,3 @@ -from collections.abc import Sequence from datetime import timedelta from typing import overload @@ -28,14 +27,7 @@ def to_timedelta( ) -> Series[Timedelta]: ... @overload def to_timedelta( - arg: ( - SequenceNotStr - | Sequence[float | timedelta] - | tuple[str | float | timedelta, ...] - | range - | ArrayLike - | Index - ), + arg: SequenceNotStr[str | float | timedelta] | range | ArrayLike | Index, unit: TimeDeltaUnitChoices | None = ..., errors: RaiseCoerce = ..., ) -> TimedeltaIndex: ... diff --git a/pandas-stubs/io/api.pyi b/pandas-stubs/io/api.pyi index 8da2a7a40..5b6bd646a 100644 --- a/pandas-stubs/io/api.pyi +++ b/pandas-stubs/io/api.pyi @@ -2,14 +2,18 @@ from pandas.io.clipboards import read_clipboard as read_clipboard from pandas.io.excel import ( ExcelFile as ExcelFile, ExcelWriter as ExcelWriter, - read_excel as read_excel, +) +from pandas.io.excel import ( + read_excel as read_excel, # pyright: ignore[reportUnknownVariableType] ) from pandas.io.feather_format import read_feather as read_feather from pandas.io.html import read_html as read_html from pandas.io.json import read_json as read_json -from pandas.io.orc import read_orc as read_orc +from pandas.io.orc import ( + read_orc as read_orc, # pyright: ignore[reportUnknownVariableType] +) from pandas.io.parquet import read_parquet as read_parquet -from pandas.io.parsers import ( +from pandas.io.parsers.readers import ( read_csv as read_csv, read_fwf as read_fwf, read_table as read_table, diff --git a/pandas-stubs/io/clipboards.pyi b/pandas-stubs/io/clipboards.pyi index 25a1ed180..f3608569e 100644 --- a/pandas-stubs/io/clipboards.pyi +++ b/pandas-stubs/io/clipboards.pyi @@ -1,6 +1,7 @@ from collections import defaultdict from collections.abc import ( Callable, + Hashable, Sequence, ) import csv @@ -33,10 +34,10 @@ def read_clipboard( dtype_backend: DtypeBackend | _NoDefaultDoNotUse = ..., delimiter: str | None = ..., header: int | Sequence[int] | Literal["infer"] | None = ..., - names: ListLikeHashable | None = ..., + names: ListLikeHashable[Hashable] | None = ..., index_col: int | str | Sequence[str | int] | Literal[False] | None = ..., - usecols: UsecolsArgType = ..., - dtype: DtypeArg | defaultdict | None = ..., + usecols: UsecolsArgType[Any] = ..., + dtype: DtypeArg | defaultdict[Hashable, Any] | None = ..., engine: CSVEngine | None = ..., converters: dict[int | str, Callable[[str], Any]] = ..., true_values: list[str] = ..., @@ -92,10 +93,10 @@ def read_clipboard( dtype_backend: DtypeBackend | _NoDefaultDoNotUse = ..., delimiter: str | None = ..., header: int | Sequence[int] | Literal["infer"] | None = ..., - names: ListLikeHashable | None = ..., + names: ListLikeHashable[Hashable] | None = ..., index_col: int | str | Sequence[str | int] | Literal[False] | None = ..., - usecols: UsecolsArgType = ..., - dtype: DtypeArg | defaultdict | None = ..., + usecols: UsecolsArgType[Any] = ..., + dtype: DtypeArg | defaultdict[Hashable, Any] | None = ..., engine: CSVEngine | None = ..., converters: dict[int | str, Callable[[str], Any]] = ..., true_values: list[str] = ..., @@ -151,10 +152,10 @@ def read_clipboard( dtype_backend: DtypeBackend | _NoDefaultDoNotUse = ..., delimiter: str | None = ..., header: int | Sequence[int] | Literal["infer"] | None = ..., - names: ListLikeHashable | None = ..., + names: ListLikeHashable[Hashable] | None = ..., index_col: int | str | Sequence[str | int] | Literal[False] | None = ..., - usecols: UsecolsArgType = ..., - dtype: DtypeArg | defaultdict | None = ..., + usecols: UsecolsArgType[Any] = ..., + dtype: DtypeArg | defaultdict[Hashable, Any] | None = ..., engine: CSVEngine | None = ..., converters: dict[int | str, Callable[[str], Any]] = ..., true_values: list[str] = ..., diff --git a/pandas-stubs/io/excel/__init__.pyi b/pandas-stubs/io/excel/__init__.pyi index 3156999fe..ea2caaa32 100644 --- a/pandas-stubs/io/excel/__init__.pyi +++ b/pandas-stubs/io/excel/__init__.pyi @@ -1,5 +1,7 @@ from pandas.io.excel._base import ( ExcelFile as ExcelFile, ExcelWriter as ExcelWriter, - read_excel as read_excel, +) +from pandas.io.excel._base import ( + read_excel as read_excel, # pyright: ignore[reportUnknownVariableType] ) diff --git a/pandas-stubs/io/excel/_base.pyi b/pandas-stubs/io/excel/_base.pyi index 9e772560c..deeddf818 100644 --- a/pandas-stubs/io/excel/_base.pyi +++ b/pandas-stubs/io/excel/_base.pyi @@ -12,7 +12,6 @@ from typing import ( overload, ) -from odf.opendocument import OpenDocument # pyright: ignore[reportMissingTypeStubs] from openpyxl.workbook.workbook import Workbook from pandas.core.frame import DataFrame import pyxlsb.workbook # pyright: ignore[reportMissingTypeStubs] @@ -35,6 +34,10 @@ from pandas._typing import ( WriteExcelBuffer, ) +from odf.opendocument import ( # pyright: ignore[reportMissingTypeStubs] # isort: skip + OpenDocument, # pyright: ignore[reportUnknownVariableType] +) + @overload def read_excel( io: ( @@ -49,9 +52,9 @@ def read_excel( sheet_name: list[IntStrT], *, header: int | Sequence[int] | None = ..., - names: ListLikeHashable | None = ..., + names: ListLikeHashable[Hashable] | None = ..., index_col: int | Sequence[int] | str | None = ..., - usecols: str | UsecolsArgType = ..., + usecols: str | UsecolsArgType[Any] = ..., dtype: str | Dtype | Mapping[str, str | Dtype] | None = ..., engine: ExcelReadEngine | None = ..., converters: Mapping[int | str, Callable[[Any], Any]] | None = ..., @@ -92,9 +95,9 @@ def read_excel( sheet_name: None, *, header: int | Sequence[int] | None = ..., - names: ListLikeHashable | None = ..., + names: ListLikeHashable[Hashable] | None = ..., index_col: int | Sequence[int] | str | None = ..., - usecols: str | UsecolsArgType = ..., + usecols: str | UsecolsArgType[Any] = ..., dtype: str | Dtype | Mapping[str, str | Dtype] | None = ..., engine: ExcelReadEngine | None = ..., converters: Mapping[int | str, Callable[[Any], Any]] | None = ..., @@ -136,9 +139,9 @@ def read_excel( # type: ignore[overload-cannot-match] sheet_name: list[int | str], *, header: int | Sequence[int] | None = ..., - names: ListLikeHashable | None = ..., + names: ListLikeHashable[Hashable] | None = ..., index_col: int | Sequence[int] | str | None = ..., - usecols: str | UsecolsArgType = ..., + usecols: str | UsecolsArgType[Any] = ..., dtype: str | Dtype | Mapping[str, str | Dtype] | None = ..., engine: ExcelReadEngine | None = ..., converters: Mapping[int | str, Callable[[Any], Any]] | None = ..., @@ -179,9 +182,9 @@ def read_excel( sheet_name: int | str = ..., *, header: int | Sequence[int] | None = ..., - names: ListLikeHashable | None = ..., + names: ListLikeHashable[Hashable] | None = ..., index_col: int | Sequence[int] | str | None = ..., - usecols: str | UsecolsArgType = ..., + usecols: str | UsecolsArgType[Any] = ..., dtype: str | Dtype | Mapping[str, str | Dtype] | None = ..., engine: ExcelReadEngine | None = ..., converters: Mapping[int | str, Callable[[Any], Any]] | None = ..., @@ -261,9 +264,9 @@ class ExcelFile: self, sheet_name: list[int | str] | None, header: int | Sequence[int] | None = ..., - names: ListLikeHashable | None = ..., + names: ListLikeHashable[Hashable] | None = ..., index_col: int | Sequence[int] | None = ..., - usecols: str | UsecolsArgType = ..., + usecols: str | UsecolsArgType[Any] = ..., converters: dict[int | str, Callable[[Any], Any]] | None = ..., true_values: Iterable[Hashable] | None = ..., false_values: Iterable[Hashable] | None = ..., @@ -289,9 +292,9 @@ class ExcelFile: self, sheet_name: int | str, header: int | Sequence[int] | None = ..., - names: ListLikeHashable | None = ..., + names: ListLikeHashable[Hashable] | None = ..., index_col: int | Sequence[int] | None = ..., - usecols: str | UsecolsArgType = ..., + usecols: str | UsecolsArgType[Any] = ..., converters: dict[int | str, Callable[[Any], Any]] | None = ..., true_values: Iterable[Hashable] | None = ..., false_values: Iterable[Hashable] | None = ..., diff --git a/pandas-stubs/io/html.pyi b/pandas-stubs/io/html.pyi index 091475b26..4a43aa45d 100644 --- a/pandas-stubs/io/html.pyi +++ b/pandas-stubs/io/html.pyi @@ -29,7 +29,7 @@ from pandas._typing import ( def read_html( io: FilePath | ReadBuffer[str], *, - match: str | Pattern = ..., + match: str | Pattern[str] = ..., flavor: HTMLFlavors | Sequence[HTMLFlavors] | None = ..., header: int | Sequence[int] | None = ..., index_col: int | Sequence[int] | list[HashableT1] | None = ..., diff --git a/pandas-stubs/io/json/__init__.pyi b/pandas-stubs/io/json/__init__.pyi index 993f8afb4..137356130 100644 --- a/pandas-stubs/io/json/__init__.pyi +++ b/pandas-stubs/io/json/__init__.pyi @@ -1,6 +1,4 @@ -from pandas.io.json._json import ( - read_json as read_json, -) +from pandas.io.json._json import read_json as read_json # below are untyped imports so commented out # to_json as to_json,; ujson_dumps as ujson_dumps,; ujson_loads as ujson_loads, diff --git a/pandas-stubs/io/json/_normalize.pyi b/pandas-stubs/io/json/_normalize.pyi index 254be890f..348a27368 100644 --- a/pandas-stubs/io/json/_normalize.pyi +++ b/pandas-stubs/io/json/_normalize.pyi @@ -1,9 +1,15 @@ +from collections.abc import ( + Mapping, + Sequence, +) +from typing import Any + from pandas import DataFrame from pandas._typing import IgnoreRaise def json_normalize( - data: dict | list[dict], + data: Mapping[str, Any] | Sequence[Mapping[str, Any]], record_path: str | list[str] | None = None, meta: str | list[str | list[str]] | None = None, meta_prefix: str | None = None, diff --git a/pandas-stubs/io/orc.pyi b/pandas-stubs/io/orc.pyi index d361df0b1..2a0adb579 100644 --- a/pandas-stubs/io/orc.pyi +++ b/pandas-stubs/io/orc.pyi @@ -1,6 +1,5 @@ from typing import Any -from fsspec.spec import AbstractFileSystem # pyright: ignore[reportMissingTypeStubs] from pandas import DataFrame from pyarrow.fs import FileSystem @@ -12,6 +11,10 @@ from pandas._typing import ( ReadBuffer, ) +from fsspec.spec import ( # pyright: ignore[reportMissingTypeStubs] # isort: skip + AbstractFileSystem, # pyright: ignore[reportUnknownVariableType] +) + def read_orc( path: FilePath | ReadBuffer[bytes], columns: list[HashableT] | None = None, diff --git a/pandas-stubs/io/parsers/readers.pyi b/pandas-stubs/io/parsers/readers.pyi index 8d0d4d8c4..f3d3a8090 100644 --- a/pandas-stubs/io/parsers/readers.pyi +++ b/pandas-stubs/io/parsers/readers.pyi @@ -41,10 +41,10 @@ def read_csv( sep: str | None = ..., delimiter: str | None = None, header: int | Sequence[int] | Literal["infer"] | None = "infer", - names: ListLikeHashable | None = ..., + names: ListLikeHashable[Hashable] | None = ..., index_col: int | str | Sequence[str | int] | Literal[False] | None = None, usecols: UsecolsArgType[HashableT] = None, - dtype: DtypeArg | defaultdict | None = None, + dtype: DtypeArg | defaultdict[Hashable, Any] | None = None, engine: CSVEngine | None = None, converters: ( Mapping[int | str, Callable[[str], Any]] @@ -104,10 +104,10 @@ def read_csv( sep: str | None = ..., delimiter: str | None = None, header: int | Sequence[int] | Literal["infer"] | None = "infer", - names: ListLikeHashable | None = ..., + names: ListLikeHashable[Hashable] | None = ..., index_col: int | str | Sequence[str | int] | Literal[False] | None = None, usecols: UsecolsArgType[HashableT] = None, - dtype: DtypeArg | defaultdict | None = None, + dtype: DtypeArg | defaultdict[Hashable, Any] | None = None, engine: CSVEngine | None = None, converters: ( Mapping[int | str, Callable[[str], Any]] @@ -167,10 +167,10 @@ def read_csv( sep: str | None = ..., delimiter: str | None = ..., header: int | Sequence[int] | Literal["infer"] | None = ..., - names: ListLikeHashable | None = ..., + names: ListLikeHashable[Hashable] | None = ..., index_col: int | str | Sequence[str | int] | Literal[False] | None = ..., usecols: UsecolsArgType[HashableT] = ..., - dtype: DtypeArg | defaultdict | None = ..., + dtype: DtypeArg | defaultdict[Hashable, Any] | None = ..., engine: CSVEngine | None = ..., converters: ( Mapping[int | str, Callable[[str], Any]] @@ -230,10 +230,10 @@ def read_table( sep: str | None = ..., delimiter: str | None = None, header: int | Sequence[int] | Literal["infer"] | None = "infer", - names: ListLikeHashable | None = ..., + names: ListLikeHashable[Hashable] | None = ..., index_col: int | str | Sequence[str | int] | Literal[False] | None = None, usecols: UsecolsArgType[HashableT] = None, - dtype: DtypeArg | defaultdict | None = None, + dtype: DtypeArg | defaultdict[Hashable, Any] | None = None, engine: CSVEngine | None = None, converters: ( Mapping[int | str, Callable[[str], Any]] @@ -293,10 +293,10 @@ def read_table( sep: str | None = ..., delimiter: str | None = None, header: int | Sequence[int] | Literal["infer"] | None = "infer", - names: ListLikeHashable | None = ..., + names: ListLikeHashable[Hashable] | None = ..., index_col: int | str | Sequence[str | int] | Literal[False] | None = None, usecols: UsecolsArgType[HashableT] = None, - dtype: DtypeArg | defaultdict | None = None, + dtype: DtypeArg | defaultdict[Hashable, Any] | None = None, engine: CSVEngine | None = None, converters: ( Mapping[int | str, Callable[[str], Any]] @@ -356,10 +356,10 @@ def read_table( sep: str | None = ..., delimiter: str | None = None, header: int | Sequence[int] | Literal["infer"] | None = "infer", - names: ListLikeHashable | None = ..., + names: ListLikeHashable[Hashable] | None = ..., index_col: int | str | Sequence[str | int] | Literal[False] | None = None, usecols: UsecolsArgType[HashableT] = None, - dtype: DtypeArg | defaultdict | None = None, + dtype: DtypeArg | defaultdict[Hashable, Any] | None = None, engine: CSVEngine | None = None, converters: ( Mapping[int | str, Callable[[str], Any]] diff --git a/pandas-stubs/io/sql.pyi b/pandas-stubs/io/sql.pyi index 4d92623de..71dbe08cf 100644 --- a/pandas-stubs/io/sql.pyi +++ b/pandas-stubs/io/sql.pyi @@ -33,8 +33,8 @@ _SQLStatement: TypeAlias = ( str | sqlalchemy.sql.expression.Selectable | sqlalchemy.sql.expression.TextClause - | sqlalchemy.sql.Select - | FromStatement + | sqlalchemy.sql.Select[Any] + | FromStatement[Any] | sqlalchemy.sql.expression.UpdateBase ) diff --git a/pandas-stubs/io/xml.pyi b/pandas-stubs/io/xml.pyi index d76408e75..7feb7a31b 100644 --- a/pandas-stubs/io/xml.pyi +++ b/pandas-stubs/io/xml.pyi @@ -1,4 +1,7 @@ -from collections.abc import Sequence +from collections.abc import ( + Hashable, + Sequence, +) from pandas.core.frame import DataFrame @@ -25,7 +28,7 @@ def read_xml( names: Sequence[str] | None = ..., dtype: DtypeArg | None = ..., converters: ConvertersArg | None = ..., - parse_dates: ParseDatesArg | None = ..., + parse_dates: ParseDatesArg[Hashable, Hashable] | None = ..., # encoding can not be None for lxml and StringIO input encoding: str | None = ..., parser: XMLParsers = ..., diff --git a/pandas-stubs/plotting/_core.pyi b/pandas-stubs/plotting/_core.pyi index 2e0adf728..f042e6f5a 100644 --- a/pandas-stubs/plotting/_core.pyi +++ b/pandas-stubs/plotting/_core.pyi @@ -45,7 +45,7 @@ _PlotAccessorColor: TypeAlias = str | list[_SingleColor] | dict[HashableT, _Sing @overload def boxplot( data: DataFrame, - column: Hashable | ListLikeHashable, + column: Hashable | ListLikeHashable[Hashable], by: None = None, ax: Axes | None = None, fontsize: float | str | None = None, @@ -61,7 +61,7 @@ def boxplot( @overload def boxplot( data: DataFrame, - column: Hashable | ListLikeHashable, + column: Hashable | ListLikeHashable[Hashable], by: None = None, ax: Axes | None = None, fontsize: float | str | None = None, @@ -77,7 +77,7 @@ def boxplot( @overload def boxplot( data: DataFrame, - column: Hashable | ListLikeHashable, + column: Hashable | ListLikeHashable[Hashable], by: None = None, ax: Axes | None = None, fontsize: float | str | None = None, @@ -93,8 +93,8 @@ def boxplot( @overload def boxplot( data: DataFrame, - column: Hashable | ListLikeHashable, - by: Hashable | ListLikeHashable, + column: Hashable | ListLikeHashable[Hashable], + by: Hashable | ListLikeHashable[Hashable], ax: Axes | None = None, fontsize: float | str | None = None, rot: float = 0, @@ -109,8 +109,8 @@ def boxplot( @overload def boxplot( data: DataFrame, - column: Hashable | ListLikeHashable, - by: Hashable | ListLikeHashable, + column: Hashable | ListLikeHashable[Hashable], + by: Hashable | ListLikeHashable[Hashable], ax: Axes | None = None, fontsize: float | str | None = None, rot: float = 0, diff --git a/pyproject.toml b/pyproject.toml index aa25abaea..2572ee734 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -324,7 +324,6 @@ reportUnknownArgumentType = false reportUnknownLambdaType = false reportUnknownMemberType = false reportUnknownParameterType = false -reportUnknownVariableType = false reportPrivateUsage = false # enable optional checks reportMissingModuleSource = true diff --git a/tests/__init__.py b/tests/__init__.py index f11a46a34..d70428df5 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -8,6 +8,7 @@ import sys from typing import ( TYPE_CHECKING, + Any, Final, Literal, get_args, @@ -134,14 +135,19 @@ def check( if dtype is None: return actual + value: Any if isinstance(actual, pd.Series): - value = actual.iloc[index_to_check_for_type] + value = actual.iloc[ # pyright: ignore[reportUnknownVariableType] + index_to_check_for_type + ] elif isinstance(actual, pd.Index): - value = actual[index_to_check_for_type] + value = actual[ # pyright: ignore[reportUnknownVariableType] + index_to_check_for_type + ] elif isinstance(actual, BaseGroupBy): - value = actual.obj + value = actual.obj # pyright: ignore[reportUnknownVariableType] elif hasattr(actual, "__iter__"): - value = next( + value = next( # pyright: ignore[reportUnknownVariableType] iter(actual) # pyright: ignore[reportArgumentType,reportCallIssue] ) else: @@ -150,7 +156,7 @@ def check( if not isinstance(value, dtype): raise RuntimeError(f"Expected type '{dtype}' but got '{type(value)}'") - return actual + return actual # pyright: ignore[reportUnknownVariableType] def pytest_warns_bounded( @@ -160,7 +166,7 @@ def pytest_warns_bounded( upper: str | None = None, version_str: str | None = None, upper_exception: type[Exception] | None = None, -) -> AbstractContextManager: +) -> AbstractContextManager[Any, bool | None]: """ Version conditional pytest.warns context manager diff --git a/tests/arrays/test_arrays.py b/tests/arrays/test_arrays.py index fd4cca834..d48c07b47 100644 --- a/tests/arrays/test_arrays.py +++ b/tests/arrays/test_arrays.py @@ -1,11 +1,19 @@ +import sys + from pandas.core.arrays.integer import IntegerArray -from pandas.core.construction import array from typing_extensions import assert_type from pandas._libs.missing import NA from tests import check +if sys.version_info >= (3, 11): + from pandas.core.construction import array +else: + from pandas.core.construction import ( + array, # pyright: ignore[reportUnknownVariableType] + ) + def test_construction() -> None: check(assert_type(array([1]), IntegerArray), IntegerArray) diff --git a/tests/arrays/test_cumul.py b/tests/arrays/test_cumul.py index 54a2af323..21489d885 100644 --- a/tests/arrays/test_cumul.py +++ b/tests/arrays/test_cumul.py @@ -1,11 +1,19 @@ +import sys + from pandas.core.arrays.integer import IntegerArray -from pandas.core.construction import array from typing_extensions import assert_type from pandas._libs.missing import NA from tests import check +if sys.version_info >= (3, 11): + from pandas.core.construction import array +else: + from pandas.core.construction import ( + array, # pyright: ignore[reportUnknownVariableType] + ) + def test_cumul_int64dtype() -> None: arr = array([1, NA, 2]) diff --git a/tests/arrays/test_extension_array.py b/tests/arrays/test_extension_array.py index 290c30b4c..dde5573c0 100644 --- a/tests/arrays/test_extension_array.py +++ b/tests/arrays/test_extension_array.py @@ -1,4 +1,6 @@ # Test common ExtensionArray methods +import sys + import numpy as np import pandas as pd from pandas.core.arrays import ExtensionArray @@ -6,7 +8,6 @@ Int32Dtype, IntegerArray, ) -from pandas.core.construction import array from typing_extensions import assert_type from pandas._typing import ArrayLike @@ -17,6 +18,13 @@ np_1darray_intp, ) +if sys.version_info >= (3, 11): + from pandas.core.construction import array +else: + from pandas.core.construction import ( + array, # pyright: ignore[reportUnknownVariableType] + ) + def test_ea_common() -> None: # Note: `ExtensionArray` is abstract, so we use `IntegerArray` for the tests. diff --git a/tests/extension/decimal/array.py b/tests/extension/decimal/array.py index 26cccd2f5..558ca8ac1 100644 --- a/tests/extension/decimal/array.py +++ b/tests/extension/decimal/array.py @@ -175,7 +175,7 @@ def __array_ufunc__( return NotImplemented if "out" in kwargs: - return arraylike.dispatch_ufunc_with_out( # type: ignore[attr-defined] # pyright: ignore[reportAttributeAccessIssue] + return arraylike.dispatch_ufunc_with_out( # type: ignore[attr-defined] # pyright: ignore[reportAttributeAccessIssue,reportUnknownVariableType] self, ufunc, method, *inputs, **kwargs ) @@ -183,11 +183,11 @@ def __array_ufunc__( result = getattr(ufunc, method)(*inputs, **kwargs) if method == "reduce": - result = arraylike.dispatch_reduction_ufunc( # type: ignore[attr-defined] # pyright: ignore[reportAttributeAccessIssue] + result = arraylike.dispatch_reduction_ufunc( # type: ignore[attr-defined] # pyright: ignore[reportAttributeAccessIssue,reportUnknownVariableType] self, ufunc, method, *inputs, **kwargs ) if result is not NotImplemented: - return result + return result # pyright: ignore[reportUnknownVariableType] def reconstruct( x: ( @@ -202,16 +202,18 @@ def reconstruct( return DecimalArray._from_sequence(x) if ufunc.nout > 1: - return tuple(reconstruct(x) for x in result) + return tuple( + reconstruct(x) + for x in result # pyright: ignore[reportUnknownVariableType] + ) return reconstruct(result) def __getitem__(self, item: ScalarIndexer | SequenceIndexer) -> Any: if isinstance(item, numbers.Integral): return self._data[item] # array, slice. - item = check_array_indexer( - self, - item, # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] + item = check_array_indexer( # pyright: ignore[reportCallIssue,reportUnknownVariableType] + self, item # type: ignore[arg-type] # pyright: ignore[reportArgumentType] ) return type(self)(self._data[item]) @@ -343,10 +345,12 @@ def convert_values(param: Any) -> ExtensionArray | list[Any]: def value_counts(self, dropna: bool = True) -> Series: from pandas.core.algorithms import ( # type: ignore[attr-defined] # isort: skip - value_counts, # pyright: ignore[reportAttributeAccessIssue] + value_counts, # pyright: ignore[reportAttributeAccessIssue,reportAttributeAccessIssue,reportUnknownVariableType] ) - return value_counts(self.to_numpy(), dropna=dropna) + return value_counts( + self.to_numpy(), dropna=dropna + ) # pyright: ignore[reportUnknownVariableType] DecimalArray._add_arithmetic_ops() diff --git a/tests/indexes/arithmetic/bool/test_mul.py b/tests/indexes/arithmetic/bool/test_mul.py index 91986b39f..59dae6eca 100644 --- a/tests/indexes/arithmetic/bool/test_mul.py +++ b/tests/indexes/arithmetic/bool/test_mul.py @@ -41,16 +41,16 @@ def test_mul_py_scalar(left: "pd.Index[bool]") -> None: check(assert_type(left * f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left * c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[type-var] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[type-var] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b * left, "pd.Index[bool]"), pd.Index, np.bool_) check(assert_type(i * left, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(f * left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c * left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] def test_mul_py_sequence(left: "pd.Index[bool]") -> None: @@ -64,16 +64,16 @@ def test_mul_py_sequence(left: "pd.Index[bool]") -> None: check(assert_type(left * f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left * c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b * left, "pd.Index[bool]"), pd.Index, np.bool_) check(assert_type(i * left, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(f * left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c * left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] def test_mul_numpy_array(left: "pd.Index[bool]") -> None: @@ -123,13 +123,13 @@ def test_mul_pd_index(left: "pd.Index[bool]") -> None: check(assert_type(left * f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left * c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b * left, "pd.Index[bool]"), pd.Index, np.bool_) check(assert_type(i * left, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(f * left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c * left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] diff --git a/tests/indexes/arithmetic/bool/test_sub.py b/tests/indexes/arithmetic/bool/test_sub.py index 8d9551a92..c9e6d2d81 100644 --- a/tests/indexes/arithmetic/bool/test_sub.py +++ b/tests/indexes/arithmetic/bool/test_sub.py @@ -20,13 +20,13 @@ def test_sub_py_scalar() -> None: b, i, f, c = True, 1, 1.0, 1j if TYPE_CHECKING_INVALID_USAGE: - _0 = left - b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left - b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left - i, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(left - f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left - c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _1 = b - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = b - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i - left, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(f - left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c - left, "pd.Index[complex]"), pd.Index, np.complexfloating) @@ -37,13 +37,13 @@ def test_sub_py_sequence() -> None: b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] if TYPE_CHECKING_INVALID_USAGE: - _0 = left - b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left - b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left - i, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(left - f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left - c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _1 = b - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = b - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i - left, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(f - left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c - left, "pd.Index[complex]"), pd.Index, np.complexfloating) @@ -84,13 +84,13 @@ def test_sub_pd_index() -> None: c = pd.Index([1.1j, 2.2j, 4.1j]) if TYPE_CHECKING_INVALID_USAGE: - _0 = left - b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left - b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left - i, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(left - f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left - c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _1 = b - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = b - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i - left, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(f - left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c - left, "pd.Index[complex]"), pd.Index, np.complexfloating) diff --git a/tests/indexes/arithmetic/bool/test_truediv.py b/tests/indexes/arithmetic/bool/test_truediv.py index 7bb82ecbd..d1280b722 100644 --- a/tests/indexes/arithmetic/bool/test_truediv.py +++ b/tests/indexes/arithmetic/bool/test_truediv.py @@ -26,14 +26,14 @@ def test_truediv_py_scalar(left: "pd.Index[bool]") -> None: if TYPE_CHECKING_INVALID_USAGE: # TODO: python/mypy#20061 - _00 = left / b # pyright: ignore[reportOperatorIssue] + _00 = left / b # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / i, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left / f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left / c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: # TODO: python/mypy#20061 - _10 = b / left # pyright: ignore[reportOperatorIssue] + _10 = b / left # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(f / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c / left, "pd.Index[complex]"), pd.Index, np.complexfloating) @@ -45,14 +45,14 @@ def test_truediv_py_sequence(left: "pd.Index[bool]") -> None: if TYPE_CHECKING_INVALID_USAGE: # TODO: python/mypy#20061 - _00 = left / b # pyright: ignore[reportOperatorIssue] + _00 = left / b # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / i, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left / f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left / c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: # TODO: python/mypy#20061 - _10 = b / left # pyright: ignore[reportOperatorIssue] + _10 = b / left # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(f / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c / left, "pd.Index[complex]"), pd.Index, np.complexfloating) @@ -93,13 +93,13 @@ def test_truediv_pd_index(left: "pd.Index[bool]") -> None: c = pd.Index([1.1j, 2.2j, 4.1j]) if TYPE_CHECKING_INVALID_USAGE: - _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / i, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left / f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left / c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(f / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c / left, "pd.Index[complex]"), pd.Index, np.complexfloating) diff --git a/tests/indexes/arithmetic/complex/test_mul.py b/tests/indexes/arithmetic/complex/test_mul.py index 235265652..28630a499 100644 --- a/tests/indexes/arithmetic/complex/test_mul.py +++ b/tests/indexes/arithmetic/complex/test_mul.py @@ -41,16 +41,16 @@ def test_mul_py_scalar(left: "pd.Index[complex]") -> None: check(assert_type(left * f, "pd.Index[complex]"), pd.Index, np.complexfloating) check(assert_type(left * c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b * left, "pd.Index[complex]"), pd.Index, np.complexfloating) check(assert_type(i * left, "pd.Index[complex]"), pd.Index, np.complexfloating) check(assert_type(f * left, "pd.Index[complex]"), pd.Index, np.complexfloating) check(assert_type(c * left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] def test_mul_py_sequence(left: "pd.Index[complex]") -> None: @@ -64,16 +64,16 @@ def test_mul_py_sequence(left: "pd.Index[complex]") -> None: check(assert_type(left * f, "pd.Index[complex]"), pd.Index, np.complexfloating) check(assert_type(left * c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b * left, "pd.Index[complex]"), pd.Index, np.complexfloating) check(assert_type(i * left, "pd.Index[complex]"), pd.Index, np.complexfloating) check(assert_type(f * left, "pd.Index[complex]"), pd.Index, np.complexfloating) check(assert_type(c * left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] def test_mul_numpy_array(left: "pd.Index[complex]") -> None: @@ -125,13 +125,13 @@ def test_mul_pd_index(left: "pd.Index[complex]") -> None: check(assert_type(left * f, "pd.Index[complex]"), pd.Index, np.complexfloating) check(assert_type(left * c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b * left, "pd.Index[complex]"), pd.Index, np.complexfloating) check(assert_type(i * left, "pd.Index[complex]"), pd.Index, np.complexfloating) check(assert_type(f * left, "pd.Index[complex]"), pd.Index, np.complexfloating) check(assert_type(c * left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] diff --git a/tests/indexes/arithmetic/float/test_floordiv.py b/tests/indexes/arithmetic/float/test_floordiv.py index 78693a0a8..ee0a9ef32 100644 --- a/tests/indexes/arithmetic/float/test_floordiv.py +++ b/tests/indexes/arithmetic/float/test_floordiv.py @@ -38,16 +38,16 @@ def test_floordiv_py_scalar(left: "pd.Index[float]") -> None: check(assert_type(left // i, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left // f, "pd.Index[float]"), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b // left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(i // left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(f // left, "pd.Index[float]"), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) @@ -61,16 +61,16 @@ def test_floordiv_py_sequence(left: "pd.Index[float]") -> None: check(assert_type(left // i, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left // f, "pd.Index[float]"), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b // left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(i // left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(f // left, "pd.Index[float]"), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] # check(assert_type(d // left, pd.Index), pd.Index, timedelta) TODO: pandas-dev/pandas#63007 @@ -122,14 +122,14 @@ def test_floordiv_pd_index(left: "pd.Index[float]") -> None: check(assert_type(left // i, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left // f, "pd.Index[float]"), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b // left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(i // left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(f // left, "pd.Index[float]"), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) diff --git a/tests/indexes/arithmetic/float/test_mul.py b/tests/indexes/arithmetic/float/test_mul.py index b255f874f..f5b9058aa 100644 --- a/tests/indexes/arithmetic/float/test_mul.py +++ b/tests/indexes/arithmetic/float/test_mul.py @@ -41,7 +41,7 @@ def test_mul_py_scalar(left: "pd.Index[float]") -> None: check(assert_type(left * f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left * c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * d, "pd.TimedeltaIndex"), pd.TimedeltaIndex, timedelta) check(assert_type(b * left, "pd.Index[float]"), pd.Index, np.floating) @@ -49,7 +49,7 @@ def test_mul_py_scalar(left: "pd.Index[float]") -> None: check(assert_type(f * left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c * left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d * left, "pd.TimedeltaIndex"), pd.TimedeltaIndex, timedelta) @@ -64,16 +64,16 @@ def test_mul_py_sequence(left: "pd.Index[float]") -> None: check(assert_type(left * f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left * c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b * left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(i * left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(f * left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c * left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] def test_mul_numpy_array(left: "pd.Index[float]") -> None: @@ -127,7 +127,7 @@ def test_mul_pd_index(left: "pd.Index[float]") -> None: check(assert_type(left * f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left * c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * d, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(b * left, "pd.Index[float]"), pd.Index, np.floating) @@ -135,5 +135,5 @@ def test_mul_pd_index(left: "pd.Index[float]") -> None: check(assert_type(f * left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c * left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d * left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) diff --git a/tests/indexes/arithmetic/float/test_truediv.py b/tests/indexes/arithmetic/float/test_truediv.py index 5840191c2..e9156ab0c 100644 --- a/tests/indexes/arithmetic/float/test_truediv.py +++ b/tests/indexes/arithmetic/float/test_truediv.py @@ -36,15 +36,15 @@ def test_truediv_py_scalar(left: "pd.Index[float]") -> None: check(assert_type(left / f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left / c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(i / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(f / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c / left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) @@ -59,15 +59,15 @@ def test_truediv_py_sequence(left: "pd.Index[float]") -> None: check(assert_type(left / f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left / c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(i / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(f / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c / left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, pd.Index), pd.Index, timedelta) @@ -113,10 +113,10 @@ def test_truediv_pd_scalar(left: "pd.Index[float]") -> None: s, d = pd.Timestamp(2025, 9, 24), pd.Timedelta(seconds=1) if TYPE_CHECKING_INVALID_USAGE: - _00 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _01 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _01 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] - _10 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) @@ -134,13 +134,13 @@ def test_truediv_pd_index(left: "pd.Index[float]") -> None: check(assert_type(left / f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left / c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(i / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(f / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c / left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) diff --git a/tests/indexes/arithmetic/int/test_floordiv.py b/tests/indexes/arithmetic/int/test_floordiv.py index cb2a61bbe..46b4b9f8c 100644 --- a/tests/indexes/arithmetic/int/test_floordiv.py +++ b/tests/indexes/arithmetic/int/test_floordiv.py @@ -38,16 +38,16 @@ def test_floordiv_py_scalar(left: "pd.Index[int]") -> None: check(assert_type(left // i, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(left // f, "pd.Index[float]"), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b // left, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(i // left, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(f // left, "pd.Index[float]"), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) @@ -61,16 +61,16 @@ def test_floordiv_py_sequence(left: "pd.Index[int]") -> None: check(assert_type(left // i, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(left // f, "pd.Index[float]"), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b // left, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(i // left, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(f // left, "pd.Index[float]"), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, pd.Index), pd.Index, timedelta) @@ -122,14 +122,14 @@ def test_floordiv_pd_index(left: "pd.Index[int]") -> None: check(assert_type(left // i, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(left // f, "pd.Index[float]"), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b // left, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(i // left, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(f // left, "pd.Index[float]"), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) diff --git a/tests/indexes/arithmetic/int/test_mul.py b/tests/indexes/arithmetic/int/test_mul.py index 42cbf7cea..d34169d79 100644 --- a/tests/indexes/arithmetic/int/test_mul.py +++ b/tests/indexes/arithmetic/int/test_mul.py @@ -41,7 +41,7 @@ def test_mul_py_scalar(left: "pd.Index[int]") -> None: check(assert_type(left * f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left * c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * d, pd.TimedeltaIndex), pd.Index, pd.Timedelta) check(assert_type(b * left, "pd.Index[int]"), pd.Index, np.integer) @@ -49,7 +49,7 @@ def test_mul_py_scalar(left: "pd.Index[int]") -> None: check(assert_type(f * left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c * left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d * left, pd.TimedeltaIndex), pd.Index, pd.Timedelta) @@ -64,16 +64,16 @@ def test_mul_py_sequence(left: "pd.Index[int]") -> None: check(assert_type(left * f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left * c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b * left, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(i * left, "pd.Index[int]"), pd.Index, np.integer) check(assert_type(f * left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c * left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] def test_mul_numpy_array(left: "pd.Index[int]") -> None: @@ -123,7 +123,7 @@ def test_mul_pd_index(left: "pd.Index[int]") -> None: check(assert_type(left * f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left * c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * d, pd.TimedeltaIndex), pd.Index, pd.Timedelta) check(assert_type(b * left, "pd.Index[int]"), pd.Index, np.integer) @@ -131,5 +131,5 @@ def test_mul_pd_index(left: "pd.Index[int]") -> None: check(assert_type(f * left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c * left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d * left, pd.TimedeltaIndex), pd.Index, pd.Timedelta) diff --git a/tests/indexes/arithmetic/int/test_truediv.py b/tests/indexes/arithmetic/int/test_truediv.py index 9775359e6..72a7489bf 100644 --- a/tests/indexes/arithmetic/int/test_truediv.py +++ b/tests/indexes/arithmetic/int/test_truediv.py @@ -36,15 +36,15 @@ def test_truediv_py_scalar(left: "pd.Index[int]") -> None: check(assert_type(left / f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left / c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(i / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(f / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c / left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) @@ -59,15 +59,15 @@ def test_truediv_py_sequence(left: "pd.Index[int]") -> None: check(assert_type(left / f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left / c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(i / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(f / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c / left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, pd.Index), pd.Index, timedelta) @@ -113,10 +113,10 @@ def test_truediv_pd_scalar(left: "pd.Index[int]") -> None: s, d = pd.Timestamp(2025, 9, 24), pd.Timedelta(seconds=1) if TYPE_CHECKING_INVALID_USAGE: - _00 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _01 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _01 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] - _10 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) @@ -134,13 +134,13 @@ def test_truediv_pd_index(left: "pd.Index[int]") -> None: check(assert_type(left / f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left / c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(i / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(f / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c / left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) diff --git a/tests/indexes/arithmetic/str/test_add.py b/tests/indexes/arithmetic/str/test_add.py index 7d7fbab02..f490f81b0 100644 --- a/tests/indexes/arithmetic/str/test_add.py +++ b/tests/indexes/arithmetic/str/test_add.py @@ -26,11 +26,11 @@ def test_add_py_scalar() -> None: r0 = "right" if TYPE_CHECKING_INVALID_USAGE: - _0 = left + i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left + i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left + r0, "pd.Index[str]"), pd.Index, str) if TYPE_CHECKING_INVALID_USAGE: - _1 = i + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = i + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(r0 + left, "pd.Index[str]"), pd.Index, str) @@ -41,12 +41,12 @@ def test_add_py_sequence() -> None: r1 = tuple(r0) if TYPE_CHECKING_INVALID_USAGE: - _0 = left + i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left + i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left + r0, "pd.Index[str]"), pd.Index, str) check(assert_type(left + r1, "pd.Index[str]"), pd.Index, str) if TYPE_CHECKING_INVALID_USAGE: - _1 = i + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = i + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(r0 + left, "pd.Index[str]"), pd.Index, str) check(assert_type(r1 + left, "pd.Index[str]"), pd.Index, str) @@ -83,9 +83,9 @@ def test_add_pd_index() -> None: r0 = pd.Index(["a", "bc", "def"]) if TYPE_CHECKING_INVALID_USAGE: - _0 = left + i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left + i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left + r0, "pd.Index[str]"), pd.Index, str) if TYPE_CHECKING_INVALID_USAGE: - _1 = i + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = i + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(r0 + left, "pd.Index[str]"), pd.Index, str) diff --git a/tests/indexes/arithmetic/str/test_mul.py b/tests/indexes/arithmetic/str/test_mul.py index 80852280a..d6a664216 100644 --- a/tests/indexes/arithmetic/str/test_mul.py +++ b/tests/indexes/arithmetic/str/test_mul.py @@ -37,22 +37,22 @@ def test_mul_py_scalar(left: "pd.Index[str]") -> None: s, d = datetime(2025, 9, 27), timedelta(seconds=1) if TYPE_CHECKING_INVALID_USAGE: - _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * i, "pd.Index[str]"), pd.Index, str) if TYPE_CHECKING_INVALID_USAGE: - _02 = left * f # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _02 = left * f # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: - _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i * left, "pd.Index[str]"), pd.Index, str) if TYPE_CHECKING_INVALID_USAGE: - _12 = f * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _12 = f * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] def test_mul_py_sequence(left: "pd.Index[str]") -> None: @@ -62,22 +62,22 @@ def test_mul_py_sequence(left: "pd.Index[str]") -> None: d = [timedelta(seconds=s + 1) for s in range(3)] if TYPE_CHECKING_INVALID_USAGE: - _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * i, "pd.Index[str]"), pd.Index, str) if TYPE_CHECKING_INVALID_USAGE: - _02 = left * f # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _02 = left * f # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: - _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i * left, "pd.Index[str]"), pd.Index, str) if TYPE_CHECKING_INVALID_USAGE: - _12 = f * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _12 = f * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] def test_mul_numpy_array(left: "pd.Index[str]") -> None: @@ -121,19 +121,19 @@ def test_mul_pd_index(left: "pd.Index[str]") -> None: d = pd.Index([timedelta(seconds=s + 1) for s in range(3)]) if TYPE_CHECKING_INVALID_USAGE: - _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * i, "pd.Index[str]"), pd.Index, str) if TYPE_CHECKING_INVALID_USAGE: - _02 = left * f # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _02 = left * f # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: - _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i * left, "pd.Index[str]"), pd.Index, str) if TYPE_CHECKING_INVALID_USAGE: - _12 = f * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _12 = f * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] diff --git a/tests/indexes/arithmetic/test_floordiv.py b/tests/indexes/arithmetic/test_floordiv.py index 4b56ec51c..e1884bd05 100644 --- a/tests/indexes/arithmetic/test_floordiv.py +++ b/tests/indexes/arithmetic/test_floordiv.py @@ -34,16 +34,16 @@ def test_floordiv_py_scalar(left_i: pd.Index) -> None: check(assert_type(left_i // i, pd.Index), pd.Index, np.integer) check(assert_type(left_i // f, pd.Index), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left_i // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left_i // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left_i // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left_i // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left_i // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left_i // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b // left_i, pd.Index), pd.Index, np.integer) check(assert_type(i // left_i, pd.Index), pd.Index, np.integer) check(assert_type(f // left_i, pd.Index), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left_i, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) @@ -57,16 +57,16 @@ def test_floordiv_py_sequence(left_i: pd.Index) -> None: check(assert_type(left_i // i, pd.Index), pd.Index, np.integer) check(assert_type(left_i // f, pd.Index), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left_i // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left_i // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left_i // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left_i // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left_i // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left_i // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b // left_i, pd.Index), pd.Index, np.integer) check(assert_type(i // left_i, pd.Index), pd.Index, np.integer) check(assert_type(f // left_i, pd.Index), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left_i, pd.Index), pd.Index, timedelta) @@ -130,14 +130,14 @@ def test_floordiv_pd_index(left_i: pd.Index) -> None: check(assert_type(left_i // i, pd.Index), pd.Index, np.integer) check(assert_type(left_i // f, pd.Index), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left_i // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left_i // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left_i // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left_i // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left_i // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left_i // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b // left_i, pd.Index), pd.Index, np.integer) check(assert_type(i // left_i, pd.Index), pd.Index, np.integer) check(assert_type(f // left_i, pd.Index), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left_i, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) diff --git a/tests/indexes/arithmetic/test_mul.py b/tests/indexes/arithmetic/test_mul.py index 24eb5d50f..45687f799 100644 --- a/tests/indexes/arithmetic/test_mul.py +++ b/tests/indexes/arithmetic/test_mul.py @@ -108,5 +108,5 @@ def test_mul_str_py_str(left_i: pd.Index) -> None: s = "abc" if TYPE_CHECKING_INVALID_USAGE: - _0 = left_i * s # type: ignore[operator] # pyright:ignore[reportOperatorIssue] - _1 = s * left_i # type: ignore[operator] # pyright:ignore[reportOperatorIssue] + _0 = left_i * s # type: ignore[operator] # pyright:ignore[reportOperatorIssue,reportUnknownVariableType] + _1 = s * left_i # type: ignore[operator] # pyright:ignore[reportOperatorIssue,reportUnknownVariableType] diff --git a/tests/indexes/arithmetic/test_sub.py b/tests/indexes/arithmetic/test_sub.py index 98ee8b8b5..84b96d87a 100644 --- a/tests/indexes/arithmetic/test_sub.py +++ b/tests/indexes/arithmetic/test_sub.py @@ -103,5 +103,5 @@ def test_sub_str_py_str() -> None: s = "abc" if TYPE_CHECKING_INVALID_USAGE: - _0 = left_i - s # type: ignore[operator] # pyright:ignore[reportOperatorIssue] - _1 = s - left_i # type: ignore[operator] # pyright:ignore[reportOperatorIssue] + _0 = left_i - s # type: ignore[operator] # pyright:ignore[reportOperatorIssue,reportUnknownVariableType] + _1 = s - left_i # type: ignore[operator] # pyright:ignore[reportOperatorIssue,reportUnknownVariableType] diff --git a/tests/indexes/arithmetic/test_truediv.py b/tests/indexes/arithmetic/test_truediv.py index 3a6432912..c6102d346 100644 --- a/tests/indexes/arithmetic/test_truediv.py +++ b/tests/indexes/arithmetic/test_truediv.py @@ -131,5 +131,5 @@ def test_truediv_str_py_str(left_i: pd.Index) -> None: s = "abc" if TYPE_CHECKING_INVALID_USAGE: - _0 = left_i / s # type: ignore[operator] # pyright:ignore[reportOperatorIssue] - _1 = s / left_i # type: ignore[operator] # pyright:ignore[reportOperatorIssue] + _0 = left_i / s # type: ignore[operator] # pyright:ignore[reportOperatorIssue,reportUnknownVariableType] + _1 = s / left_i # type: ignore[operator] # pyright:ignore[reportOperatorIssue,reportUnknownVariableType] diff --git a/tests/indexes/arithmetic/timedeltaindex/test_floordiv.py b/tests/indexes/arithmetic/timedeltaindex/test_floordiv.py index 9b395f0a8..b7d98708a 100644 --- a/tests/indexes/arithmetic/timedeltaindex/test_floordiv.py +++ b/tests/indexes/arithmetic/timedeltaindex/test_floordiv.py @@ -34,20 +34,20 @@ def test_floordiv_py_scalar(left: pd.TimedeltaIndex) -> None: s, d = datetime(2025, 9, 24), timedelta(seconds=1) if TYPE_CHECKING_INVALID_USAGE: - _00 = left // b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left // b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left // i, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(left // f, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left // d, "pd.Index[int]"), pd.Index, np.integer) if TYPE_CHECKING_INVALID_USAGE: - _10 = b // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _11 = i // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _12 = f // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _11 = i // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _12 = f // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, "pd.Index[int]"), pd.Index, np.integer) @@ -57,12 +57,12 @@ def test_floordiv_py_sequence(left: pd.TimedeltaIndex) -> None: s, d = [datetime(2025, 9, 24)], [timedelta(seconds=1)] if TYPE_CHECKING_INVALID_USAGE: - _00 = left // b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left // b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left // i, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(left // f, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] # TODO: pandas-dev/pandas#62552 switch to np.integer after Pandas 3.0 check( assert_type(left // d, "pd.Index[int]"), @@ -71,11 +71,11 @@ def test_floordiv_py_sequence(left: pd.TimedeltaIndex) -> None: ) if TYPE_CHECKING_INVALID_USAGE: - _10 = b // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _11 = i // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _12 = f // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _11 = i // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _12 = f // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, "pd.Index[int]"), pd.Index, np.integer) @@ -114,11 +114,11 @@ def test_floordiv_pd_scalar(left: pd.TimedeltaIndex) -> None: s, d = pd.Timestamp(2025, 9, 24), pd.Timedelta(seconds=1) if TYPE_CHECKING_INVALID_USAGE: - _00 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left // d, "pd.Index[int]"), pd.Index, np.integer) if TYPE_CHECKING_INVALID_USAGE: - _10 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, "pd.Index[int]"), pd.Index, np.integer) @@ -131,18 +131,18 @@ def test_floordiv_pd_index(left: pd.TimedeltaIndex) -> None: s, d = pd.Index([datetime(2025, 9, 24)]), pd.Index([timedelta(seconds=1)]) if TYPE_CHECKING_INVALID_USAGE: - _00 = left // b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left // b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left // i, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(left // f, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left // d, "pd.Index[int]"), pd.Index, np.integer) if TYPE_CHECKING_INVALID_USAGE: - _10 = b // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _11 = i // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _12 = f // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _11 = i // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _12 = f // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, "pd.Index[int]"), pd.Index, np.integer) diff --git a/tests/indexes/arithmetic/timedeltaindex/test_mul.py b/tests/indexes/arithmetic/timedeltaindex/test_mul.py index 170a81b73..1c88827aa 100644 --- a/tests/indexes/arithmetic/timedeltaindex/test_mul.py +++ b/tests/indexes/arithmetic/timedeltaindex/test_mul.py @@ -29,18 +29,18 @@ def test_mul_py_scalar(left: pd.TimedeltaIndex) -> None: b, i, f, c = True, 1, 1.0, 1j if TYPE_CHECKING_INVALID_USAGE: - _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * i, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(left * f, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: - _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i * left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(f * left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] def test_mul_py_sequence(left: pd.TimedeltaIndex) -> None: @@ -48,18 +48,18 @@ def test_mul_py_sequence(left: pd.TimedeltaIndex) -> None: b, i, f, c = [True], [2], [1.5], [1.7j] if TYPE_CHECKING_INVALID_USAGE: - _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * i, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(left * f, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: - _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i * left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(f * left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] def test_mul_numpy_array(left: pd.TimedeltaIndex) -> None: @@ -100,15 +100,15 @@ def test_mul_pd_index(left: pd.TimedeltaIndex) -> None: c = pd.Index([1.7j]) if TYPE_CHECKING_INVALID_USAGE: - _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * i, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(left * f, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: - _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i * left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(f * left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] diff --git a/tests/indexes/arithmetic/timedeltaindex/test_truediv.py b/tests/indexes/arithmetic/timedeltaindex/test_truediv.py index 16b5f216e..f26826cdb 100644 --- a/tests/indexes/arithmetic/timedeltaindex/test_truediv.py +++ b/tests/indexes/arithmetic/timedeltaindex/test_truediv.py @@ -32,20 +32,20 @@ def test_truediv_py_scalar(left: pd.TimedeltaIndex) -> None: s, d = datetime(2025, 9, 24), timedelta(seconds=1) if TYPE_CHECKING_INVALID_USAGE: - _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / i, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(left / f, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left / c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left / c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / d, "pd.Index[float]"), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _11 = i / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _12 = f / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _11 = i / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _12 = f / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, "pd.Index[float]"), pd.Index, np.floating) @@ -55,20 +55,20 @@ def test_truediv_py_sequence(left: pd.TimedeltaIndex) -> None: s, d = [datetime(2025, 9, 24)], [timedelta(seconds=1)] if TYPE_CHECKING_INVALID_USAGE: - _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / i, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(left / f, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left / c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left / c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / d, "pd.Index[float]"), pd.Index, float) if TYPE_CHECKING_INVALID_USAGE: - _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _11 = i / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _12 = f / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _11 = i / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _12 = f / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, "pd.Index[float]"), pd.Index, np.floating) @@ -107,11 +107,11 @@ def test_truediv_pd_scalar(left: pd.TimedeltaIndex) -> None: s, d = pd.Timestamp(2025, 9, 24), pd.Timedelta(seconds=1) if TYPE_CHECKING_INVALID_USAGE: - _0 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / d, "pd.Index[float]"), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _1 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, "pd.Index[float]"), pd.Index, np.floating) @@ -124,18 +124,18 @@ def test_truediv_pd_index(left: pd.TimedeltaIndex) -> None: s, d = pd.Index([datetime(2025, 9, 24)]), pd.Index([timedelta(seconds=1)]) if TYPE_CHECKING_INVALID_USAGE: - _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / i, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(left / f, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left / c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left / c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / d, "pd.Index[float]"), pd.Index, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _11 = i / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _12 = f / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _11 = i / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _12 = f / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, "pd.Index[float]"), pd.Index, np.floating) diff --git a/tests/scalars/test_scalars.py b/tests/scalars/test_scalars.py index fc441af48..0ed5aa2b5 100644 --- a/tests/scalars/test_scalars.py +++ b/tests/scalars/test_scalars.py @@ -41,7 +41,7 @@ ) if not PD_LTE_23: - from pandas.errors import Pandas4Warning # type: ignore[attr-defined] # pyright: ignore[reportAttributeAccessIssue,reportRedeclaration] # isort: skip + from pandas.errors import Pandas4Warning # type: ignore[attr-defined] # pyright: ignore[reportAttributeAccessIssue,reportRedeclaration,reportUnknownVariableType] # isort: skip else: Pandas4Warning: TypeAlias = FutureWarning # type: ignore[no-redef] @@ -291,14 +291,23 @@ def test_interval_math() -> None: ) if TYPE_CHECKING_INVALID_USAGE: - _i = interval_i - pd.Interval(1, 2) # type: ignore[type-var] # pyright: ignore[reportOperatorIssue] - _f = interval_f - pd.Interval(1.0, 2.0) # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _ts = interval_ts - pd.Interval( # type: ignore[operator] - pd.Timestamp(2025, 9, 29), pd.Timestamp(2025, 9, 30), closed="both" - ) # pyright: ignore[reportOperatorIssue] - _td = interval_td - pd.Interval( # type: ignore[operator] - pd.Timedelta(1, "ns"), pd.Timedelta(2, "ns") - ) # pyright: ignore[reportOperatorIssue] + _i = interval_i - pd.Interval(1, 2) # type: ignore[type-var] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _f = interval_f - pd.Interval(1.0, 2.0) # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + # TODO: psf/black#4880 + # fmt: off + _ts = ( # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + interval_ts + - pd.Interval( # type: ignore[operator] + pd.Timestamp(2025, 9, 29), pd.Timestamp(2025, 9, 30), closed="both" + ) + ) + _td = ( # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + interval_td + - pd.Interval( # type: ignore[operator] + pd.Timedelta(1, "ns"), pd.Timedelta(2, "ns") + ) + ) + # fmt: on def test_interval_cmp() -> None: @@ -572,14 +581,14 @@ def test_timedelta_add_sub() -> None: # TypeError: as_period, as_timestamp, as_datetime, as_date, as_datetime64, # as_period_index, as_datetime_index, as_ndarray_dt64 if TYPE_CHECKING_INVALID_USAGE: - _0 = td - as_period # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _1 = td - as_timestamp # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _2 = td - as_datetime # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _3 = td - as_date # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _4 = td - as_datetime64 # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _5 = td - as_period_index # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _6 = td - as_datetime_index # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _7 = td - as_ndarray_dt64 # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = td - as_period # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _1 = td - as_timestamp # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _2 = td - as_datetime # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _3 = td - as_date # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _4 = td - as_datetime64 # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _5 = td - as_period_index # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _6 = td - as_datetime_index # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _7 = td - as_ndarray_dt64 # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(td - td, pd.Timedelta), pd.Timedelta) check(assert_type(td - as_dt_timedelta, pd.Timedelta), pd.Timedelta) @@ -652,10 +661,10 @@ def test_timedelta_mul_div() -> None: # TypeError: md_int, md_float, md_ndarray_intp, md_ndarray_float, mp_series_int, # mp_series_float, md_int64_index, md_float_index if TYPE_CHECKING_INVALID_USAGE: - _00 = md_int // td # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _01 = md_float // td # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _02 = md_ndarray_intp // td # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _03 = md_ndarray_float // td # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = md_int // td # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _01 = md_float // td # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _02 = md_ndarray_intp // td # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _03 = md_ndarray_float // td # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(td / td, float), float) check(assert_type(td / pd.NaT, float), float) @@ -669,10 +678,10 @@ def test_timedelta_mul_div() -> None: # TypeError: md_int, md_float, md_ndarray_intp, md_ndarray_float, mp_series_int, # mp_series_float, md_int64_index, md_float_index if TYPE_CHECKING_INVALID_USAGE: - _10 = md_int / td # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _11 = md_float / td # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _12 = md_ndarray_intp / td # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = md_ndarray_float / td # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = md_int / td # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _11 = md_float / td # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _12 = md_ndarray_intp / td # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = md_ndarray_float / td # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] def test_timedelta_mod_abs_unary() -> None: diff --git a/tests/scalars/timedelta/test_arithmetic.py b/tests/scalars/timedelta/test_arithmetic.py index e401ae032..2894f4e41 100644 --- a/tests/scalars/timedelta/test_arithmetic.py +++ b/tests/scalars/timedelta/test_arithmetic.py @@ -24,7 +24,7 @@ def test_mul() -> None: if TYPE_CHECKING_INVALID_USAGE: # pd.Timedelta * bool is not allowed, see GH1418 - _0 = a * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _1 = b * a # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _2 = a * e # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _3 = e * a # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = a * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _1 = b * a # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _2 = a * e # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _3 = e * a # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] diff --git a/tests/series/arithmetic/bool/test_mul.py b/tests/series/arithmetic/bool/test_mul.py index 63402bf59..5dfc6c879 100644 --- a/tests/series/arithmetic/bool/test_mul.py +++ b/tests/series/arithmetic/bool/test_mul.py @@ -41,16 +41,16 @@ def test_mul_py_scalar(left: "pd.Series[bool]") -> None: check(assert_type(left * f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[type-var] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[type-var] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b * left, "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(i * left, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(f * left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left.mul(b), "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(left.mul(i), "pd.Series[int]"), pd.Series, np.integer) @@ -82,16 +82,16 @@ def test_mul_py_sequence(left: "pd.Series[bool]") -> None: check(assert_type(left * f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b * left, "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(i * left, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(f * left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left.mul(b), "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(left.mul(i), "pd.Series[int]"), pd.Series, np.integer) @@ -177,16 +177,16 @@ def test_mul_pd_index(left: "pd.Series[bool]") -> None: check(assert_type(left * f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b * left, "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(i * left, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(f * left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left.mul(b), "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(left.mul(i), "pd.Series[int]"), pd.Series, np.integer) @@ -221,16 +221,16 @@ def test_mul_pd_series(left: "pd.Series[bool]") -> None: check(assert_type(left * f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b * left, "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(i * left, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(f * left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left.mul(b), "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(left.mul(i), "pd.Series[int]"), pd.Series, np.integer) diff --git a/tests/series/arithmetic/bool/test_sub.py b/tests/series/arithmetic/bool/test_sub.py index b1724b7af..fb1090537 100644 --- a/tests/series/arithmetic/bool/test_sub.py +++ b/tests/series/arithmetic/bool/test_sub.py @@ -20,13 +20,13 @@ def test_sub_py_scalar() -> None: b, i, f, c = True, 1, 1.0, 1j if TYPE_CHECKING_INVALID_USAGE: - _0 = left - b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left - b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left - i, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(left - f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _1 = b - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = b - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i - left, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(f - left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c - left, "pd.Series[complex]"), pd.Series, np.complexfloating) @@ -51,13 +51,13 @@ def test_sub_py_sequence() -> None: b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] if TYPE_CHECKING_INVALID_USAGE: - _0 = left - b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left - b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left - i, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(left - f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _1 = b - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = b - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i - left, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(f - left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c - left, "pd.Series[complex]"), pd.Series, np.complexfloating) @@ -126,13 +126,13 @@ def test_sub_pd_index() -> None: c = pd.Index([1.1j, 2.2j, 4.1j]) if TYPE_CHECKING_INVALID_USAGE: - _0 = left - b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left - b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left - i, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(left - f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _1 = b - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = b - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i - left, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(f - left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c - left, "pd.Series[complex]"), pd.Series, np.complexfloating) @@ -160,13 +160,13 @@ def test_sub_pd_series() -> None: c = pd.Series([1.1j, 2.2j, 4.1j]) if TYPE_CHECKING_INVALID_USAGE: - _0 = left - b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left - b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left - i, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(left - f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _1 = b - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = b - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i - left, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(f - left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c - left, "pd.Series[complex]"), pd.Series, np.complexfloating) diff --git a/tests/series/arithmetic/bool/test_truediv.py b/tests/series/arithmetic/bool/test_truediv.py index b4429cf32..ad68bb121 100644 --- a/tests/series/arithmetic/bool/test_truediv.py +++ b/tests/series/arithmetic/bool/test_truediv.py @@ -26,14 +26,14 @@ def test_truediv_py_scalar(left: "pd.Series[bool]") -> None: if TYPE_CHECKING_INVALID_USAGE: # TODO: python/mypy#20061 - _00 = left / b # pyright: ignore[reportOperatorIssue] + _00 = left / b # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: # TODO: python/mypy#20061 - _10 = b / left # pyright: ignore[reportOperatorIssue] + _10 = b / left # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) @@ -83,14 +83,14 @@ def test_truediv_py_sequence(left: "pd.Series[bool]") -> None: if TYPE_CHECKING_INVALID_USAGE: # TODO: python/mypy#20061 - _00 = left / b # pyright: ignore[reportOperatorIssue] + _00 = left / b # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: # TODO: python/mypy#20061 - _10 = b / left # pyright: ignore[reportOperatorIssue] + _10 = b / left # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) @@ -195,13 +195,13 @@ def test_truediv_pd_index(left: "pd.Series[bool]") -> None: c = pd.Index([1.1j, 2.2j, 4.1j]) if TYPE_CHECKING_INVALID_USAGE: - _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) @@ -249,13 +249,13 @@ def test_truediv_pd_series(left: "pd.Series[bool]") -> None: c = pd.Series([1.1j, 2.2j, 4.1j]) if TYPE_CHECKING_INVALID_USAGE: - _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) diff --git a/tests/series/arithmetic/complex/test_mul.py b/tests/series/arithmetic/complex/test_mul.py index dc955f641..b7b1e9c1c 100644 --- a/tests/series/arithmetic/complex/test_mul.py +++ b/tests/series/arithmetic/complex/test_mul.py @@ -41,16 +41,16 @@ def test_mul_py_scalar(left: "pd.Series[complex]") -> None: check(assert_type(left * f, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b * left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(i * left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(f * left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left.mul(b), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.mul(i), "pd.Series[complex]"), pd.Series, np.complexfloating) @@ -88,16 +88,16 @@ def test_mul_py_sequence(left: "pd.Series[complex]") -> None: check(assert_type(left * f, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b * left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(i * left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(f * left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left.mul(b), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.mul(i), "pd.Series[complex]"), pd.Series, np.complexfloating) @@ -197,16 +197,16 @@ def test_mul_pd_index(left: "pd.Series[complex]") -> None: check(assert_type(left * f, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b * left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(i * left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(f * left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left.mul(b), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.mul(i), "pd.Series[complex]"), pd.Series, np.complexfloating) @@ -247,16 +247,16 @@ def test_mul_pd_series(left: "pd.Series[complex]") -> None: check(assert_type(left * f, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b * left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(i * left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(f * left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left.mul(b), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.mul(i), "pd.Series[complex]"), pd.Series, np.complexfloating) diff --git a/tests/series/arithmetic/float/test_floordiv.py b/tests/series/arithmetic/float/test_floordiv.py index 436377adb..f7587cf19 100644 --- a/tests/series/arithmetic/float/test_floordiv.py +++ b/tests/series/arithmetic/float/test_floordiv.py @@ -37,16 +37,16 @@ def test_floordiv_py_scalar(left: "pd.Series[float]") -> None: check(assert_type(left // i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left // f, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b // left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i // left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f // left, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.floordiv(b), "pd.Series[float]"), pd.Series, np.floating) @@ -80,16 +80,16 @@ def test_floordiv_py_sequence(left: "pd.Series[float]") -> None: check(assert_type(left // i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left // f, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b // left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i // left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f // left, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] # check(assert_type(d // left, pd.Series), pd.Series, timedelta) TODO: uncomment after pandas-dev/pandas#63007 check(assert_type(left.floordiv(b), "pd.Series[float]"), pd.Series, np.floating) @@ -177,16 +177,16 @@ def test_floordiv_pd_index(left: "pd.Series[float]") -> None: check(assert_type(left // i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left // f, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b // left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i // left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f // left, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.floordiv(b), "pd.Series[float]"), pd.Series, np.floating) @@ -223,16 +223,16 @@ def test_floordiv_pd_series(left: "pd.Series[float]") -> None: check(assert_type(left // i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left // f, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b // left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i // left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f // left, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.floordiv(b), "pd.Series[float]"), pd.Series, np.floating) diff --git a/tests/series/arithmetic/float/test_mul.py b/tests/series/arithmetic/float/test_mul.py index 8e56d10f5..75fdf85b5 100644 --- a/tests/series/arithmetic/float/test_mul.py +++ b/tests/series/arithmetic/float/test_mul.py @@ -41,7 +41,7 @@ def test_mul_py_scalar(left: "pd.Series[float]") -> None: check(assert_type(left * f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * d, "pd.Series[pd.Timedelta]"), pd.Series, timedelta) check(assert_type(b * left, "pd.Series[float]"), pd.Series, np.floating) @@ -49,7 +49,7 @@ def test_mul_py_scalar(left: "pd.Series[float]") -> None: check(assert_type(f * left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d * left, "pd.Series[pd.Timedelta]"), pd.Series, timedelta) check(assert_type(left.mul(b), "pd.Series[float]"), pd.Series, np.floating) @@ -82,7 +82,7 @@ def test_mul_py_sequence(left: "pd.Series[float]") -> None: check(assert_type(left * f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * d, "pd.Series[pd.Timedelta]"), pd.Series, timedelta) check(assert_type(b * left, "pd.Series[float]"), pd.Series, np.floating) @@ -90,7 +90,7 @@ def test_mul_py_sequence(left: "pd.Series[float]") -> None: check(assert_type(f * left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d * left, "pd.Series[pd.Timedelta]"), pd.Series, timedelta) check(assert_type(left.mul(b), "pd.Series[float]"), pd.Series, np.floating) @@ -177,7 +177,7 @@ def test_mul_pd_index(left: "pd.Series[float]") -> None: check(assert_type(left * f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * d, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(b * left, "pd.Series[float]"), pd.Series, np.floating) @@ -185,7 +185,7 @@ def test_mul_pd_index(left: "pd.Series[float]") -> None: check(assert_type(f * left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.mul(b), "pd.Series[float]"), pd.Series, np.floating) @@ -221,7 +221,7 @@ def test_mul_pd_series(left: "pd.Series[float]") -> None: check(assert_type(left * f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * d, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(b * left, "pd.Series[float]"), pd.Series, np.floating) @@ -229,7 +229,7 @@ def test_mul_pd_series(left: "pd.Series[float]") -> None: check(assert_type(f * left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.mul(b), "pd.Series[float]"), pd.Series, np.floating) diff --git a/tests/series/arithmetic/float/test_truediv.py b/tests/series/arithmetic/float/test_truediv.py index 09ecf5955..065969288 100644 --- a/tests/series/arithmetic/float/test_truediv.py +++ b/tests/series/arithmetic/float/test_truediv.py @@ -36,15 +36,15 @@ def test_truediv_py_scalar(left: "pd.Series[float]") -> None: check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) @@ -105,15 +105,15 @@ def test_truediv_py_sequence(left: "pd.Series[float]") -> None: check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, pd.Series), pd.Series, timedelta) # dtype object check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) @@ -249,11 +249,11 @@ def test_truediv_pd_scalar(left: "pd.Series[float]") -> None: s, d = pd.Timestamp(2025, 9, 24), pd.Timedelta(seconds=1) if TYPE_CHECKING_INVALID_USAGE: - _00 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _01 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _01 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: - _10 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: @@ -291,15 +291,15 @@ def test_truediv_pd_index(left: "pd.Series[float]") -> None: check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) @@ -363,15 +363,15 @@ def test_truediv_pd_series(left: "pd.Series[float]") -> None: check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) diff --git a/tests/series/arithmetic/int/test_floordiv.py b/tests/series/arithmetic/int/test_floordiv.py index 9e4fc5542..b671ce3b6 100644 --- a/tests/series/arithmetic/int/test_floordiv.py +++ b/tests/series/arithmetic/int/test_floordiv.py @@ -38,16 +38,16 @@ def test_floordiv_py_scalar(left: "pd.Series[int]") -> None: check(assert_type(left // i, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(left // f, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b // left, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(i // left, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(f // left, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.floordiv(b), "pd.Series[int]"), pd.Series, np.integer) @@ -81,16 +81,16 @@ def test_floordiv_py_sequence(left: "pd.Series[int]") -> None: check(assert_type(left // i, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(left // f, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b // left, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(i // left, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(f // left, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, pd.Series), pd.Series, timedelta) check(assert_type(left.floordiv(b), "pd.Series[int]"), pd.Series, np.integer) @@ -178,16 +178,16 @@ def test_floordiv_pd_index(left: "pd.Series[int]") -> None: check(assert_type(left // i, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(left // f, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b // left, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(i // left, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(f // left, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.floordiv(b), "pd.Series[int]"), pd.Series, np.integer) @@ -224,16 +224,16 @@ def test_floordiv_pd_series(left: "pd.Series[int]") -> None: check(assert_type(left // i, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(left // f, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b // left, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(i // left, "pd.Series[int]"), pd.Series, np.integer) check(assert_type(f // left, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.floordiv(b), "pd.Series[int]"), pd.Series, np.integer) diff --git a/tests/series/arithmetic/int/test_mul.py b/tests/series/arithmetic/int/test_mul.py index 933412c7d..6c7eba090 100644 --- a/tests/series/arithmetic/int/test_mul.py +++ b/tests/series/arithmetic/int/test_mul.py @@ -41,7 +41,7 @@ def test_mul_py_scalar(left: "pd.Series[int]") -> None: check(assert_type(left * f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * d, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(b * left, "pd.Series[int]"), pd.Series, np.integer) @@ -49,7 +49,7 @@ def test_mul_py_scalar(left: "pd.Series[int]") -> None: check(assert_type(f * left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.mul(b), "pd.Series[int]"), pd.Series, np.integer) @@ -82,7 +82,7 @@ def test_mul_py_sequence(left: "pd.Series[int]") -> None: check(assert_type(left * f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * d, "pd.Series[pd.Timedelta]"), pd.Series, timedelta) check(assert_type(b * left, "pd.Series[int]"), pd.Series, np.integer) @@ -90,7 +90,7 @@ def test_mul_py_sequence(left: "pd.Series[int]") -> None: check(assert_type(f * left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d * left, "pd.Series[pd.Timedelta]"), pd.Series, timedelta) check(assert_type(left.mul(b), "pd.Series[int]"), pd.Series, np.integer) @@ -177,7 +177,7 @@ def test_mul_pd_index(left: "pd.Series[int]") -> None: check(assert_type(left * f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * d, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(b * left, "pd.Series[int]"), pd.Series, np.integer) @@ -185,7 +185,7 @@ def test_mul_pd_index(left: "pd.Series[int]") -> None: check(assert_type(f * left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.mul(b), "pd.Series[int]"), pd.Series, np.integer) @@ -221,7 +221,7 @@ def test_mul_pd_series(left: "pd.Series[int]") -> None: check(assert_type(left * f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * d, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(b * left, "pd.Series[int]"), pd.Series, np.integer) @@ -229,7 +229,7 @@ def test_mul_pd_series(left: "pd.Series[int]") -> None: check(assert_type(f * left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.mul(b), "pd.Series[int]"), pd.Series, np.integer) diff --git a/tests/series/arithmetic/int/test_truediv.py b/tests/series/arithmetic/int/test_truediv.py index 19aeabf78..df0d490a3 100644 --- a/tests/series/arithmetic/int/test_truediv.py +++ b/tests/series/arithmetic/int/test_truediv.py @@ -36,15 +36,15 @@ def test_truediv_py_scalar(left: "pd.Series[int]") -> None: check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) @@ -105,15 +105,15 @@ def test_truediv_py_sequence(left: "pd.Series[int]") -> None: check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, pd.Series), pd.Series, timedelta) # dtype object check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) @@ -253,11 +253,11 @@ def test_truediv_pd_scalar(left: "pd.Series[int]") -> None: s, d = pd.Timestamp(2025, 9, 24), pd.Timedelta(seconds=1) if TYPE_CHECKING_INVALID_USAGE: - _00 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _01 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _01 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: - _10 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: @@ -295,15 +295,15 @@ def test_truediv_pd_index(left: "pd.Series[int]") -> None: check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) @@ -367,15 +367,15 @@ def test_truediv_pd_series(left: "pd.Series[int]") -> None: check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) diff --git a/tests/series/arithmetic/str/test_add.py b/tests/series/arithmetic/str/test_add.py index 6aa5ce0ff..1d8595397 100644 --- a/tests/series/arithmetic/str/test_add.py +++ b/tests/series/arithmetic/str/test_add.py @@ -26,11 +26,11 @@ def test_add_py_scalar() -> None: r0 = "right" if TYPE_CHECKING_INVALID_USAGE: - _0 = left + i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left + i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left + r0, "pd.Series[str]"), pd.Series, str) if TYPE_CHECKING_INVALID_USAGE: - _1 = i + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = i + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(r0 + left, "pd.Series[str]"), pd.Series, str) if TYPE_CHECKING_INVALID_USAGE: @@ -49,12 +49,12 @@ def test_add_py_sequence() -> None: r1 = tuple(r0) if TYPE_CHECKING_INVALID_USAGE: - _0 = left + i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left + i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left + r0, "pd.Series[str]"), pd.Series, str) check(assert_type(left + r1, "pd.Series[str]"), pd.Series, str) if TYPE_CHECKING_INVALID_USAGE: - _1 = i + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = i + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(r0 + left, "pd.Series[str]"), pd.Series, str) check(assert_type(r1 + left, "pd.Series[str]"), pd.Series, str) @@ -109,11 +109,11 @@ def test_add_pd_index() -> None: r0 = pd.Index(["a", "bc", "def"]) if TYPE_CHECKING_INVALID_USAGE: - _0 = left + i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left + i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left + r0, "pd.Series[str]"), pd.Series, str) if TYPE_CHECKING_INVALID_USAGE: - _1 = i + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = i + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(r0 + left, "pd.Series[str]"), pd.Series, str) if TYPE_CHECKING_INVALID_USAGE: @@ -131,11 +131,11 @@ def test_add_pd_series() -> None: r0 = pd.Series(["a", "bc", "def"]) if TYPE_CHECKING_INVALID_USAGE: - _0 = left + i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left + i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left + r0, "pd.Series[str]"), pd.Series, str) if TYPE_CHECKING_INVALID_USAGE: - _1 = i + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = i + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(r0 + left, "pd.Series[str]"), pd.Series, str) if TYPE_CHECKING_INVALID_USAGE: diff --git a/tests/series/arithmetic/str/test_mul.py b/tests/series/arithmetic/str/test_mul.py index ab27a7858..efcce7bfb 100644 --- a/tests/series/arithmetic/str/test_mul.py +++ b/tests/series/arithmetic/str/test_mul.py @@ -37,22 +37,22 @@ def test_mul_py_scalar(left: "pd.Series[str]") -> None: s, d = datetime(2025, 9, 27), timedelta(seconds=1) if TYPE_CHECKING_INVALID_USAGE: - _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * i, "pd.Series[str]"), pd.Series, str) if TYPE_CHECKING_INVALID_USAGE: - _02 = left * f # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _02 = left * f # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: - _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i * left, "pd.Series[str]"), pd.Series, str) if TYPE_CHECKING_INVALID_USAGE: - _12 = f * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _12 = f * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: left.mul(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] @@ -80,22 +80,22 @@ def test_mul_py_sequence(left: "pd.Series[str]") -> None: d = [timedelta(seconds=s + 1) for s in range(3)] if TYPE_CHECKING_INVALID_USAGE: - _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * i, "pd.Series[str]"), pd.Series, str) if TYPE_CHECKING_INVALID_USAGE: - _02 = left * f # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _02 = left * f # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: - _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i * left, "pd.Series[str]"), pd.Series, str) if TYPE_CHECKING_INVALID_USAGE: - _12 = f * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _12 = f * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: left.mul(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] @@ -175,22 +175,22 @@ def test_mul_pd_index(left: "pd.Series[str]") -> None: d = pd.Index([timedelta(seconds=s + 1) for s in range(3)]) if TYPE_CHECKING_INVALID_USAGE: - _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * i, "pd.Series[str]"), pd.Series, str) if TYPE_CHECKING_INVALID_USAGE: - _02 = left * f # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _02 = left * f # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: - _10 = b * left # type: ignore[operator,type-var,unused-ignore] # pyright: ignore[reportOperatorIssue] # mypy gives different errors for mypy and test_dist + _10 = b * left # type: ignore[operator,type-var,unused-ignore] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] # mypy gives different errors for mypy and test_dist check(assert_type(i * left, "pd.Series[str]"), pd.Series, str) if TYPE_CHECKING_INVALID_USAGE: - _12 = f * left # type: ignore[operator,type-var,unused-ignore] # pyright: ignore[reportOperatorIssue] # mypy gives different errors for mypy and test_dist - _13 = c * left # type: ignore[operator,type-var,unused-ignore] # pyright: ignore[reportOperatorIssue] # mypy gives different errors for mypy and test_dist - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _12 = f * left # type: ignore[operator,type-var,unused-ignore] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] # mypy gives different errors for mypy and test_dist + _13 = c * left # type: ignore[operator,type-var,unused-ignore] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] # mypy gives different errors for mypy and test_dist + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: left.mul(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] @@ -221,22 +221,22 @@ def test_mul_pd_series(left: "pd.Series[str]") -> None: d = pd.Series([timedelta(seconds=s + 1) for s in range(3)]) if TYPE_CHECKING_INVALID_USAGE: - _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * i, "pd.Series[str]"), pd.Series, str) if TYPE_CHECKING_INVALID_USAGE: - _02 = left * f # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _02 = left * f # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: - _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i * left, "pd.Series[str]"), pd.Series, str) if TYPE_CHECKING_INVALID_USAGE: - _12 = f * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _12 = f * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: left.mul(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] diff --git a/tests/series/arithmetic/test_floordiv.py b/tests/series/arithmetic/test_floordiv.py index 57073b7ef..caa54dc00 100644 --- a/tests/series/arithmetic/test_floordiv.py +++ b/tests/series/arithmetic/test_floordiv.py @@ -34,16 +34,16 @@ def test_floordiv_py_scalar(left_i: pd.Series) -> None: check(assert_type(left_i // i, pd.Series), pd.Series, np.integer) check(assert_type(left_i // f, pd.Series), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left_i // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left_i // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left_i // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left_i // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left_i // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left_i // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b // left_i, pd.Series), pd.Series, np.integer) check(assert_type(i // left_i, pd.Series), pd.Series, np.integer) check(assert_type(f // left_i, pd.Series), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left_i, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left_i.floordiv(b), pd.Series), pd.Series, np.integer) @@ -77,16 +77,16 @@ def test_floordiv_py_sequence(left_i: pd.Series) -> None: check(assert_type(left_i // i, pd.Series), pd.Series, np.integer) check(assert_type(left_i // f, pd.Series), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left_i // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left_i // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left_i // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left_i // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left_i // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left_i // d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b // left_i, pd.Series), pd.Series, np.integer) check(assert_type(i // left_i, pd.Series), pd.Series, np.integer) check(assert_type(f // left_i, pd.Series), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left_i, pd.Series), pd.Series, timedelta) check(assert_type(left_i.floordiv(b), pd.Series), pd.Series, np.integer) @@ -194,8 +194,8 @@ def test_floordiv_pd_index(left_i: pd.Series) -> None: check(assert_type(left_i // i, pd.Series), pd.Series, np.integer) check(assert_type(left_i // f, pd.Series), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left_i // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left_i // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left_i // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left_i // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] def _05() -> None: # pyright: ignore[reportUnusedFunction] assert_type(left_i // d, Never) @@ -204,8 +204,8 @@ def _05() -> None: # pyright: ignore[reportUnusedFunction] check(assert_type(i // left_i, pd.Series), pd.Series, np.integer) check(assert_type(f // left_i, pd.Series), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left_i, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left_i.floordiv(b), pd.Series), pd.Series, np.integer) @@ -244,16 +244,16 @@ def test_floordiv_pd_series(left_i: pd.Series) -> None: check(assert_type(left_i // i, pd.Series), pd.Series, np.integer) check(assert_type(left_i // f, pd.Series), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _03 = left_i // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left_i // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left_i // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left_i // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] # left_i // d # This invalid one cannot be detected by static type checking check(assert_type(b // left_i, pd.Series), pd.Series, np.integer) check(assert_type(i // left_i, pd.Series), pd.Series, np.integer) check(assert_type(f // left_i, pd.Series), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _13 = c // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left_i, pd.Series), pd.Series, pd.Timedelta) check(assert_type(left_i.floordiv(b), pd.Series), pd.Series, np.integer) diff --git a/tests/series/arithmetic/test_mul.py b/tests/series/arithmetic/test_mul.py index 0c6b70fc9..d2f915321 100644 --- a/tests/series/arithmetic/test_mul.py +++ b/tests/series/arithmetic/test_mul.py @@ -183,7 +183,7 @@ def test_mul_str_py_str(left_i: pd.Series) -> None: s = "abc" if TYPE_CHECKING_INVALID_USAGE: - _0 = left_i * s # type: ignore[operator] # pyright:ignore[reportOperatorIssue] - _1 = s * left_i # type: ignore[operator] # pyright:ignore[reportOperatorIssue] + _0 = left_i * s # type: ignore[operator] # pyright:ignore[reportOperatorIssue,reportUnknownVariableType] + _1 = s * left_i # type: ignore[operator] # pyright:ignore[reportOperatorIssue,reportUnknownVariableType] left_i.mul(s) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] left_i.rmul(s) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] diff --git a/tests/series/arithmetic/test_sub.py b/tests/series/arithmetic/test_sub.py index 267e380d8..f49910889 100644 --- a/tests/series/arithmetic/test_sub.py +++ b/tests/series/arithmetic/test_sub.py @@ -189,7 +189,7 @@ def test_sub_ts_py_datetime() -> None: check(assert_type(left_ts - s, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: # Series[Any] (Timestamp) - Sequence[datetime] should work, see pandas-dev/pandas#62353 - _1 = left_ts - a # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = left_ts - a # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] # Series[Any] (Timedelta) - datetime fails at runtime, # which cannot be revealed by our static type checking # _2 = left_td - s @@ -198,16 +198,16 @@ def test_sub_ts_py_datetime() -> None: # see pandas-dev/pandas#62353. Even if such __sub__ is supported # it will fail at runtime here, # which cannot be revealed by our static type checking - _3 = left_td - a # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _3 = left_td - a # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(s - left_ts, pd.Series), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: # Sequence[datetime] - Series[Any] (Timestamp) should work, see pandas-dev/pandas#62353 - _5 = a - left_ts # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _5 = a - left_ts # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(s - left_td, pd.Series), pd.Series, pd.Timestamp) if TYPE_CHECKING_INVALID_USAGE: # Sequence[datetime] - Series[Any] (Timedelta) should work, see pandas-dev/pandas#62353 - _7 = a - left_td # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _7 = a - left_td # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check( assert_type(left_ts.sub(s), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta @@ -315,7 +315,7 @@ def test_sub_str_py_str() -> None: s = "abc" if TYPE_CHECKING_INVALID_USAGE: - _0 = left_i - s # type: ignore[operator] # pyright:ignore[reportOperatorIssue] - _1 = s - left_i # type: ignore[operator] # pyright:ignore[reportOperatorIssue] + _0 = left_i - s # type: ignore[operator] # pyright:ignore[reportOperatorIssue,reportUnknownVariableType] + _1 = s - left_i # type: ignore[operator] # pyright:ignore[reportOperatorIssue,reportUnknownVariableType] left_i.sub(s) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] left_i.rsub(s) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] diff --git a/tests/series/arithmetic/test_truediv.py b/tests/series/arithmetic/test_truediv.py index 1d1f1f609..4dd108601 100644 --- a/tests/series/arithmetic/test_truediv.py +++ b/tests/series/arithmetic/test_truediv.py @@ -36,15 +36,15 @@ def test_truediv_py_scalar(left_i: pd.Series) -> None: check(assert_type(left_i / f, pd.Series), pd.Series) check(assert_type(left_i / c, pd.Series), pd.Series) if TYPE_CHECKING_INVALID_USAGE: - _04 = left_i / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left_i / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left_i / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left_i / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b / left_i, pd.Series), pd.Series) check(assert_type(i / left_i, pd.Series), pd.Series) check(assert_type(f / left_i, pd.Series), pd.Series) check(assert_type(c / left_i, pd.Series), pd.Series) if TYPE_CHECKING_INVALID_USAGE: - _14 = s / left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s / left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left_i, pd.Series), pd.Series) check(assert_type(left_i.truediv(b), pd.Series), pd.Series) @@ -91,15 +91,15 @@ def test_truediv_py_sequence(left_i: pd.Series) -> None: check(assert_type(left_i / f, pd.Series), pd.Series) check(assert_type(left_i / c, pd.Series), pd.Series) if TYPE_CHECKING_INVALID_USAGE: - _04 = left_i / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _05 = left_i / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left_i / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _05 = left_i / d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(b / left_i, pd.Series), pd.Series) check(assert_type(i / left_i, pd.Series), pd.Series) check(assert_type(f / left_i, pd.Series), pd.Series) check(assert_type(c / left_i, pd.Series), pd.Series) if TYPE_CHECKING_INVALID_USAGE: - _14 = s / left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s / left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left_i, pd.Series), pd.Series) check(assert_type(left_i.truediv(b), pd.Series), pd.Series) @@ -231,7 +231,7 @@ def test_truediv_pd_index(left_i: pd.Series) -> None: check(assert_type(left_i / f, pd.Series), pd.Series) check(assert_type(left_i / c, pd.Series), pd.Series) if TYPE_CHECKING_INVALID_USAGE: - _05 = left_i / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _05 = left_i / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] assert_type(left_i / d, Never) check(assert_type(a / left_i, pd.Series), pd.Series) @@ -240,7 +240,7 @@ def test_truediv_pd_index(left_i: pd.Series) -> None: check(assert_type(f / left_i, pd.Series), pd.Series) check(assert_type(c / left_i, pd.Series), pd.Series) if TYPE_CHECKING_INVALID_USAGE: - _15 = s / left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _15 = s / left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left_i, pd.Series), pd.Series) check(assert_type(left_i.truediv(a), pd.Series), pd.Series) @@ -300,7 +300,7 @@ def test_truediv_pd_series(left_i: pd.Series) -> None: check(assert_type(left_i / f, pd.Series), pd.Series) check(assert_type(left_i / c, pd.Series), pd.Series) if TYPE_CHECKING_INVALID_USAGE: - _04 = left_i / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _04 = left_i / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] # _05 = left_i / d # This invalid one cannot be detected by static type checking check(assert_type(a / left_i, pd.Series), pd.Series) @@ -309,7 +309,7 @@ def test_truediv_pd_series(left_i: pd.Series) -> None: check(assert_type(f / left_i, pd.Series), pd.Series) check(assert_type(c / left_i, pd.Series), pd.Series) if TYPE_CHECKING_INVALID_USAGE: - _14 = s / left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _14 = s / left_i # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left_i, pd.Series), pd.Series) check(assert_type(left_i.truediv(a), pd.Series), pd.Series) @@ -387,8 +387,8 @@ def test_truediv_str_py_str(left_i: pd.Series) -> None: s = "abc" if TYPE_CHECKING_INVALID_USAGE: - _00 = left_i / s # type: ignore[operator] # pyright:ignore[reportOperatorIssue] - _01 = s / left_i # type: ignore[operator] # pyright:ignore[reportOperatorIssue] + _00 = left_i / s # type: ignore[operator] # pyright:ignore[reportOperatorIssue,reportUnknownVariableType] + _01 = s / left_i # type: ignore[operator] # pyright:ignore[reportOperatorIssue,reportUnknownVariableType] left_i.truediv(s) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] left_i.div(s) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] diff --git a/tests/series/arithmetic/timedelta/test_add.py b/tests/series/arithmetic/timedelta/test_add.py index 6409ffe1d..6a677836d 100644 --- a/tests/series/arithmetic/timedelta/test_add.py +++ b/tests/series/arithmetic/timedelta/test_add.py @@ -80,12 +80,12 @@ def test_add_py_sequence() -> None: if TYPE_CHECKING_INVALID_USAGE: # Series[Timedelta] + Sequence[datetime] should work, see pandas-dev/pandas#62353 - _0 = left + s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left + s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] # Series[Timedelta] + Sequence[timedelta] should work, see pandas-dev/pandas#62353 - _a = left + d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _a = left + d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] - _1 = s + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _b = d + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = s + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _b = d + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left.add(s), "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) check(assert_type(left.add(d), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) diff --git a/tests/series/arithmetic/timedelta/test_floordiv.py b/tests/series/arithmetic/timedelta/test_floordiv.py index d75203cde..e16c7142c 100644 --- a/tests/series/arithmetic/timedelta/test_floordiv.py +++ b/tests/series/arithmetic/timedelta/test_floordiv.py @@ -34,20 +34,20 @@ def test_floordiv_py_scalar(left: "pd.Series[pd.Timedelta]") -> None: s, d = datetime(2025, 9, 24), timedelta(seconds=1) if TYPE_CHECKING_INVALID_USAGE: - _00 = left // b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left // b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left // i, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left // f, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left // d, "pd.Series[int]"), pd.Series, np.integer) if TYPE_CHECKING_INVALID_USAGE: - _10 = b // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _11 = i // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _12 = f // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _11 = i // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _12 = f // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, "pd.Series[int]"), pd.Series, np.integer) if TYPE_CHECKING_INVALID_USAGE: @@ -82,12 +82,12 @@ def test_floordiv_py_sequence(left: "pd.Series[pd.Timedelta]") -> None: s, d = [datetime(2025, 9, 24)], [timedelta(seconds=1)] if TYPE_CHECKING_INVALID_USAGE: - _00 = left // b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left // b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left // i, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left // f, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] # TODO: pandas-dev/pandas#62552 switch to np.integer after Pandas 3.0 check( assert_type(left // d, "pd.Series[int]"), @@ -96,11 +96,11 @@ def test_floordiv_py_sequence(left: "pd.Series[pd.Timedelta]") -> None: ) if TYPE_CHECKING_INVALID_USAGE: - _10 = b // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _11 = i // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _12 = f // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _11 = i // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _12 = f // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, "pd.Series[int]"), pd.Series, np.integer) if TYPE_CHECKING_INVALID_USAGE: @@ -189,11 +189,11 @@ def test_floordiv_pd_scalar(left: "pd.Series[pd.Timedelta]") -> None: s, d = pd.Timestamp(2025, 9, 24), pd.Timedelta(seconds=1) if TYPE_CHECKING_INVALID_USAGE: - _00 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left // d, "pd.Series[int]"), pd.Series, np.integer) if TYPE_CHECKING_INVALID_USAGE: - _10 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, "pd.Series[int]"), pd.Series, np.integer) if TYPE_CHECKING_INVALID_USAGE: @@ -214,20 +214,20 @@ def test_floordiv_pd_index(left: "pd.Series[pd.Timedelta]") -> None: s, d = pd.Index([datetime(2025, 9, 24)]), pd.Index([timedelta(seconds=1)]) if TYPE_CHECKING_INVALID_USAGE: - _00 = left // b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left // b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left // i, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left // f, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left // d, "pd.Series[int]"), pd.Series, np.integer) if TYPE_CHECKING_INVALID_USAGE: - _10 = b // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _11 = i // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _12 = f // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _11 = i // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _12 = f // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, "pd.Series[int]"), pd.Series, np.integer) if TYPE_CHECKING_INVALID_USAGE: @@ -265,20 +265,20 @@ def test_floordiv_pd_series(left: "pd.Series[pd.Timedelta]") -> None: s, d = pd.Series([datetime(2025, 9, 24)]), pd.Series([timedelta(seconds=1)]) if TYPE_CHECKING_INVALID_USAGE: - _00 = left // b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left // b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left // i, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left // f, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left // d, "pd.Series[int]"), pd.Series, np.integer) if TYPE_CHECKING_INVALID_USAGE: - _10 = b // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _11 = i // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _12 = f // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _11 = i // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _12 = f // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d // left, "pd.Series[int]"), pd.Series, np.integer) if TYPE_CHECKING_INVALID_USAGE: diff --git a/tests/series/arithmetic/timedelta/test_mul.py b/tests/series/arithmetic/timedelta/test_mul.py index 2f5f5db18..9c55b058a 100644 --- a/tests/series/arithmetic/timedelta/test_mul.py +++ b/tests/series/arithmetic/timedelta/test_mul.py @@ -29,18 +29,18 @@ def test_mul_py_scalar(left: "pd.Series[pd.Timedelta]") -> None: b, i, f, c = True, 1, 1.0, 1j if TYPE_CHECKING_INVALID_USAGE: - _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * i, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left * f, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: - _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(f * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: left.mul(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] @@ -62,18 +62,18 @@ def test_mul_py_sequence(left: "pd.Series[pd.Timedelta]") -> None: b, i, f, c = [True], [2], [1.5], [1.7j] if TYPE_CHECKING_INVALID_USAGE: - _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * i, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left * f, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: - _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(f * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: left.mul(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] @@ -138,18 +138,18 @@ def test_mul_pd_index(left: "pd.Series[pd.Timedelta]") -> None: c = pd.Index([1.7j]) if TYPE_CHECKING_INVALID_USAGE: - _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * i, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left * f, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: - _10 = b * left # type: ignore[operator,type-var,unused-ignore] # pyright: ignore[reportOperatorIssue] # mypy gives different errors for mypy and test_dist + _10 = b * left # type: ignore[operator,type-var,unused-ignore] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] # mypy gives different errors for mypy and test_dist check(assert_type(i * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(f * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _13 = c * left # type: ignore[operator,type-var,unused-ignore] # pyright: ignore[reportOperatorIssue] # mypy gives different errors for mypy and test_dist + _13 = c * left # type: ignore[operator,type-var,unused-ignore] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] # mypy gives different errors for mypy and test_dist if TYPE_CHECKING_INVALID_USAGE: left.mul(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] @@ -174,18 +174,18 @@ def test_mul_pd_series(left: "pd.Series[pd.Timedelta]") -> None: c = pd.Series([1.7j]) if TYPE_CHECKING_INVALID_USAGE: - _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left * i, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left * f, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: - _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(i * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(f * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: left.mul(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] diff --git a/tests/series/arithmetic/timedelta/test_sub.py b/tests/series/arithmetic/timedelta/test_sub.py index c4c618b25..b3084b30e 100644 --- a/tests/series/arithmetic/timedelta/test_sub.py +++ b/tests/series/arithmetic/timedelta/test_sub.py @@ -28,7 +28,7 @@ def test_sub_py_scalar() -> None: d = timedelta(seconds=1) if TYPE_CHECKING_INVALID_USAGE: - _0 = left - s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left - s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left - d, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(s - left, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) @@ -48,7 +48,7 @@ def test_sub_numpy_scalar() -> None: d = np.timedelta64(1, "s") if TYPE_CHECKING_INVALID_USAGE: - _0 = left - s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left - s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left - d, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(s - left, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) @@ -68,7 +68,7 @@ def test_sub_pd_scalar() -> None: d = pd.Timedelta(seconds=1) if TYPE_CHECKING_INVALID_USAGE: - _0 = left - s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left - s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left - d, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(s - left, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) @@ -88,12 +88,12 @@ def test_sub_py_sequence() -> None: d = [timedelta(seconds=1)] if TYPE_CHECKING_INVALID_USAGE: - _0 = left - s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left - s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] # Series[Timedelta] - Sequence[timedelta] should work, see pandas-dev/pandas#62353 - _a = left - d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _a = left - d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] - _1 = s - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _b = d - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = s - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _b = d - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: left.sub(s) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] @@ -132,7 +132,7 @@ def test_sub_pd_index() -> None: d = pd.Index([pd.Timedelta(seconds=1)]) if TYPE_CHECKING_INVALID_USAGE: - _0 = left - s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left - s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left - d, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(s - left, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) @@ -152,7 +152,7 @@ def test_sub_pd_series() -> None: d = pd.Series([pd.Timedelta(seconds=1)]) if TYPE_CHECKING_INVALID_USAGE: - _0 = left - s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left - s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left - d, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(s - left, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) diff --git a/tests/series/arithmetic/timedelta/test_truediv.py b/tests/series/arithmetic/timedelta/test_truediv.py index 6167ad679..1b0c4a70d 100644 --- a/tests/series/arithmetic/timedelta/test_truediv.py +++ b/tests/series/arithmetic/timedelta/test_truediv.py @@ -32,20 +32,20 @@ def test_truediv_py_scalar(left: "pd.Series[pd.Timedelta]") -> None: s, d = datetime(2025, 9, 24), timedelta(seconds=1) if TYPE_CHECKING_INVALID_USAGE: - _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / i, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left / f, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left / c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left / c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / d, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _11 = i / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _12 = f / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _11 = i / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _12 = f / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: @@ -93,20 +93,20 @@ def test_truediv_py_sequence(left: "pd.Series[pd.Timedelta]") -> None: s, d = [datetime(2025, 9, 24)], [timedelta(seconds=1)] if TYPE_CHECKING_INVALID_USAGE: - _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / i, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left / f, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left / c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left / c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / d, "pd.Series[float]"), pd.Series, float) if TYPE_CHECKING_INVALID_USAGE: - _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _11 = i / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _12 = f / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _11 = i / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _12 = f / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: @@ -221,11 +221,11 @@ def test_truediv_pd_scalar(left: "pd.Series[pd.Timedelta]") -> None: s, d = pd.Timestamp(2025, 9, 24), pd.Timedelta(seconds=1) if TYPE_CHECKING_INVALID_USAGE: - _0 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / d, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _1 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: @@ -254,20 +254,20 @@ def test_truediv_pd_index(left: "pd.Series[pd.Timedelta]") -> None: s, d = pd.Index([datetime(2025, 9, 24)]), pd.Index([timedelta(seconds=1)]) if TYPE_CHECKING_INVALID_USAGE: - _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / i, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left / f, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left / c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left / c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / d, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _11 = i / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _12 = f / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _11 = i / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _12 = f / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: @@ -318,20 +318,20 @@ def test_truediv_pd_series(left: "pd.Series[pd.Timedelta]") -> None: s, d = pd.Series([datetime(2025, 9, 24)]), pd.Series([timedelta(seconds=1)]) if TYPE_CHECKING_INVALID_USAGE: - _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / i, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left / f, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _03 = left / c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left / c # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _04 = left / s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left / d, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: - _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _11 = i / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _12 = f / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _13 = c / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _11 = i / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _12 = f / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _13 = c / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _14 = s / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d / left, "pd.Series[float]"), pd.Series, np.floating) if TYPE_CHECKING_INVALID_USAGE: diff --git a/tests/series/arithmetic/timestamp/test_add.py b/tests/series/arithmetic/timestamp/test_add.py index 03029e7d8..8fef61228 100644 --- a/tests/series/arithmetic/timestamp/test_add.py +++ b/tests/series/arithmetic/timestamp/test_add.py @@ -28,11 +28,11 @@ def test_add_py_scalar() -> None: d = timedelta(seconds=1) if TYPE_CHECKING_INVALID_USAGE: - _0 = left + s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left + s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left + d, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) if TYPE_CHECKING_INVALID_USAGE: - _1 = s + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = s + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d + left, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) if TYPE_CHECKING_INVALID_USAGE: @@ -50,11 +50,11 @@ def test_add_numpy_scalar() -> None: d = np.timedelta64(1, "s") if TYPE_CHECKING_INVALID_USAGE: - _0 = left + s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left + s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left + d, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) if TYPE_CHECKING_INVALID_USAGE: - _1 = s + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = s + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d + left, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) if TYPE_CHECKING_INVALID_USAGE: @@ -72,11 +72,11 @@ def test_add_pd_scalar() -> None: d = pd.Timedelta(seconds=1) if TYPE_CHECKING_INVALID_USAGE: - _0 = left + s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left + s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left + d, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) if TYPE_CHECKING_INVALID_USAGE: - _1 = s + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = s + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d + left, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) if TYPE_CHECKING_INVALID_USAGE: @@ -94,12 +94,12 @@ def test_add_py_sequence() -> None: d = [timedelta(seconds=1)] if TYPE_CHECKING_INVALID_USAGE: - _0 = left + s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left + s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] # Series[Timestamp] + Sequence[timedelta] should work, see pandas-dev/pandas#62353 - _a = left + d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _a = left + d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] - _1 = s + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _b = d + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = s + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _b = d + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] if TYPE_CHECKING_INVALID_USAGE: left.add(s) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] @@ -143,11 +143,11 @@ def test_add_pd_index() -> None: d = pd.Index([pd.Timedelta(seconds=1)]) if TYPE_CHECKING_INVALID_USAGE: - _0 = left + s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left + s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left + d, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) if TYPE_CHECKING_INVALID_USAGE: - _1 = s + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = s + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d + left, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) if TYPE_CHECKING_INVALID_USAGE: @@ -165,11 +165,11 @@ def test_add_pd_series() -> None: d = pd.Series([pd.Timedelta(seconds=1)]) if TYPE_CHECKING_INVALID_USAGE: - _0 = left + s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left + s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left + d, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) if TYPE_CHECKING_INVALID_USAGE: - _1 = s + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = s + left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(d + left, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) if TYPE_CHECKING_INVALID_USAGE: diff --git a/tests/series/arithmetic/timestamp/test_sub.py b/tests/series/arithmetic/timestamp/test_sub.py index b5ae269f9..c3ad36fac 100644 --- a/tests/series/arithmetic/timestamp/test_sub.py +++ b/tests/series/arithmetic/timestamp/test_sub.py @@ -29,7 +29,7 @@ def test_sub_py_scalar() -> None: check(assert_type(s - left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _ = d - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _ = d - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left.sub(s), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left - d, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) @@ -49,7 +49,7 @@ def test_sub_numpy_scalar() -> None: check(assert_type(s - left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _ = d - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _ = d - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left.sub(s), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left - d, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) @@ -69,7 +69,7 @@ def test_sub_pd_scalar() -> None: check(assert_type(s - left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _ = d - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _ = d - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left.sub(s), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left - d, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) @@ -86,12 +86,12 @@ def test_sub_py_sequence() -> None: if TYPE_CHECKING_INVALID_USAGE: # Series[Timestamp] - Sequence[timestamp] should work, see pandas-dev/pandas#62353 - _0 = left - s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _0 = left - s # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] # Series[Timestamp] - Sequence[timedelta] should work, see pandas-dev/pandas#62353 - _a = left - d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _a = left - d # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] - _1 = s - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _b = d - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = s - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _b = d - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] left.sub(s) left.sub(d) @@ -134,7 +134,7 @@ def test_sub_pd_index() -> None: check(assert_type(s - left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _ = d - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _ = d - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left.sub(s), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left - d, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) @@ -154,7 +154,7 @@ def test_sub_pd_series() -> None: check(assert_type(s - left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _ = d - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _ = d - left # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] check(assert_type(left.sub(s), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left - d, "pd.Series[pd.Timestamp]"), pd.Series, pd.Timestamp) diff --git a/tests/series/test_properties.py b/tests/series/test_properties.py index 844336ab9..eb8d0701f 100644 --- a/tests/series/test_properties.py +++ b/tests/series/test_properties.py @@ -78,8 +78,8 @@ def test_property_dt() -> None: ) if TYPE_CHECKING_INVALID_USAGE: - _0 = Series([1]).dt # type: ignore[arg-type] # pyright: ignore[reportAttributeAccessIssue] - _1 = Series(["2025-01-01"]).dt # type: ignore[arg-type] # pyright: ignore[reportAttributeAccessIssue] + _0 = Series([1]).dt # type: ignore[arg-type] # pyright: ignore[reportAttributeAccessIssue,reportUnknownVariableType] + _1 = Series(["2025-01-01"]).dt # type: ignore[arg-type] # pyright: ignore[reportAttributeAccessIssue,reportUnknownVariableType] def test_property_array() -> None: diff --git a/tests/series/test_series.py b/tests/series/test_series.py index 33eee7915..f832600e3 100644 --- a/tests/series/test_series.py +++ b/tests/series/test_series.py @@ -102,7 +102,7 @@ ) if not PD_LTE_23: - from pandas.errors import Pandas4Warning # type: ignore[attr-defined] # pyright: ignore[reportAttributeAccessIssue,reportRedeclaration] # isort: skip + from pandas.errors import Pandas4Warning # type: ignore[attr-defined] # pyright: ignore[reportAttributeAccessIssue,reportRedeclaration,reportUnknownVariableType] # isort: skip else: Pandas4Warning: TypeAlias = FutureWarning # type: ignore[no-redef] @@ -327,9 +327,9 @@ def test_arguments_drop() -> None: # GH 950 s = pd.Series([0, 1, 2]) if TYPE_CHECKING_INVALID_USAGE: - _res1 = s.drop() # type: ignore[call-overload] # pyright: ignore[reportCallIssue] - _res2 = s.drop([0], columns=["col1"]) # type: ignore[call-overload] # pyright: ignore[reportCallIssue, reportArgumentType] - _res3 = s.drop([0], index=[0]) # type: ignore[call-overload] # pyright: ignore[reportCallIssue, reportArgumentType] + _res1 = s.drop() # type: ignore[call-overload] # pyright: ignore[reportCallIssue,reportUnknownVariableType] + _res2 = s.drop([0], columns=["col1"]) # type: ignore[call-overload] # pyright: ignore[reportCallIssue,reportArgumentType,reportUnknownVariableType] + _res3 = s.drop([0], index=[0]) # type: ignore[call-overload] # pyright: ignore[reportCallIssue,reportArgumentType,reportUnknownVariableType] def _never_checker0() -> None: # pyright: ignore[reportUnusedFunction] assert_type(s.drop(columns=None), Never) @@ -3230,7 +3230,7 @@ def test_to_json_mode() -> None: check(assert_type(result2, str), str) check(assert_type(result4, str), str) if TYPE_CHECKING_INVALID_USAGE: - _result3 = s.to_json(orient="records", lines=False, mode="a") # type: ignore[call-overload] # pyright: ignore[reportArgumentType,reportCallIssue] + _result3 = s.to_json(orient="records", lines=False, mode="a") # type: ignore[call-overload] # pyright: ignore[reportArgumentType,reportCallIssue,reportUnknownVariableType] def test_interpolate() -> None: diff --git a/tests/test_frame.py b/tests/test_frame.py index 99f8cfa7a..5609d8379 100644 --- a/tests/test_frame.py +++ b/tests/test_frame.py @@ -84,7 +84,7 @@ _PandasNamedTuple: TypeAlias = tuple if not PD_LTE_23: - from pandas.errors import Pandas4Warning # type: ignore[attr-defined] # pyright: ignore[reportAttributeAccessIssue,reportRedeclaration] # isort: skip + from pandas.errors import Pandas4Warning # type: ignore[attr-defined] # pyright: ignore[reportAttributeAccessIssue,reportRedeclaration,reportUnknownVariableType] # isort: skip else: Pandas4Warning: TypeAlias = FutureWarning # type: ignore[no-redef] @@ -183,22 +183,22 @@ def test_types_append() -> None: df = pd.DataFrame(data={"col1": [1, 2], "col2": [3, 4]}) df2 = pd.DataFrame({"col1": [10, 20], "col2": [30, 40]}) if TYPE_CHECKING_INVALID_USAGE: - _res1: pd.DataFrame = df.append(df2) # type: ignore[operator] # pyright: ignore[reportCallIssue] - _res2: pd.DataFrame = df.append([1, 2, 3]) # type: ignore[operator] # pyright: ignore[reportCallIssue] - _res3: pd.DataFrame = df.append([[1, 2, 3]]) # type: ignore[operator] # pyright: ignore[reportCallIssue] - _res4: pd.DataFrame = df.append( # type: ignore[operator] # pyright: ignore[reportCallIssue] + _res1: pd.DataFrame = df.append(df2) # type: ignore[operator] # pyright: ignore[reportCallIssue,reportUnknownVariableType] + _res2: pd.DataFrame = df.append([1, 2, 3]) # type: ignore[operator] # pyright: ignore[reportCallIssue,reportUnknownVariableType] + _res3: pd.DataFrame = df.append([[1, 2, 3]]) # type: ignore[operator] # pyright: ignore[reportCallIssue,reportUnknownVariableType] + _res4: pd.DataFrame = df.append( # type: ignore[operator] # pyright: ignore[reportCallIssue,reportUnknownVariableType] {("a", 1): [1, 2, 3], "b": df2}, ignore_index=True ) - _res5: pd.DataFrame = df.append( # type: ignore[operator] # pyright: ignore[reportCallIssue] + _res5: pd.DataFrame = df.append( # type: ignore[operator] # pyright: ignore[reportCallIssue,reportUnknownVariableType] {1: [1, 2, 3]}, ignore_index=True ) - _res6: pd.DataFrame = df.append( # type: ignore[operator] # pyright: ignore[reportCallIssue] + _res6: pd.DataFrame = df.append( # type: ignore[operator] # pyright: ignore[reportCallIssue,reportUnknownVariableType] {1: [1, 2, 3], "col2": [1, 2, 3]}, ignore_index=True ) - _res7: pd.DataFrame = df.append( # type: ignore[operator] # pyright: ignore[reportCallIssue] + _res7: pd.DataFrame = df.append( # type: ignore[operator] # pyright: ignore[reportCallIssue,reportUnknownVariableType] pd.Series([5, 6]), ignore_index=True ) - _res8: pd.DataFrame = df.append( # type: ignore[operator] # pyright: ignore[reportCallIssue] + _res8: pd.DataFrame = df.append( # type: ignore[operator] # pyright: ignore[reportCallIssue,reportUnknownVariableType] pd.Series([5, 6], index=["col1", "col2"]), ignore_index=True ) @@ -394,7 +394,9 @@ def test_types_assign() -> None: def test_assign() -> None: df = pd.DataFrame({"a": [1, 2, 3], 1: [4, 5, 6]}) - my_unnamed_func = lambda df: df["a"] * 2 + my_unnamed_func = ( # pyright: ignore[reportUnknownVariableType] + lambda df: df["a"] * 2 + ) def my_named_func_1(df: pd.DataFrame) -> pd.Series[str]: return df["a"] @@ -493,9 +495,9 @@ def test_arguments_drop() -> None: # GH 950 df = pd.DataFrame(data={"col1": [1, 2], "col2": [3, 4]}) if TYPE_CHECKING_INVALID_USAGE: - _res1 = df.drop() # type: ignore[call-overload] # pyright: ignore[reportCallIssue] - _res2 = df.drop([0], columns=["col1"]) # type: ignore[call-overload] # pyright: ignore[reportCallIssue, reportArgumentType] - _res3 = df.drop([0], index=[0]) # type: ignore[call-overload] # pyright: ignore[reportCallIssue, reportArgumentType] + _res1 = df.drop() # type: ignore[call-overload] # pyright: ignore[reportCallIssue,reportUnknownVariableType] + _res2 = df.drop([0], columns=["col1"]) # type: ignore[call-overload] # pyright: ignore[reportCallIssue,reportArgumentType,reportUnknownVariableType] + _res3 = df.drop([0], index=[0]) # type: ignore[call-overload] # pyright: ignore[reportCallIssue,reportArgumentType,reportUnknownVariableType] def _never_checker0() -> None: # pyright: ignore[reportUnusedFunction] assert_type(df.drop(columns=None), Never) @@ -3991,7 +3993,7 @@ def test_to_dict_into_defaultdict() -> None: """Test DataFrame.to_dict with `into` is an instance of defaultdict[Any, list]""" data = pd.DataFrame({("str", "rts"): [[1, 2, 4], [2, 3], [3]]}) - target: defaultdict[Any, list] = defaultdict(list) + target: defaultdict[Any, list[Any]] = defaultdict(list) check( assert_type(data.to_dict(into=target), defaultdict[Any, list]), @@ -4560,10 +4562,10 @@ def test_to_dict_index() -> None: assert_type(df.to_dict(orient="split", index=False), dict[str, list]), dict, str ) if TYPE_CHECKING_INVALID_USAGE: - _0 = df.to_dict(orient="records", index=False) # type: ignore[call-overload] # pyright: ignore[reportArgumentType,reportCallIssue] - _1 = df.to_dict(orient="dict", index=False) # type: ignore[call-overload] # pyright: ignore[reportArgumentType,reportCallIssue] - _2 = df.to_dict(orient="series", index=False) # type: ignore[call-overload] # pyright: ignore[reportArgumentType,reportCallIssue] - _3 = df.to_dict(orient="index", index=False) # type: ignore[call-overload] # pyright: ignore[reportArgumentType,reportCallIssue] + _0 = df.to_dict(orient="records", index=False) # type: ignore[call-overload] # pyright: ignore[reportArgumentType,reportCallIssue,reportUnknownVariableType] + _1 = df.to_dict(orient="dict", index=False) # type: ignore[call-overload] # pyright: ignore[reportArgumentType,reportCallIssue,reportUnknownVariableType] + _2 = df.to_dict(orient="series", index=False) # type: ignore[call-overload] # pyright: ignore[reportArgumentType,reportCallIssue,reportUnknownVariableType] + _3 = df.to_dict(orient="index", index=False) # type: ignore[call-overload] # pyright: ignore[reportArgumentType,reportCallIssue,reportUnknownVariableType] def test_suffix_prefix_index() -> None: @@ -4632,7 +4634,7 @@ def _0() -> None: # pyright: ignore[reportUnusedFunction] assert_never(df.select_dtypes([], [])) if TYPE_CHECKING_INVALID_USAGE: - _1 = df.select_dtypes() # type: ignore[call-overload] # pyright: ignore[reportCallIssue] + _1 = df.select_dtypes() # type: ignore[call-overload] # pyright: ignore[reportCallIssue,reportUnknownVariableType] # str like dtypes are not allowed def _2() -> None: # pyright: ignore[reportUnusedFunction] @@ -4660,7 +4662,7 @@ def test_to_json_mode() -> None: check(assert_type(result2, str), str) check(assert_type(result4, str), str) if TYPE_CHECKING_INVALID_USAGE: - _result3 = df.to_json(orient="records", lines=False, mode="a") # type: ignore[call-overload] # pyright: ignore[reportArgumentType,reportCallIssue] + _result3 = df.to_json(orient="records", lines=False, mode="a") # type: ignore[call-overload] # pyright: ignore[reportArgumentType,reportCallIssue,reportUnknownVariableType] def test_interpolate() -> None: @@ -4875,7 +4877,9 @@ def test_transpose() -> None: def test_combine() -> None: df1 = pd.DataFrame({"A": [0, 0], "B": [4, 4]}) df2 = pd.DataFrame({"A": [1, 1], "B": [3, 3]}) - take_smaller = lambda s1, s2: s1 if s1.sum() < s2.sum() else s2 + take_smaller = lambda s1, s2: ( # pyright: ignore[reportUnknownVariableType] + s1 if s1.sum() < s2.sum() else s2 + ) assert_type( check( df1.combine(df2, take_smaller, fill_value=0, overwrite=False), pd.DataFrame diff --git a/tests/test_interval.py b/tests/test_interval.py index 398bda276..30159e2c0 100644 --- a/tests/test_interval.py +++ b/tests/test_interval.py @@ -86,9 +86,9 @@ def test_interval_length() -> None: check(assert_type(idres, "pd.Interval[pd.Timestamp]"), pd.Interval, pd.Timestamp) if TYPE_CHECKING_INVALID_USAGE: _00 = 20 in i1 # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _01 = i1 + pd.Timestamp("2000-03-03") # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _02 = i1 * 3 # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _03 = i1 * pd.Timedelta(seconds=20) # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _01 = i1 + pd.Timestamp("2000-03-03") # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _02 = i1 * 3 # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _03 = i1 * pd.Timedelta(seconds=20) # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] i2 = pd.Interval(10, 20) check(assert_type(i2.length, int), int) @@ -105,7 +105,7 @@ def test_interval_length() -> None: if TYPE_CHECKING_INVALID_USAGE: _10 = pd.Timestamp("2001-01-02") in i2 # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _11 = i2 + pd.Timedelta(seconds=20) # type: ignore[type-var] # pyright: ignore[reportOperatorIssue] + _11 = i2 + pd.Timedelta(seconds=20) # type: ignore[type-var] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] i3 = pd.Interval(13.2, 19.5) check(assert_type(i3.length, float), float) check(assert_type(i3.left, float), float) @@ -118,7 +118,7 @@ def test_interval_length() -> None: check(assert_type(i3 * 3, "pd.Interval[float]"), pd.Interval, float) if TYPE_CHECKING_INVALID_USAGE: _20 = pd.Timestamp("2001-01-02") in i3 # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _21 = i3 + pd.Timedelta(seconds=20) # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _21 = i3 + pd.Timedelta(seconds=20) # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] def test_interval_array_contains() -> None: diff --git a/tests/test_io.py b/tests/test_io.py index ff5bb5850..d10dd912e 100644 --- a/tests/test_io.py +++ b/tests/test_io.py @@ -21,13 +21,11 @@ errors, read_clipboard, read_csv, - read_excel, read_feather, read_fwf, read_hdf, read_html, read_json, - read_orc, read_parquet, read_pickle, read_sas, @@ -39,6 +37,8 @@ read_table, read_xml, ) +from pandas import read_excel # pyright: ignore[reportUnknownVariableType] +from pandas import read_orc # pyright: ignore[reportUnknownVariableType] from pandas.api.typing import JsonReader import pytest import sqlalchemy @@ -945,7 +945,7 @@ def test_text_file_reader() -> None: with TextFileReader(path, engine="python") as tfr: check(assert_type(tfr.__next__(), DataFrame), DataFrame) df_iter: DataFrame - for df_iter in tfr: + for df_iter in tfr: # pyright: ignore[reportUnknownVariableType] check(df_iter, DataFrame) diff --git a/tests/test_pandas.py b/tests/test_pandas.py index 9e2e87949..979055c5b 100644 --- a/tests/test_pandas.py +++ b/tests/test_pandas.py @@ -1026,11 +1026,7 @@ def test_cut() -> None: labels=["1", "2", "3", "4"], retbins=True, ) - m0, m1 = pd.cut( - pd.Series([1, 2, 3, 4, 5, 6, 7, 8]), - intval_idx, - retbins=True, - ) + m0, m1 = pd.cut(pd.Series([1, 2, 3, 4, 5, 6, 7, 8]), intval_idx, retbins=True) check(assert_type(j0, pd.Series), pd.Series) check(assert_type(j1, np_1darray_float), np_1darray, np.floating) check(assert_type(k0, pd.Series), pd.Series) diff --git a/tests/test_resampler.py b/tests/test_resampler.py index 3fa7ac15a..83d0f05b5 100644 --- a/tests/test_resampler.py +++ b/tests/test_resampler.py @@ -26,7 +26,7 @@ ) if not PD_LTE_23: - from pandas.errors import Pandas4Warning # type: ignore[attr-defined] # pyright: ignore[reportAttributeAccessIssue,reportRedeclaration] # isort: skip + from pandas.errors import Pandas4Warning # type: ignore[attr-defined] # pyright: ignore[reportAttributeAccessIssue,reportRedeclaration,reportUnknownVariableType] # isort: skip else: Pandas4Warning: TypeAlias = FutureWarning # type: ignore[no-redef] diff --git a/tests/test_timefuncs.py b/tests/test_timefuncs.py index 0b210feb2..2a8a62015 100644 --- a/tests/test_timefuncs.py +++ b/tests/test_timefuncs.py @@ -52,7 +52,7 @@ ) if not PD_LTE_23: - from pandas.errors import Pandas4Warning # type: ignore[attr-defined] # pyright: ignore[reportAttributeAccessIssue,reportRedeclaration] # isort: skip + from pandas.errors import Pandas4Warning # type: ignore[attr-defined] # pyright: ignore[reportAttributeAccessIssue,reportRedeclaration,reportUnknownVariableType] # isort: skip else: Pandas4Warning: TypeAlias = FutureWarning # type: ignore[no-redef] @@ -1631,9 +1631,9 @@ def test_timedelta64_and_arithmatic_operator() -> None: td = np.timedelta64(1, "D") check(assert_type((s3 / td), "pd.Series[float]"), pd.Series, float) if TYPE_CHECKING_INVALID_USAGE: - _1 = s1 * td # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _2 = s1 / td # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - _3 = s3 * td # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _1 = s1 * td # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _2 = s1 / td # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + _3 = s3 * td # type: ignore[operator] # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] def test_timedeltaseries_add_timestampseries() -> None: