From 40791c2ba86f47cd84235df843e049c2d1cea832 Mon Sep 17 00:00:00 2001 From: ram vikram singh Date: Fri, 11 Nov 2022 02:38:22 +0530 Subject: [PATCH 1/6] t001 --- pandas-stubs/core/dtypes/common.pyi | 2 +- tests/test_api_types.py | 183 ++++++++++++++++++++++++++++ 2 files changed, 184 insertions(+), 1 deletion(-) diff --git a/pandas-stubs/core/dtypes/common.pyi b/pandas-stubs/core/dtypes/common.pyi index 3156f1508..dd2d83f75 100644 --- a/pandas-stubs/core/dtypes/common.pyi +++ b/pandas-stubs/core/dtypes/common.pyi @@ -28,7 +28,7 @@ from pandas.core.dtypes.inference import ( is_scalar as is_scalar, ) -_ArrayOrDtype: TypeAlias = Union[ArrayLike, npt.DTypeLike, pd.Series, pd.DataFrame] +_ArrayOrDtype: TypeAlias = Union[ArrayLike, npt.DTypeLike, pd.Series, pd.DataFrame, pd.Index] def is_object_dtype(arr_or_dtype: _ArrayOrDtype) -> bool: ... def is_sparse(arr: ArrayLike | pd.Series | pd.DataFrame) -> bool: ... diff --git a/tests/test_api_types.py b/tests/test_api_types.py index de4e2c393..dc68c57f1 100644 --- a/tests/test_api_types.py +++ b/tests/test_api_types.py @@ -18,46 +18,101 @@ def test_is_array_like() -> None: check(assert_type(api.is_array_like(arr), bool), bool) + check(assert_type(api.is_array_like(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_array_like(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_array_like(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_array_like(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_array_like(pd.Index([1, 2.0])), bool), bool) def test_is_bool() -> None: check(assert_type(api.is_bool(obj), bool), bool) + check(assert_type(api.is_bool(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_bool(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_bool(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_bool(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_bool(pd.Index([1, 2.0])), bool), bool) def test_is_bool_dtype() -> None: check(assert_type(api.is_bool_dtype(arr), bool), bool) + check(assert_type(api.is_bool_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_bool_dtype(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_bool_dtype(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_bool_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_bool_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_categorical_dtype() -> None: check(assert_type(api.is_categorical_dtype(arr), bool), bool) + check(assert_type(api.is_categorical_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_categorical_dtype(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_categorical_dtype(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_categorical_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_categorical_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_complex() -> None: check(assert_type(api.is_complex(obj), bool), bool) + check(assert_type(api.is_complex(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_complex(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_complex(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_complex(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_complex(pd.Index([1, 2.0])), bool), bool) def test_is_complex_dtype() -> None: check(assert_type(api.is_complex_dtype(arr), bool), bool) + check(assert_type(api.is_complex_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_complex_dtype(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_complex_dtype(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_complex_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_complex_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_datetime64_any_dtype() -> None: check(assert_type(api.is_datetime64_any_dtype(arr), bool), bool) + check(assert_type(api.is_datetime64_any_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_datetime64_any_dtype(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_datetime64_any_dtype(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_datetime64_any_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_datetime64_any_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_datetime64_dtype() -> None: check(assert_type(api.is_datetime64_dtype(arr), bool), bool) + check(assert_type(api.is_datetime64_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_datetime64_dtype(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_datetime64_dtype(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_datetime64_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_datetime64_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_datetime64_ns_dtype() -> None: check(assert_type(api.is_datetime64_ns_dtype(arr), bool), bool) + check(assert_type(api.is_datetime64_ns_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_datetime64_ns_dtype(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_datetime64_ns_dtype(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_datetime64_ns_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_datetime64_ns_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_datetime64tz_dtype() -> None: check(assert_type(api.is_datetime64tz_dtype(arr), bool), bool) + check(assert_type(api.is_datetime64tz_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_datetime64tz_dtype(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_datetime64tz_dtype(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_datetime64tz_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_datetime64tz_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_dict_like() -> None: check(assert_type(api.is_dict_like(mapping), bool), bool) + check(assert_type(api.is_dict_like(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_dict_like(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_dict_like(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_dict_like(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_dict_like(pd.Index([1, 2.0])), bool), bool) def test_is_dtype_equal() -> None: @@ -66,106 +121,234 @@ def test_is_dtype_equal() -> None: def test_is_extension_array_dtype() -> None: check(assert_type(api.is_extension_array_dtype(arr), bool), bool) + check(assert_type(api.is_extension_array_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_extension_array_dtype(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_extension_array_dtype(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_extension_array_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_extension_array_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_file_like() -> None: check(assert_type(api.is_file_like(obj), bool), bool) + check(assert_type(api.is_file_like(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_file_like(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_file_like(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_file_like(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_file_like(pd.Index([1, 2.0])), bool), bool) def test_is_float() -> None: check(assert_type(api.is_float(obj), bool), bool) + check(assert_type(api.is_float(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_float(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_float(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_float(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_float(pd.Index([1, 2.0])), bool), bool) def test_is_float_dtype() -> None: check(assert_type(api.is_float_dtype(arr), bool), bool) + check(assert_type(api.is_float_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_float_dtype(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_float_dtype(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_float_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_float_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_hashable() -> None: check(assert_type(api.is_hashable(obj), bool), bool) + check(assert_type(api.is_hashable(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_hashable(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_hashable(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_hashable(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_hashable(pd.Index([1, 2.0])), bool), bool) def test_is_int64_dtype() -> None: check(assert_type(api.is_int64_dtype(arr), bool), bool) + check(assert_type(api.is_int64_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_int64_dtype(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_int64_dtype(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_int64_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_int64_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_integer() -> None: check(assert_type(api.is_integer(obj), bool), bool) + check(assert_type(api.is_integer(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_integer(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_integer(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_integer(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_integer(pd.Index([1, 2.0])), bool), bool) def test_is_integer_dtype() -> None: check(assert_type(api.is_integer_dtype(arr), bool), bool) + check(assert_type(api.is_integer_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_integer_dtype(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_integer_dtype(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_integer_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_integer_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_interval() -> None: check(assert_type(api.is_interval(obj), bool), bool) + check(assert_type(api.is_interval(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_interval(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_interval(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_interval(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_interval(pd.Index([1, 2.0])), bool), bool) def test_is_interval_dtype() -> None: check(assert_type(api.is_interval_dtype(obj), bool), bool) + check(assert_type(api.is_interval(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_interval(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_interval(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_interval(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_interval(pd.Index([1, 2.0])), bool), bool) def test_is_iterator() -> None: check(assert_type(api.is_iterator(obj), bool), bool) + check(assert_type(api.is_iterator(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_iterator(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_iterator(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_iterator(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_iterator(pd.Index([1, 2.0])), bool), bool) def test_is_list_like() -> None: check(assert_type(api.is_list_like(obj), bool), bool) + check(assert_type(api.is_list_like(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_list_like(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_list_like(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_list_like(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_list_like(pd.Index([1, 2.0])), bool), bool) def test_is_named_tuple() -> None: check(assert_type(api.is_named_tuple(obj), bool), bool) + check(assert_type(api.is_named_tuple(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_named_tuple(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_named_tuple(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_named_tuple(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_named_tuple(pd.Index([1, 2.0])), bool), bool) def test_is_number() -> None: check(assert_type(api.is_number(obj), bool), bool) + check(assert_type(api.is_number(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_number(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_number(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_number(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_number(pd.Index([1, 2.0])), bool), bool) def test_is_numeric_dtype() -> None: check(assert_type(api.is_numeric_dtype(arr), bool), bool) + check(assert_type(api.is_numeric_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_numeric_dtype(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_numeric_dtype(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_numeric_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_numeric_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_object_dtype() -> None: check(assert_type(api.is_object_dtype(arr), bool), bool) + check(assert_type(api.is_object_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_object_dtype(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_object_dtype(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_object_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_object_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_period_dtype() -> None: check(assert_type(api.is_period_dtype(arr), bool), bool) + check(assert_type(api.is_period_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_period_dtype(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_period_dtype(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_period_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_period_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_re() -> None: check(assert_type(api.is_re(obj), bool), bool) + check(assert_type(api.is_re(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_re(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_re(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_re(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_re(pd.Index([1, 2.0])), bool), bool) def test_is_re_compilable() -> None: check(assert_type(api.is_re_compilable(obj), bool), bool) + check(assert_type(api.is_re_compilable(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_re_compilable(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_re_compilable(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_re_compilable(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_re_compilable(pd.Index([1, 2.0])), bool), bool) def test_is_scalar() -> None: check(assert_type(api.is_scalar(obj), bool), bool) + check(assert_type(api.is_scalar(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_scalar(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_scalar(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_scalar(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_scalar(pd.Index([1, 2.0])), bool), bool) def test_is_signed_integer_dtype() -> None: check(assert_type(api.is_signed_integer_dtype(arr), bool), bool) + check(assert_type(api.is_signed_integer_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_signed_integer_dtype(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_signed_integer_dtype(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_signed_integer_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_signed_integer_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_sparse() -> None: check(assert_type(api.is_sparse(arr), bool), bool) + check(assert_type(api.is_sparse(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_sparse(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_sparse(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) def test_is_string_dtype() -> None: check(assert_type(api.is_string_dtype(arr), bool), bool) + check(assert_type(api.is_string_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_string_dtype(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_string_dtype(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_string_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_string_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_timedelta64_dtype() -> None: check(assert_type(api.is_timedelta64_dtype(arr), bool), bool) + check(assert_type(api.is_timedelta64_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_timedelta64_dtype(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_timedelta64_dtype(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_timedelta64_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_timedelta64_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_timedelta64_ns_dtype() -> None: check(assert_type(api.is_timedelta64_ns_dtype(arr), bool), bool) + check(assert_type(api.is_timedelta64_ns_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_timedelta64_ns_dtype(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_timedelta64_ns_dtype(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_timedelta64_ns_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_timedelta64_ns_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_unsigned_integer_dtype() -> None: check(assert_type(api.is_unsigned_integer_dtype(arr), bool), bool) + check(assert_type(api.is_unsigned_integer_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_unsigned_integer_dtype(np.dtype(np.int32)), bool), bool) + check(assert_type(api.is_unsigned_integer_dtype(pd.Series([1,2,3])), bool), bool) + check(assert_type(api.is_unsigned_integer_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_unsigned_integer_dtype(pd.Index([1, 2.0])), bool), bool) def test_pandas_dtype() -> None: From 149006e2659f5bb19c0914700b3828dde30df122 Mon Sep 17 00:00:00 2001 From: ram vikram singh Date: Fri, 11 Nov 2022 02:56:34 +0530 Subject: [PATCH 2/6] Update test_api_types.py --- tests/test_api_types.py | 360 +++++++++++++++++++++++++++------------- 1 file changed, 249 insertions(+), 111 deletions(-) diff --git a/tests/test_api_types.py b/tests/test_api_types.py index dc68c57f1..a93b6f979 100644 --- a/tests/test_api_types.py +++ b/tests/test_api_types.py @@ -18,100 +18,144 @@ def test_is_array_like() -> None: check(assert_type(api.is_array_like(arr), bool), bool) - check(assert_type(api.is_array_like(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_array_like(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_array_like(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_array_like(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_array_like(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_array_like(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type(api.is_array_like(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + bool, + ) check(assert_type(api.is_array_like(pd.Index([1, 2.0])), bool), bool) def test_is_bool() -> None: check(assert_type(api.is_bool(obj), bool), bool) - check(assert_type(api.is_bool(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_bool(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_bool(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_bool(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_bool(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_bool(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type(api.is_bool(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), bool + ) check(assert_type(api.is_bool(pd.Index([1, 2.0])), bool), bool) def test_is_bool_dtype() -> None: check(assert_type(api.is_bool_dtype(arr), bool), bool) - check(assert_type(api.is_bool_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_bool_dtype(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_bool_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_bool_dtype(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_bool_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_bool_dtype(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type(api.is_bool_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + bool, + ) check(assert_type(api.is_bool_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_categorical_dtype() -> None: check(assert_type(api.is_categorical_dtype(arr), bool), bool) - check(assert_type(api.is_categorical_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_categorical_dtype(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_categorical_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_categorical_dtype(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_categorical_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_categorical_dtype(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type( + api.is_categorical_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool + ), + bool, + ) check(assert_type(api.is_categorical_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_complex() -> None: check(assert_type(api.is_complex(obj), bool), bool) - check(assert_type(api.is_complex(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_complex(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_complex(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_complex(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_complex(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_complex(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type(api.is_complex(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + bool, + ) check(assert_type(api.is_complex(pd.Index([1, 2.0])), bool), bool) def test_is_complex_dtype() -> None: check(assert_type(api.is_complex_dtype(arr), bool), bool) - check(assert_type(api.is_complex_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_complex_dtype(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_complex_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_complex_dtype(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_complex_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_complex_dtype(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type( + api.is_complex_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool + ), + bool, + ) check(assert_type(api.is_complex_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_datetime64_any_dtype() -> None: check(assert_type(api.is_datetime64_any_dtype(arr), bool), bool) - check(assert_type(api.is_datetime64_any_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_datetime64_any_dtype(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_datetime64_any_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_datetime64_any_dtype(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_datetime64_any_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_datetime64_any_dtype(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type( + api.is_datetime64_any_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool + ), + bool, + ) check(assert_type(api.is_datetime64_any_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_datetime64_dtype() -> None: check(assert_type(api.is_datetime64_dtype(arr), bool), bool) - check(assert_type(api.is_datetime64_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_datetime64_dtype(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_datetime64_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_datetime64_dtype(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_datetime64_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_datetime64_dtype(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type( + api.is_datetime64_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool + ), + bool, + ) check(assert_type(api.is_datetime64_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_datetime64_ns_dtype() -> None: check(assert_type(api.is_datetime64_ns_dtype(arr), bool), bool) - check(assert_type(api.is_datetime64_ns_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_datetime64_ns_dtype(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_datetime64_ns_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_datetime64_ns_dtype(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_datetime64_ns_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_datetime64_ns_dtype(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type( + api.is_datetime64_ns_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool + ), + bool, + ) check(assert_type(api.is_datetime64_ns_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_datetime64tz_dtype() -> None: check(assert_type(api.is_datetime64tz_dtype(arr), bool), bool) - check(assert_type(api.is_datetime64tz_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_datetime64tz_dtype(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_datetime64tz_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_datetime64tz_dtype(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_datetime64tz_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_datetime64tz_dtype(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type( + api.is_datetime64tz_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool + ), + bool, + ) check(assert_type(api.is_datetime64tz_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_dict_like() -> None: check(assert_type(api.is_dict_like(mapping), bool), bool) - check(assert_type(api.is_dict_like(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_dict_like(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_dict_like(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_dict_like(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_dict_like(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_dict_like(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type(api.is_dict_like(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + bool, + ) check(assert_type(api.is_dict_like(pd.Index([1, 2.0])), bool), bool) @@ -121,233 +165,327 @@ def test_is_dtype_equal() -> None: def test_is_extension_array_dtype() -> None: check(assert_type(api.is_extension_array_dtype(arr), bool), bool) - check(assert_type(api.is_extension_array_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_extension_array_dtype(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_extension_array_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_extension_array_dtype(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_extension_array_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_extension_array_dtype(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type( + api.is_extension_array_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool + ), + bool, + ) check(assert_type(api.is_extension_array_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_file_like() -> None: check(assert_type(api.is_file_like(obj), bool), bool) - check(assert_type(api.is_file_like(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_file_like(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_file_like(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_file_like(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_file_like(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_file_like(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type(api.is_file_like(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + bool, + ) check(assert_type(api.is_file_like(pd.Index([1, 2.0])), bool), bool) def test_is_float() -> None: check(assert_type(api.is_float(obj), bool), bool) - check(assert_type(api.is_float(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_float(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_float(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_float(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_float(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_float(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type(api.is_float(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), bool + ) check(assert_type(api.is_float(pd.Index([1, 2.0])), bool), bool) def test_is_float_dtype() -> None: check(assert_type(api.is_float_dtype(arr), bool), bool) - check(assert_type(api.is_float_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_float_dtype(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_float_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_float_dtype(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_float_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_float_dtype(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type(api.is_float_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + bool, + ) check(assert_type(api.is_float_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_hashable() -> None: check(assert_type(api.is_hashable(obj), bool), bool) - check(assert_type(api.is_hashable(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_hashable(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_hashable(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_hashable(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_hashable(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_hashable(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type(api.is_hashable(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + bool, + ) check(assert_type(api.is_hashable(pd.Index([1, 2.0])), bool), bool) def test_is_int64_dtype() -> None: check(assert_type(api.is_int64_dtype(arr), bool), bool) - check(assert_type(api.is_int64_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_int64_dtype(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_int64_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_int64_dtype(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_int64_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_int64_dtype(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type(api.is_int64_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + bool, + ) check(assert_type(api.is_int64_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_integer() -> None: check(assert_type(api.is_integer(obj), bool), bool) - check(assert_type(api.is_integer(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_integer(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_integer(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_integer(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_integer(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_integer(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type(api.is_integer(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + bool, + ) check(assert_type(api.is_integer(pd.Index([1, 2.0])), bool), bool) def test_is_integer_dtype() -> None: check(assert_type(api.is_integer_dtype(arr), bool), bool) - check(assert_type(api.is_integer_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_integer_dtype(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_integer_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_integer_dtype(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_integer_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_integer_dtype(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type( + api.is_integer_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool + ), + bool, + ) check(assert_type(api.is_integer_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_interval() -> None: check(assert_type(api.is_interval(obj), bool), bool) - check(assert_type(api.is_interval(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_interval(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_interval(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_interval(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_interval(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_interval(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type(api.is_interval(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + bool, + ) check(assert_type(api.is_interval(pd.Index([1, 2.0])), bool), bool) def test_is_interval_dtype() -> None: check(assert_type(api.is_interval_dtype(obj), bool), bool) - check(assert_type(api.is_interval(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_interval(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_interval(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_interval(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_interval(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_interval(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type(api.is_interval(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + bool, + ) check(assert_type(api.is_interval(pd.Index([1, 2.0])), bool), bool) def test_is_iterator() -> None: check(assert_type(api.is_iterator(obj), bool), bool) - check(assert_type(api.is_iterator(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_iterator(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_iterator(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_iterator(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_iterator(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_iterator(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type(api.is_iterator(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + bool, + ) check(assert_type(api.is_iterator(pd.Index([1, 2.0])), bool), bool) def test_is_list_like() -> None: check(assert_type(api.is_list_like(obj), bool), bool) - check(assert_type(api.is_list_like(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_list_like(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_list_like(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_list_like(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_list_like(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_list_like(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type(api.is_list_like(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + bool, + ) check(assert_type(api.is_list_like(pd.Index([1, 2.0])), bool), bool) def test_is_named_tuple() -> None: check(assert_type(api.is_named_tuple(obj), bool), bool) - check(assert_type(api.is_named_tuple(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_named_tuple(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_named_tuple(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_named_tuple(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_named_tuple(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_named_tuple(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type(api.is_named_tuple(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + bool, + ) check(assert_type(api.is_named_tuple(pd.Index([1, 2.0])), bool), bool) def test_is_number() -> None: check(assert_type(api.is_number(obj), bool), bool) - check(assert_type(api.is_number(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_number(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_number(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_number(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_number(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_number(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type(api.is_number(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), bool + ) check(assert_type(api.is_number(pd.Index([1, 2.0])), bool), bool) def test_is_numeric_dtype() -> None: check(assert_type(api.is_numeric_dtype(arr), bool), bool) - check(assert_type(api.is_numeric_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_numeric_dtype(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_numeric_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_numeric_dtype(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_numeric_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_numeric_dtype(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type( + api.is_numeric_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool + ), + bool, + ) check(assert_type(api.is_numeric_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_object_dtype() -> None: check(assert_type(api.is_object_dtype(arr), bool), bool) - check(assert_type(api.is_object_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_object_dtype(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_object_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_object_dtype(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_object_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_object_dtype(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type( + api.is_object_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool + ), + bool, + ) check(assert_type(api.is_object_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_period_dtype() -> None: check(assert_type(api.is_period_dtype(arr), bool), bool) - check(assert_type(api.is_period_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_period_dtype(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_period_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_period_dtype(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_period_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_period_dtype(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type( + api.is_period_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool + ), + bool, + ) check(assert_type(api.is_period_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_re() -> None: check(assert_type(api.is_re(obj), bool), bool) - check(assert_type(api.is_re(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_re(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_re(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_re(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_re(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_re(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_re(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), bool) check(assert_type(api.is_re(pd.Index([1, 2.0])), bool), bool) def test_is_re_compilable() -> None: check(assert_type(api.is_re_compilable(obj), bool), bool) - check(assert_type(api.is_re_compilable(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_re_compilable(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_re_compilable(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_re_compilable(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_re_compilable(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_re_compilable(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type( + api.is_re_compilable(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool + ), + bool, + ) check(assert_type(api.is_re_compilable(pd.Index([1, 2.0])), bool), bool) def test_is_scalar() -> None: check(assert_type(api.is_scalar(obj), bool), bool) - check(assert_type(api.is_scalar(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_scalar(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_scalar(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_scalar(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_scalar(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_scalar(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type(api.is_scalar(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), bool + ) check(assert_type(api.is_scalar(pd.Index([1, 2.0])), bool), bool) def test_is_signed_integer_dtype() -> None: check(assert_type(api.is_signed_integer_dtype(arr), bool), bool) - check(assert_type(api.is_signed_integer_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_signed_integer_dtype(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_signed_integer_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_signed_integer_dtype(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_signed_integer_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_signed_integer_dtype(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type( + api.is_signed_integer_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool + ), + bool, + ) check(assert_type(api.is_signed_integer_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_sparse() -> None: check(assert_type(api.is_sparse(arr), bool), bool) - check(assert_type(api.is_sparse(np.array([1,2,3])), bool), bool) - check(assert_type(api.is_sparse(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_sparse(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_sparse(np.array([1, 2, 3])), bool), bool) + check(assert_type(api.is_sparse(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type(api.is_sparse(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), bool + ) def test_is_string_dtype() -> None: check(assert_type(api.is_string_dtype(arr), bool), bool) - check(assert_type(api.is_string_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_string_dtype(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_string_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_string_dtype(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_string_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_string_dtype(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type( + api.is_string_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool + ), + bool, + ) check(assert_type(api.is_string_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_timedelta64_dtype() -> None: check(assert_type(api.is_timedelta64_dtype(arr), bool), bool) - check(assert_type(api.is_timedelta64_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_timedelta64_dtype(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_timedelta64_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_timedelta64_dtype(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_timedelta64_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_timedelta64_dtype(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type( + api.is_timedelta64_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool + ), + bool, + ) check(assert_type(api.is_timedelta64_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_timedelta64_ns_dtype() -> None: check(assert_type(api.is_timedelta64_ns_dtype(arr), bool), bool) - check(assert_type(api.is_timedelta64_ns_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_timedelta64_ns_dtype(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_timedelta64_ns_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_timedelta64_ns_dtype(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_timedelta64_ns_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_timedelta64_ns_dtype(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type( + api.is_timedelta64_ns_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool + ), + bool, + ) check(assert_type(api.is_timedelta64_ns_dtype(pd.Index([1, 2.0])), bool), bool) def test_is_unsigned_integer_dtype() -> None: check(assert_type(api.is_unsigned_integer_dtype(arr), bool), bool) - check(assert_type(api.is_unsigned_integer_dtype(np.array([1,2,3])), bool), bool) + check(assert_type(api.is_unsigned_integer_dtype(np.array([1, 2, 3])), bool), bool) check(assert_type(api.is_unsigned_integer_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_unsigned_integer_dtype(pd.Series([1,2,3])), bool), bool) - check(assert_type(api.is_unsigned_integer_dtype(pd.DataFrame({"a":[1,2], "b":[3,4]})), bool), bool) + check(assert_type(api.is_unsigned_integer_dtype(pd.Series([1, 2, 3])), bool), bool) + check( + assert_type( + api.is_unsigned_integer_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), + bool, + ), + bool, + ) check(assert_type(api.is_unsigned_integer_dtype(pd.Index([1, 2.0])), bool), bool) From 18674916497202a5be8f07ea9c80ed83245fbd81 Mon Sep 17 00:00:00 2001 From: ram vikram singh Date: Fri, 11 Nov 2022 03:02:01 +0530 Subject: [PATCH 3/6] up3 --- pandas-stubs/core/dtypes/common.pyi | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/pandas-stubs/core/dtypes/common.pyi b/pandas-stubs/core/dtypes/common.pyi index dd2d83f75..e3a3c7069 100644 --- a/pandas-stubs/core/dtypes/common.pyi +++ b/pandas-stubs/core/dtypes/common.pyi @@ -28,7 +28,9 @@ from pandas.core.dtypes.inference import ( is_scalar as is_scalar, ) -_ArrayOrDtype: TypeAlias = Union[ArrayLike, npt.DTypeLike, pd.Series, pd.DataFrame, pd.Index] +_ArrayOrDtype: TypeAlias = Union[ + ArrayLike, npt.DTypeLike, pd.Series, pd.DataFrame, pd.Index +] def is_object_dtype(arr_or_dtype: _ArrayOrDtype) -> bool: ... def is_sparse(arr: ArrayLike | pd.Series | pd.DataFrame) -> bool: ... From 3dc9ec4d4403971f6ccf5d3c8126c127c86cb429 Mon Sep 17 00:00:00 2001 From: ram vikram singh Date: Fri, 11 Nov 2022 03:43:20 +0530 Subject: [PATCH 4/6] up8 --- pandas-stubs/core/dtypes/common.pyi | 1 + 1 file changed, 1 insertion(+) diff --git a/pandas-stubs/core/dtypes/common.pyi b/pandas-stubs/core/dtypes/common.pyi index e3a3c7069..a24ab9832 100644 --- a/pandas-stubs/core/dtypes/common.pyi +++ b/pandas-stubs/core/dtypes/common.pyi @@ -32,6 +32,7 @@ _ArrayOrDtype: TypeAlias = Union[ ArrayLike, npt.DTypeLike, pd.Series, pd.DataFrame, pd.Index ] + def is_object_dtype(arr_or_dtype: _ArrayOrDtype) -> bool: ... def is_sparse(arr: ArrayLike | pd.Series | pd.DataFrame) -> bool: ... def is_datetime64_dtype(arr_or_dtype: _ArrayOrDtype) -> bool: ... From e3a7fbbf4feab345acbc3a5d418639ed3dec5921 Mon Sep 17 00:00:00 2001 From: ram vikram singh Date: Fri, 11 Nov 2022 04:16:04 +0530 Subject: [PATCH 5/6] update --- pandas-stubs/core/dtypes/common.pyi | 1 - tests/test_api_types.py | 391 ++++++++++++---------------- 2 files changed, 166 insertions(+), 226 deletions(-) diff --git a/pandas-stubs/core/dtypes/common.pyi b/pandas-stubs/core/dtypes/common.pyi index a24ab9832..e3a3c7069 100644 --- a/pandas-stubs/core/dtypes/common.pyi +++ b/pandas-stubs/core/dtypes/common.pyi @@ -32,7 +32,6 @@ _ArrayOrDtype: TypeAlias = Union[ ArrayLike, npt.DTypeLike, pd.Series, pd.DataFrame, pd.Index ] - def is_object_dtype(arr_or_dtype: _ArrayOrDtype) -> bool: ... def is_sparse(arr: ArrayLike | pd.Series | pd.DataFrame) -> bool: ... def is_datetime64_dtype(arr_or_dtype: _ArrayOrDtype) -> bool: ... diff --git a/tests/test_api_types.py b/tests/test_api_types.py index a93b6f979..bc89095c3 100644 --- a/tests/test_api_types.py +++ b/tests/test_api_types.py @@ -14,149 +14,131 @@ arr = pd.Series([1, 2, 3]) obj = "True" mapping = {"a": "a"} +dframe = pd.DataFrame({"a": [1, 2], "b": [3, 4]}) +dtylike = np.dtype(np.int32) +ind = pd.Index([1, 2.0]) def test_is_array_like() -> None: check(assert_type(api.is_array_like(arr), bool), bool) - check(assert_type(api.is_array_like(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_array_like(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_array_like(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_array_like(nparr), bool), bool) + check(assert_type(api.is_array_like(dtylike), bool), bool) check( - assert_type(api.is_array_like(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + assert_type(api.is_array_like(dframe), bool), bool, ) - check(assert_type(api.is_array_like(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_array_like(ind), bool), bool) def test_is_bool() -> None: check(assert_type(api.is_bool(obj), bool), bool) - check(assert_type(api.is_bool(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_bool(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_bool(pd.Series([1, 2, 3])), bool), bool) - check( - assert_type(api.is_bool(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), bool - ) - check(assert_type(api.is_bool(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_bool(nparr), bool), bool) + check(assert_type(api.is_bool(dtylike), bool), bool) + check(assert_type(api.is_bool(arr), bool), bool) + check(assert_type(api.is_bool(dframe), bool), bool) + check(assert_type(api.is_bool(ind), bool), bool) def test_is_bool_dtype() -> None: check(assert_type(api.is_bool_dtype(arr), bool), bool) - check(assert_type(api.is_bool_dtype(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_bool_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_bool_dtype(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_bool_dtype(nparr), bool), bool) + check(assert_type(api.is_bool_dtype(dtylike), bool), bool) check( - assert_type(api.is_bool_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + assert_type(api.is_bool_dtype(dframe), bool), bool, ) - check(assert_type(api.is_bool_dtype(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_bool_dtype(ind), bool), bool) def test_is_categorical_dtype() -> None: check(assert_type(api.is_categorical_dtype(arr), bool), bool) - check(assert_type(api.is_categorical_dtype(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_categorical_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_categorical_dtype(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_categorical_dtype(nparr), bool), bool) + check(assert_type(api.is_categorical_dtype(dtylike), bool), bool) + check(assert_type(api.is_categorical_dtype(arr), bool), bool) check( - assert_type( - api.is_categorical_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool - ), + assert_type(api.is_categorical_dtype(dframe), bool), bool, ) - check(assert_type(api.is_categorical_dtype(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_categorical_dtype(ind), bool), bool) def test_is_complex() -> None: check(assert_type(api.is_complex(obj), bool), bool) - check(assert_type(api.is_complex(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_complex(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_complex(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_complex(nparr), bool), bool) + check(assert_type(api.is_complex(dtylike), bool), bool) + check(assert_type(api.is_complex(arr), bool), bool) check( - assert_type(api.is_complex(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + assert_type(api.is_complex(dframe), bool), bool, ) - check(assert_type(api.is_complex(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_complex(ind), bool), bool) def test_is_complex_dtype() -> None: check(assert_type(api.is_complex_dtype(arr), bool), bool) - check(assert_type(api.is_complex_dtype(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_complex_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_complex_dtype(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_complex_dtype(nparr), bool), bool) + check(assert_type(api.is_complex_dtype(dtylike), bool), bool) check( - assert_type( - api.is_complex_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool - ), + assert_type(api.is_complex_dtype(dframe), bool), bool, ) - check(assert_type(api.is_complex_dtype(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_complex_dtype(ind), bool), bool) def test_is_datetime64_any_dtype() -> None: check(assert_type(api.is_datetime64_any_dtype(arr), bool), bool) - check(assert_type(api.is_datetime64_any_dtype(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_datetime64_any_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_datetime64_any_dtype(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_datetime64_any_dtype(nparr), bool), bool) + check(assert_type(api.is_datetime64_any_dtype(dtylike), bool), bool) check( - assert_type( - api.is_datetime64_any_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool - ), + assert_type(api.is_datetime64_any_dtype(dframe), bool), bool, ) - check(assert_type(api.is_datetime64_any_dtype(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_datetime64_any_dtype(ind), bool), bool) def test_is_datetime64_dtype() -> None: check(assert_type(api.is_datetime64_dtype(arr), bool), bool) - check(assert_type(api.is_datetime64_dtype(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_datetime64_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_datetime64_dtype(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_datetime64_dtype(nparr), bool), bool) + check(assert_type(api.is_datetime64_dtype(dtylike), bool), bool) check( - assert_type( - api.is_datetime64_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool - ), + assert_type(api.is_datetime64_dtype(dframe), bool), bool, ) - check(assert_type(api.is_datetime64_dtype(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_datetime64_dtype(ind), bool), bool) def test_is_datetime64_ns_dtype() -> None: check(assert_type(api.is_datetime64_ns_dtype(arr), bool), bool) - check(assert_type(api.is_datetime64_ns_dtype(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_datetime64_ns_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_datetime64_ns_dtype(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_datetime64_ns_dtype(nparr), bool), bool) + check(assert_type(api.is_datetime64_ns_dtype(dtylike), bool), bool) check( - assert_type( - api.is_datetime64_ns_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool - ), + assert_type(api.is_datetime64_ns_dtype(dframe), bool), bool, ) - check(assert_type(api.is_datetime64_ns_dtype(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_datetime64_ns_dtype(ind), bool), bool) def test_is_datetime64tz_dtype() -> None: check(assert_type(api.is_datetime64tz_dtype(arr), bool), bool) - check(assert_type(api.is_datetime64tz_dtype(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_datetime64tz_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_datetime64tz_dtype(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_datetime64tz_dtype(nparr), bool), bool) + check(assert_type(api.is_datetime64tz_dtype(dtylike), bool), bool) check( - assert_type( - api.is_datetime64tz_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool - ), + assert_type(api.is_datetime64tz_dtype(dframe), bool), bool, ) - check(assert_type(api.is_datetime64tz_dtype(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_datetime64tz_dtype(ind), bool), bool) def test_is_dict_like() -> None: check(assert_type(api.is_dict_like(mapping), bool), bool) - check(assert_type(api.is_dict_like(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_dict_like(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_dict_like(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_dict_like(nparr), bool), bool) + check(assert_type(api.is_dict_like(dtylike), bool), bool) + check(assert_type(api.is_dict_like(arr), bool), bool) check( - assert_type(api.is_dict_like(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + assert_type(api.is_dict_like(dframe), bool), bool, ) - check(assert_type(api.is_dict_like(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_dict_like(ind), bool), bool) def test_is_dtype_equal() -> None: @@ -165,328 +147,287 @@ def test_is_dtype_equal() -> None: def test_is_extension_array_dtype() -> None: check(assert_type(api.is_extension_array_dtype(arr), bool), bool) - check(assert_type(api.is_extension_array_dtype(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_extension_array_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_extension_array_dtype(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_extension_array_dtype(nparr), bool), bool) + check(assert_type(api.is_extension_array_dtype(dtylike), bool), bool) check( - assert_type( - api.is_extension_array_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool - ), + assert_type(api.is_extension_array_dtype(dframe), bool), bool, ) - check(assert_type(api.is_extension_array_dtype(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_extension_array_dtype(ind), bool), bool) def test_is_file_like() -> None: check(assert_type(api.is_file_like(obj), bool), bool) - check(assert_type(api.is_file_like(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_file_like(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_file_like(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_file_like(nparr), bool), bool) + check(assert_type(api.is_file_like(dtylike), bool), bool) + check(assert_type(api.is_file_like(arr), bool), bool) check( - assert_type(api.is_file_like(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + assert_type(api.is_file_like(dframe), bool), bool, ) - check(assert_type(api.is_file_like(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_file_like(ind), bool), bool) def test_is_float() -> None: check(assert_type(api.is_float(obj), bool), bool) - check(assert_type(api.is_float(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_float(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_float(pd.Series([1, 2, 3])), bool), bool) - check( - assert_type(api.is_float(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), bool - ) - check(assert_type(api.is_float(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_float(nparr), bool), bool) + check(assert_type(api.is_float(dtylike), bool), bool) + check(assert_type(api.is_float(arr), bool), bool) + check(assert_type(api.is_float(dframe), bool), bool) + check(assert_type(api.is_float(ind), bool), bool) def test_is_float_dtype() -> None: check(assert_type(api.is_float_dtype(arr), bool), bool) - check(assert_type(api.is_float_dtype(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_float_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_float_dtype(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_float_dtype(nparr), bool), bool) + check(assert_type(api.is_float_dtype(dtylike), bool), bool) check( - assert_type(api.is_float_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + assert_type(api.is_float_dtype(dframe), bool), bool, ) - check(assert_type(api.is_float_dtype(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_float_dtype(ind), bool), bool) def test_is_hashable() -> None: check(assert_type(api.is_hashable(obj), bool), bool) - check(assert_type(api.is_hashable(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_hashable(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_hashable(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_hashable(nparr), bool), bool) + check(assert_type(api.is_hashable(dtylike), bool), bool) + check(assert_type(api.is_hashable(arr), bool), bool) check( - assert_type(api.is_hashable(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + assert_type(api.is_hashable(dframe), bool), bool, ) - check(assert_type(api.is_hashable(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_hashable(ind), bool), bool) def test_is_int64_dtype() -> None: check(assert_type(api.is_int64_dtype(arr), bool), bool) - check(assert_type(api.is_int64_dtype(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_int64_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_int64_dtype(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_int64_dtype(nparr), bool), bool) + check(assert_type(api.is_int64_dtype(dtylike), bool), bool) check( - assert_type(api.is_int64_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + assert_type(api.is_int64_dtype(dframe), bool), bool, ) - check(assert_type(api.is_int64_dtype(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_int64_dtype(ind), bool), bool) def test_is_integer() -> None: check(assert_type(api.is_integer(obj), bool), bool) - check(assert_type(api.is_integer(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_integer(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_integer(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_integer(nparr), bool), bool) + check(assert_type(api.is_integer(dtylike), bool), bool) + check(assert_type(api.is_integer(arr), bool), bool) check( - assert_type(api.is_integer(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + assert_type(api.is_integer(dframe), bool), bool, ) - check(assert_type(api.is_integer(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_integer(ind), bool), bool) def test_is_integer_dtype() -> None: check(assert_type(api.is_integer_dtype(arr), bool), bool) - check(assert_type(api.is_integer_dtype(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_integer_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_integer_dtype(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_integer_dtype(nparr), bool), bool) + check(assert_type(api.is_integer_dtype(dtylike), bool), bool) check( - assert_type( - api.is_integer_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool - ), + assert_type(api.is_integer_dtype(dframe), bool), bool, ) - check(assert_type(api.is_integer_dtype(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_integer_dtype(ind), bool), bool) def test_is_interval() -> None: check(assert_type(api.is_interval(obj), bool), bool) - check(assert_type(api.is_interval(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_interval(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_interval(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_interval(nparr), bool), bool) + check(assert_type(api.is_interval(dtylike), bool), bool) + check(assert_type(api.is_interval(arr), bool), bool) check( - assert_type(api.is_interval(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + assert_type(api.is_interval(dframe), bool), bool, ) - check(assert_type(api.is_interval(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_interval(ind), bool), bool) def test_is_interval_dtype() -> None: check(assert_type(api.is_interval_dtype(obj), bool), bool) - check(assert_type(api.is_interval(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_interval(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_interval(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_interval(nparr), bool), bool) + check(assert_type(api.is_interval(dtylike), bool), bool) + check(assert_type(api.is_interval(arr), bool), bool) check( - assert_type(api.is_interval(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + assert_type(api.is_interval(dframe), bool), bool, ) - check(assert_type(api.is_interval(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_interval(ind), bool), bool) def test_is_iterator() -> None: check(assert_type(api.is_iterator(obj), bool), bool) - check(assert_type(api.is_iterator(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_iterator(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_iterator(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_iterator(nparr), bool), bool) + check(assert_type(api.is_iterator(dtylike), bool), bool) + check(assert_type(api.is_iterator(arr), bool), bool) check( - assert_type(api.is_iterator(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + assert_type(api.is_iterator(dframe), bool), bool, ) - check(assert_type(api.is_iterator(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_iterator(ind), bool), bool) def test_is_list_like() -> None: check(assert_type(api.is_list_like(obj), bool), bool) - check(assert_type(api.is_list_like(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_list_like(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_list_like(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_list_like(nparr), bool), bool) + check(assert_type(api.is_list_like(dtylike), bool), bool) + check(assert_type(api.is_list_like(arr), bool), bool) check( - assert_type(api.is_list_like(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + assert_type(api.is_list_like(dframe), bool), bool, ) - check(assert_type(api.is_list_like(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_list_like(ind), bool), bool) def test_is_named_tuple() -> None: check(assert_type(api.is_named_tuple(obj), bool), bool) - check(assert_type(api.is_named_tuple(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_named_tuple(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_named_tuple(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_named_tuple(nparr), bool), bool) + check(assert_type(api.is_named_tuple(dtylike), bool), bool) + check(assert_type(api.is_named_tuple(arr), bool), bool) check( - assert_type(api.is_named_tuple(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), + assert_type(api.is_named_tuple(dframe), bool), bool, ) - check(assert_type(api.is_named_tuple(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_named_tuple(ind), bool), bool) def test_is_number() -> None: check(assert_type(api.is_number(obj), bool), bool) - check(assert_type(api.is_number(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_number(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_number(pd.Series([1, 2, 3])), bool), bool) - check( - assert_type(api.is_number(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), bool - ) - check(assert_type(api.is_number(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_number(nparr), bool), bool) + check(assert_type(api.is_number(dtylike), bool), bool) + check(assert_type(api.is_number(arr), bool), bool) + check(assert_type(api.is_number(dframe), bool), bool) + check(assert_type(api.is_number(ind), bool), bool) def test_is_numeric_dtype() -> None: check(assert_type(api.is_numeric_dtype(arr), bool), bool) - check(assert_type(api.is_numeric_dtype(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_numeric_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_numeric_dtype(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_numeric_dtype(nparr), bool), bool) + check(assert_type(api.is_numeric_dtype(dtylike), bool), bool) check( - assert_type( - api.is_numeric_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool - ), + assert_type(api.is_numeric_dtype(dframe), bool), bool, ) - check(assert_type(api.is_numeric_dtype(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_numeric_dtype(ind), bool), bool) def test_is_object_dtype() -> None: check(assert_type(api.is_object_dtype(arr), bool), bool) - check(assert_type(api.is_object_dtype(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_object_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_object_dtype(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_object_dtype(nparr), bool), bool) + check(assert_type(api.is_object_dtype(dtylike), bool), bool) check( - assert_type( - api.is_object_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool - ), + assert_type(api.is_object_dtype(dframe), bool), bool, ) - check(assert_type(api.is_object_dtype(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_object_dtype(ind), bool), bool) def test_is_period_dtype() -> None: check(assert_type(api.is_period_dtype(arr), bool), bool) - check(assert_type(api.is_period_dtype(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_period_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_period_dtype(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_period_dtype(nparr), bool), bool) + check(assert_type(api.is_period_dtype(dtylike), bool), bool) check( - assert_type( - api.is_period_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool - ), + assert_type(api.is_period_dtype(dframe), bool), bool, ) - check(assert_type(api.is_period_dtype(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_period_dtype(ind), bool), bool) def test_is_re() -> None: check(assert_type(api.is_re(obj), bool), bool) - check(assert_type(api.is_re(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_re(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_re(pd.Series([1, 2, 3])), bool), bool) - check(assert_type(api.is_re(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), bool) - check(assert_type(api.is_re(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_re(nparr), bool), bool) + check(assert_type(api.is_re(dtylike), bool), bool) + check(assert_type(api.is_re(arr), bool), bool) + check(assert_type(api.is_re(dframe), bool), bool) + check(assert_type(api.is_re(ind), bool), bool) def test_is_re_compilable() -> None: check(assert_type(api.is_re_compilable(obj), bool), bool) - check(assert_type(api.is_re_compilable(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_re_compilable(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_re_compilable(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_re_compilable(nparr), bool), bool) + check(assert_type(api.is_re_compilable(dtylike), bool), bool) + check(assert_type(api.is_re_compilable(arr), bool), bool) check( - assert_type( - api.is_re_compilable(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool - ), + assert_type(api.is_re_compilable(dframe), bool), bool, ) - check(assert_type(api.is_re_compilable(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_re_compilable(ind), bool), bool) def test_is_scalar() -> None: check(assert_type(api.is_scalar(obj), bool), bool) - check(assert_type(api.is_scalar(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_scalar(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_scalar(pd.Series([1, 2, 3])), bool), bool) - check( - assert_type(api.is_scalar(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), bool - ) - check(assert_type(api.is_scalar(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_scalar(nparr), bool), bool) + check(assert_type(api.is_scalar(dtylike), bool), bool) + check(assert_type(api.is_scalar(arr), bool), bool) + check(assert_type(api.is_scalar(dframe), bool), bool) + check(assert_type(api.is_scalar(ind), bool), bool) def test_is_signed_integer_dtype() -> None: check(assert_type(api.is_signed_integer_dtype(arr), bool), bool) - check(assert_type(api.is_signed_integer_dtype(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_signed_integer_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_signed_integer_dtype(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_signed_integer_dtype(nparr), bool), bool) + check(assert_type(api.is_signed_integer_dtype(dtylike), bool), bool) check( - assert_type( - api.is_signed_integer_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool - ), + assert_type(api.is_signed_integer_dtype(dframe), bool), bool, ) - check(assert_type(api.is_signed_integer_dtype(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_signed_integer_dtype(ind), bool), bool) def test_is_sparse() -> None: check(assert_type(api.is_sparse(arr), bool), bool) - check(assert_type(api.is_sparse(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_sparse(pd.Series([1, 2, 3])), bool), bool) - check( - assert_type(api.is_sparse(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool), bool - ) + check(assert_type(api.is_sparse(nparr), bool), bool) + check(assert_type(api.is_sparse(dframe), bool), bool) def test_is_string_dtype() -> None: check(assert_type(api.is_string_dtype(arr), bool), bool) - check(assert_type(api.is_string_dtype(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_string_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_string_dtype(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_string_dtype(nparr), bool), bool) + check(assert_type(api.is_string_dtype(dtylike), bool), bool) check( - assert_type( - api.is_string_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool - ), + assert_type(api.is_string_dtype(dframe), bool), bool, ) - check(assert_type(api.is_string_dtype(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_string_dtype(ind), bool), bool) def test_is_timedelta64_dtype() -> None: check(assert_type(api.is_timedelta64_dtype(arr), bool), bool) - check(assert_type(api.is_timedelta64_dtype(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_timedelta64_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_timedelta64_dtype(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_timedelta64_dtype(nparr), bool), bool) + check(assert_type(api.is_timedelta64_dtype(dtylike), bool), bool) check( - assert_type( - api.is_timedelta64_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool - ), + assert_type(api.is_timedelta64_dtype(dframe), bool), bool, ) - check(assert_type(api.is_timedelta64_dtype(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_timedelta64_dtype(ind), bool), bool) def test_is_timedelta64_ns_dtype() -> None: check(assert_type(api.is_timedelta64_ns_dtype(arr), bool), bool) - check(assert_type(api.is_timedelta64_ns_dtype(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_timedelta64_ns_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_timedelta64_ns_dtype(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_timedelta64_ns_dtype(nparr), bool), bool) + check(assert_type(api.is_timedelta64_ns_dtype(dtylike), bool), bool) check( - assert_type( - api.is_timedelta64_ns_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), bool - ), + assert_type(api.is_timedelta64_ns_dtype(dframe), bool), bool, ) - check(assert_type(api.is_timedelta64_ns_dtype(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_timedelta64_ns_dtype(ind), bool), bool) def test_is_unsigned_integer_dtype() -> None: check(assert_type(api.is_unsigned_integer_dtype(arr), bool), bool) - check(assert_type(api.is_unsigned_integer_dtype(np.array([1, 2, 3])), bool), bool) - check(assert_type(api.is_unsigned_integer_dtype(np.dtype(np.int32)), bool), bool) - check(assert_type(api.is_unsigned_integer_dtype(pd.Series([1, 2, 3])), bool), bool) + check(assert_type(api.is_unsigned_integer_dtype(nparr), bool), bool) + check(assert_type(api.is_unsigned_integer_dtype(dtylike), bool), bool) check( assert_type( - api.is_unsigned_integer_dtype(pd.DataFrame({"a": [1, 2], "b": [3, 4]})), + api.is_unsigned_integer_dtype(dframe), bool, ), bool, ) - check(assert_type(api.is_unsigned_integer_dtype(pd.Index([1, 2.0])), bool), bool) + check(assert_type(api.is_unsigned_integer_dtype(ind), bool), bool) def test_pandas_dtype() -> None: From 9ed018fcc0c476da240bf38726e6d92be9ffe225 Mon Sep 17 00:00:00 2001 From: ram vikram singh Date: Fri, 11 Nov 2022 04:53:44 +0530 Subject: [PATCH 6/6] update1 --- tests/test_api_types.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/test_api_types.py b/tests/test_api_types.py index bc89095c3..9bf7a7efb 100644 --- a/tests/test_api_types.py +++ b/tests/test_api_types.py @@ -54,7 +54,6 @@ def test_is_categorical_dtype() -> None: check(assert_type(api.is_categorical_dtype(arr), bool), bool) check(assert_type(api.is_categorical_dtype(nparr), bool), bool) check(assert_type(api.is_categorical_dtype(dtylike), bool), bool) - check(assert_type(api.is_categorical_dtype(arr), bool), bool) check( assert_type(api.is_categorical_dtype(dframe), bool), bool,