From 79f6b5000fa59fdb183abaadb19fd7a382ee74cb Mon Sep 17 00:00:00 2001
From: LarWong <larrywong418@gmail.com>
Date: Sun, 11 Apr 2021 16:33:31 -0400
Subject: [PATCH 01/11] TYP: Added overloads for fillna() in frame.py and
 series.py

---
 pandas/core/frame.py  | 348 +++++++++++++++++++++++++++++++++++++++++
 pandas/core/series.py | 349 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 697 insertions(+)

diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 64ec0801b5d8a..371b730135e23 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -5007,6 +5007,354 @@ def rename(
             errors=errors,
         )
 
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None = ...,
+        method: str | None = ...,
+        axis: Axis | None = ...,
+        inplace: Literal[False] = ...,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
+    ) -> DataFrame:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        *,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None = ...,
+        method: str | None = ...,
+        axis: Axis | None = ...,
+        inplace: bool = ...,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
+    ) -> DataFrame | None:
+        ...
+
     @doc(NDFrame.fillna, **_shared_doc_kwargs)
     def fillna(
         self,
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 968ab27d6d58c..d723f8dc37dd1 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -41,6 +41,7 @@
     FrameOrSeriesUnion,
     IndexKeyFunc,
     NpDtype,
+    Scalar,
     SingleManager,
     StorageOptions,
     ValueKeyFunc,
@@ -4572,6 +4573,354 @@ def drop(
             errors=errors,
         )
 
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None = ...,
+        method: str | None = ...,
+        axis: Axis | None = ...,
+        inplace: Literal[False] = ...,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
+    ) -> Series:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        *,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None = ...,
+        method: str | None = ...,
+        axis: Axis | None = ...,
+        inplace: bool = ...,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
+    ) -> DataFrame | None:
+        ...
+
     @doc(NDFrame.fillna, **_shared_doc_kwargs)
     def fillna(
         self,

From 9b6966ac54828627ff482710499bb71954770568 Mon Sep 17 00:00:00 2001
From: LarWong <larrywong418@gmail.com>
Date: Sun, 11 Apr 2021 16:33:31 -0400
Subject: [PATCH 02/11] TYP: Added overloads for fillna() in frame.py and
 series.py #40737

---
 pandas/core/frame.py  | 348 +++++++++++++++++++++++++++++++++++++++++
 pandas/core/series.py | 349 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 697 insertions(+)

diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 64ec0801b5d8a..371b730135e23 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -5007,6 +5007,354 @@ def rename(
             errors=errors,
         )
 
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None = ...,
+        method: str | None = ...,
+        axis: Axis | None = ...,
+        inplace: Literal[False] = ...,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
+    ) -> DataFrame:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        *,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None = ...,
+        method: str | None = ...,
+        axis: Axis | None = ...,
+        inplace: bool = ...,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
+    ) -> DataFrame | None:
+        ...
+
     @doc(NDFrame.fillna, **_shared_doc_kwargs)
     def fillna(
         self,
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 968ab27d6d58c..d723f8dc37dd1 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -41,6 +41,7 @@
     FrameOrSeriesUnion,
     IndexKeyFunc,
     NpDtype,
+    Scalar,
     SingleManager,
     StorageOptions,
     ValueKeyFunc,
@@ -4572,6 +4573,354 @@ def drop(
             errors=errors,
         )
 
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None = ...,
+        method: str | None = ...,
+        axis: Axis | None = ...,
+        inplace: Literal[False] = ...,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
+    ) -> Series:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        *,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self,
+        value: Scalar | dict | Series | DataFrame | None = ...,
+        method: str | None = ...,
+        axis: Axis | None = ...,
+        inplace: bool = ...,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
+    ) -> DataFrame | None:
+        ...
+
     @doc(NDFrame.fillna, **_shared_doc_kwargs)
     def fillna(
         self,

From fce2d11cf66a027227a41779640b427257a27402 Mon Sep 17 00:00:00 2001
From: LarWong <larrywong418@gmail.com>
Date: Sun, 11 Apr 2021 16:51:18 -0400
Subject: [PATCH 03/11] TYP: Added fillna() overloads to generic.py #40727

---
 pandas/core/generic.py | 349 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 349 insertions(+)

diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 729a3ee1f038c..bbd3fe69a2e90 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -47,6 +47,7 @@
     Manager,
     NpDtype,
     Renamer,
+    Scalar,
     StorageOptions,
     T,
     TimedeltaConvertibleTypes,
@@ -6269,6 +6270,354 @@ def convert_dtypes(
     # ----------------------------------------------------------------------
     # Filling NA's
 
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        value: Scalar | dict | Series | DataFrame | None = ...,
+        method: str | None = ...,
+        axis: Axis | None = ...,
+        inplace: Literal[False] = ...,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
+    ) -> FrameOrSeries | None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        *,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        *,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        *,
+        method: str | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        *,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        value: Scalar | dict | Series | DataFrame | None,
+        *,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        *,
+        inplace: Literal[True],
+        limit: int | None,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        *,
+        downcast: dict | str | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        value: Scalar | dict | Series | DataFrame | None,
+        method: str | None,
+        axis: Axis | None,
+        inplace: Literal[True],
+        limit: int | None,
+    ) -> None:
+        ...
+
+    @overload
+    def fillna(
+        self: FrameOrSeries,
+        value: Scalar | dict | Series | DataFrame | None = ...,
+        method: str | None = ...,
+        axis: Axis | None = ...,
+        inplace: bool_t = ...,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
+    ) -> FrameOrSeries | None:
+        ...
+
     @doc(**_shared_doc_kwargs)
     def fillna(
         self: FrameOrSeries,

From 16b42e78b39f781f90bb6dd7db5ed964b6934bc4 Mon Sep 17 00:00:00 2001
From: LarWong <larrywong418@gmail.com>
Date: Sun, 11 Apr 2021 18:31:32 -0400
Subject: [PATCH 04/11] TYP: removed generic overloads #40737

---
 pandas/core/generic.py | 349 -----------------------------------------
 pandas/core/series.py  |   2 +-
 2 files changed, 1 insertion(+), 350 deletions(-)

diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index bbd3fe69a2e90..729a3ee1f038c 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -47,7 +47,6 @@
     Manager,
     NpDtype,
     Renamer,
-    Scalar,
     StorageOptions,
     T,
     TimedeltaConvertibleTypes,
@@ -6270,354 +6269,6 @@ def convert_dtypes(
     # ----------------------------------------------------------------------
     # Filling NA's
 
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        value: Scalar | dict | Series | DataFrame | None = ...,
-        method: str | None = ...,
-        axis: Axis | None = ...,
-        inplace: Literal[False] = ...,
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
-    ) -> FrameOrSeries | None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        *,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        *,
-        method: str | None,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        *,
-        inplace: Literal[True],
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        *,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        inplace: Literal[True],
-        limit: int | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        inplace: Literal[True],
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        *,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        *,
-        method: str | None,
-        inplace: Literal[True],
-        limit: int | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        *,
-        method: str | None,
-        inplace: Literal[True],
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit: int | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        *,
-        inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        *,
-        inplace: Literal[True],
-        limit: int | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        *,
-        inplace: Literal[True],
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit: int | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        *,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit: int | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        *,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        *,
-        method: str | None,
-        inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        *,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        *,
-        inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-        *,
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit: int | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self: FrameOrSeries,
-        value: Scalar | dict | Series | DataFrame | None = ...,
-        method: str | None = ...,
-        axis: Axis | None = ...,
-        inplace: bool_t = ...,
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
-    ) -> FrameOrSeries | None:
-        ...
-
     @doc(**_shared_doc_kwargs)
     def fillna(
         self: FrameOrSeries,
diff --git a/pandas/core/series.py b/pandas/core/series.py
index d723f8dc37dd1..d946de7f4b079 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -4918,7 +4918,7 @@ def fillna(
         inplace: bool = ...,
         limit: int | None = ...,
         downcast: dict | str | None = ...,
-    ) -> DataFrame | None:
+    ) -> Series | None:
         ...
 
     @doc(NDFrame.fillna, **_shared_doc_kwargs)

From 2ab41f8feac128409ec5821c7f60d0a6bca29c4e Mon Sep 17 00:00:00 2001
From: LarWong <larrywong418@gmail.com>
Date: Mon, 12 Apr 2021 10:50:42 -0400
Subject: [PATCH 05/11] fixed redundant cast error

---
 pandas/core/strings/object_array.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/pandas/core/strings/object_array.py b/pandas/core/strings/object_array.py
index f2027f2707a8b..dc4550484fa3b 100644
--- a/pandas/core/strings/object_array.py
+++ b/pandas/core/strings/object_array.py
@@ -5,7 +5,6 @@
     Pattern,
     Set,
     Union,
-    cast,
 )
 import unicodedata
 import warnings
@@ -371,9 +370,7 @@ def _str_get_dummies(self, sep="|"):
         try:
             arr = sep + arr + sep
         except TypeError:
-            arr = cast(Series, arr)
             arr = sep + arr.astype(str) + sep
-        arr = cast(Series, arr)
 
         tags: Set[str] = set()
         for ts in Series(arr).str.split(sep):

From a641df2fa412fef3c9f7926226e9044869b8f58c Mon Sep 17 00:00:00 2001
From: LarWong <larrywong418@gmail.com>
Date: Mon, 12 Apr 2021 12:14:48 -0400
Subject: [PATCH 06/11] reverting prior changes

---
 pandas/core/strings/object_array.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/pandas/core/strings/object_array.py b/pandas/core/strings/object_array.py
index dc4550484fa3b..f2027f2707a8b 100644
--- a/pandas/core/strings/object_array.py
+++ b/pandas/core/strings/object_array.py
@@ -5,6 +5,7 @@
     Pattern,
     Set,
     Union,
+    cast,
 )
 import unicodedata
 import warnings
@@ -370,7 +371,9 @@ def _str_get_dummies(self, sep="|"):
         try:
             arr = sep + arr + sep
         except TypeError:
+            arr = cast(Series, arr)
             arr = sep + arr.astype(str) + sep
+        arr = cast(Series, arr)
 
         tags: Set[str] = set()
         for ts in Series(arr).str.split(sep):

From 45cc60ce8b97d48cf40710b8fc5c32953b4f90b2 Mon Sep 17 00:00:00 2001
From: LarWong <larrywong418@gmail.com>
Date: Mon, 12 Apr 2021 13:35:02 -0400
Subject: [PATCH 07/11] remove cast again

---
 pandas/core/strings/object_array.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/pandas/core/strings/object_array.py b/pandas/core/strings/object_array.py
index f2027f2707a8b..dc4550484fa3b 100644
--- a/pandas/core/strings/object_array.py
+++ b/pandas/core/strings/object_array.py
@@ -5,7 +5,6 @@
     Pattern,
     Set,
     Union,
-    cast,
 )
 import unicodedata
 import warnings
@@ -371,9 +370,7 @@ def _str_get_dummies(self, sep="|"):
         try:
             arr = sep + arr + sep
         except TypeError:
-            arr = cast(Series, arr)
             arr = sep + arr.astype(str) + sep
-        arr = cast(Series, arr)
 
         tags: Set[str] = set()
         for ts in Series(arr).str.split(sep):

From b6a4fac7c45deb8a0d630268b20beff973221341 Mon Sep 17 00:00:00 2001
From: LarWong <larrywong418@gmail.com>
Date: Mon, 12 Apr 2021 16:52:20 -0400
Subject: [PATCH 08/11] removed unnecessary overloads in frame.py and series.py

---
 pandas/core/frame.py  | 233 ------------------------------------------
 pandas/core/series.py | 233 ------------------------------------------
 2 files changed, 466 deletions(-)

diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 371b730135e23..415b44415d85d 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -5036,195 +5036,7 @@ def fillna(
         self,
         *,
         inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        method: str | None,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        inplace: Literal[True],
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        *,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        inplace: Literal[True],
-        limit: int | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        inplace: Literal[True],
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        method: str | None,
-        inplace: Literal[True],
         limit: int | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        method: str | None,
-        inplace: Literal[True],
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit: int | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        *,
-        inplace: Literal[True],
-        limit: int | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        *,
-        inplace: Literal[True],
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit: int | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
         downcast: dict | str | None,
     ) -> None:
         ...
@@ -5240,28 +5052,6 @@ def fillna(
     ) -> None:
         ...
 
-    @overload
-    def fillna(
-        self,
-        *,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit: int | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
     @overload
     def fillna(
         self,
@@ -5320,29 +5110,6 @@ def fillna(
     ) -> None:
         ...
 
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-        *,
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit: int | None,
-    ) -> None:
-        ...
-
     @overload
     def fillna(
         self,
diff --git a/pandas/core/series.py b/pandas/core/series.py
index bdda658c9bebe..f4ecadb7929ae 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -4618,195 +4618,7 @@ def fillna(
         self,
         *,
         inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        method: str | None,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        inplace: Literal[True],
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        *,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        inplace: Literal[True],
-        limit: int | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        inplace: Literal[True],
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        method: str | None,
-        inplace: Literal[True],
         limit: int | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        method: str | None,
-        inplace: Literal[True],
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit: int | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        *,
-        inplace: Literal[True],
-        limit: int | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        *,
-        inplace: Literal[True],
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit: int | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        *,
-        axis: Axis | None,
-        inplace: Literal[True],
         downcast: dict | str | None,
     ) -> None:
         ...
@@ -4822,28 +4634,6 @@ def fillna(
     ) -> None:
         ...
 
-    @overload
-    def fillna(
-        self,
-        *,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit: int | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        *,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
     @overload
     def fillna(
         self,
@@ -4902,29 +4692,6 @@ def fillna(
     ) -> None:
         ...
 
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-        *,
-        downcast: dict | str | None,
-    ) -> None:
-        ...
-
-    @overload
-    def fillna(
-        self,
-        value: Scalar | dict | Series | DataFrame | None,
-        method: str | None,
-        axis: Axis | None,
-        inplace: Literal[True],
-        limit: int | None,
-    ) -> None:
-        ...
-
     @overload
     def fillna(
         self,

From 2adcaf722b72382e0a0862ba09d5dec5c3a297da Mon Sep 17 00:00:00 2001
From: LarWong <larrywong418@gmail.com>
Date: Mon, 12 Apr 2021 17:22:06 -0400
Subject: [PATCH 09/11] fixed overloads

---
 pandas/core/frame.py  | 32 ++++++++++++++++----------------
 pandas/core/series.py | 32 ++++++++++++++++----------------
 2 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 415b44415d85d..a054477cb7e80 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -5026,8 +5026,8 @@ def fillna(
         method: str | None,
         axis: Axis | None,
         inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
     ) -> None:
         ...
 
@@ -5036,8 +5036,8 @@ def fillna(
         self,
         *,
         inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
     ) -> None:
         ...
 
@@ -5047,8 +5047,8 @@ def fillna(
         value: Scalar | dict | Series | DataFrame | None,
         *,
         inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
     ) -> None:
         ...
 
@@ -5058,8 +5058,8 @@ def fillna(
         *,
         method: str | None,
         inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
     ) -> None:
         ...
 
@@ -5069,8 +5069,8 @@ def fillna(
         *,
         axis: Axis | None,
         inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
     ) -> None:
         ...
 
@@ -5081,8 +5081,8 @@ def fillna(
         method: str | None,
         axis: Axis | None,
         inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
     ) -> None:
         ...
 
@@ -5093,8 +5093,8 @@ def fillna(
         *,
         axis: Axis | None,
         inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
     ) -> None:
         ...
 
@@ -5105,8 +5105,8 @@ def fillna(
         method: str | None,
         *,
         inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
     ) -> None:
         ...
 
diff --git a/pandas/core/series.py b/pandas/core/series.py
index f4ecadb7929ae..701218d1548fb 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -4608,8 +4608,8 @@ def fillna(
         method: str | None,
         axis: Axis | None,
         inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
     ) -> None:
         ...
 
@@ -4618,8 +4618,8 @@ def fillna(
         self,
         *,
         inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
     ) -> None:
         ...
 
@@ -4629,8 +4629,8 @@ def fillna(
         value: Scalar | dict | Series | DataFrame | None,
         *,
         inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
     ) -> None:
         ...
 
@@ -4640,8 +4640,8 @@ def fillna(
         *,
         method: str | None,
         inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
     ) -> None:
         ...
 
@@ -4651,8 +4651,8 @@ def fillna(
         *,
         axis: Axis | None,
         inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
     ) -> None:
         ...
 
@@ -4663,8 +4663,8 @@ def fillna(
         method: str | None,
         axis: Axis | None,
         inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
     ) -> None:
         ...
 
@@ -4675,8 +4675,8 @@ def fillna(
         *,
         axis: Axis | None,
         inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
     ) -> None:
         ...
 
@@ -4687,8 +4687,8 @@ def fillna(
         method: str | None,
         *,
         inplace: Literal[True],
-        limit: int | None,
-        downcast: dict | str | None,
+        limit: int | None = ...,
+        downcast: dict | str | None = ...,
     ) -> None:
         ...
 

From 0c3d28dab262a8e5c1f1e1f3e62dc73ec155a33b Mon Sep 17 00:00:00 2001
From: LarWong <larrywong418@gmail.com>
Date: Thu, 15 Apr 2021 11:01:50 -0400
Subject: [PATCH 10/11] reverted value typing

---
 pandas/core/frame.py  | 12 ++++++------
 pandas/core/series.py | 13 ++++++-------
 2 files changed, 12 insertions(+), 13 deletions(-)

diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 14ce9e54c589e..c838abfeb97c2 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -5010,7 +5010,7 @@ def rename(
     @overload
     def fillna(
         self,
-        value: Scalar | dict | Series | DataFrame | None = ...,
+        value=...,
         method: str | None = ...,
         axis: Axis | None = ...,
         inplace: Literal[False] = ...,
@@ -5022,7 +5022,7 @@ def fillna(
     @overload
     def fillna(
         self,
-        value: Scalar | dict | Series | DataFrame | None,
+        value,
         method: str | None,
         axis: Axis | None,
         inplace: Literal[True],
@@ -5044,7 +5044,7 @@ def fillna(
     @overload
     def fillna(
         self,
-        value: Scalar | dict | Series | DataFrame | None,
+        value,
         *,
         inplace: Literal[True],
         limit: int | None = ...,
@@ -5089,7 +5089,7 @@ def fillna(
     @overload
     def fillna(
         self,
-        value: Scalar | dict | Series | DataFrame | None,
+        value,
         *,
         axis: Axis | None,
         inplace: Literal[True],
@@ -5101,7 +5101,7 @@ def fillna(
     @overload
     def fillna(
         self,
-        value: Scalar | dict | Series | DataFrame | None,
+        value,
         method: str | None,
         *,
         inplace: Literal[True],
@@ -5113,7 +5113,7 @@ def fillna(
     @overload
     def fillna(
         self,
-        value: Scalar | dict | Series | DataFrame | None = ...,
+        value=...,
         method: str | None = ...,
         axis: Axis | None = ...,
         inplace: bool = ...,
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 6c1683342b1c4..7f0d4266b2e6c 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -41,7 +41,6 @@
     FrameOrSeriesUnion,
     IndexKeyFunc,
     NpDtype,
-    Scalar,
     SingleManager,
     StorageOptions,
     ValueKeyFunc,
@@ -4585,7 +4584,7 @@ def drop(
     @overload
     def fillna(
         self,
-        value: Scalar | dict | Series | DataFrame | None = ...,
+        value=...,
         method: str | None = ...,
         axis: Axis | None = ...,
         inplace: Literal[False] = ...,
@@ -4597,7 +4596,7 @@ def fillna(
     @overload
     def fillna(
         self,
-        value: Scalar | dict | Series | DataFrame | None,
+        value,
         method: str | None,
         axis: Axis | None,
         inplace: Literal[True],
@@ -4619,7 +4618,7 @@ def fillna(
     @overload
     def fillna(
         self,
-        value: Scalar | dict | Series | DataFrame | None,
+        value,
         *,
         inplace: Literal[True],
         limit: int | None = ...,
@@ -4664,7 +4663,7 @@ def fillna(
     @overload
     def fillna(
         self,
-        value: Scalar | dict | Series | DataFrame | None,
+        value,
         *,
         axis: Axis | None,
         inplace: Literal[True],
@@ -4676,7 +4675,7 @@ def fillna(
     @overload
     def fillna(
         self,
-        value: Scalar | dict | Series | DataFrame | None,
+        value,
         method: str | None,
         *,
         inplace: Literal[True],
@@ -4688,7 +4687,7 @@ def fillna(
     @overload
     def fillna(
         self,
-        value: Scalar | dict | Series | DataFrame | None = ...,
+        value=...,
         method: str | None = ...,
         axis: Axis | None = ...,
         inplace: bool = ...,

From 1c8dd1a6e499e6bc69a6c879b49b69f356d37e56 Mon Sep 17 00:00:00 2001
From: Marco Gorelli <marcogorelli@protonmail.com>
Date: Thu, 15 Apr 2021 18:14:40 +0100
Subject: [PATCH 11/11] remove extra types (lets keep this to overloads)

---
 pandas/core/frame.py  | 40 ++++++++++++++++++++--------------------
 pandas/core/series.py | 40 ++++++++++++++++++++--------------------
 2 files changed, 40 insertions(+), 40 deletions(-)

diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index c838abfeb97c2..37fc5de95b3d2 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -5014,8 +5014,8 @@ def fillna(
         method: str | None = ...,
         axis: Axis | None = ...,
         inplace: Literal[False] = ...,
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> DataFrame:
         ...
 
@@ -5026,8 +5026,8 @@ def fillna(
         method: str | None,
         axis: Axis | None,
         inplace: Literal[True],
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> None:
         ...
 
@@ -5036,8 +5036,8 @@ def fillna(
         self,
         *,
         inplace: Literal[True],
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> None:
         ...
 
@@ -5047,8 +5047,8 @@ def fillna(
         value,
         *,
         inplace: Literal[True],
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> None:
         ...
 
@@ -5058,8 +5058,8 @@ def fillna(
         *,
         method: str | None,
         inplace: Literal[True],
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> None:
         ...
 
@@ -5069,8 +5069,8 @@ def fillna(
         *,
         axis: Axis | None,
         inplace: Literal[True],
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> None:
         ...
 
@@ -5081,8 +5081,8 @@ def fillna(
         method: str | None,
         axis: Axis | None,
         inplace: Literal[True],
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> None:
         ...
 
@@ -5093,8 +5093,8 @@ def fillna(
         *,
         axis: Axis | None,
         inplace: Literal[True],
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> None:
         ...
 
@@ -5105,8 +5105,8 @@ def fillna(
         method: str | None,
         *,
         inplace: Literal[True],
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> None:
         ...
 
@@ -5117,8 +5117,8 @@ def fillna(
         method: str | None = ...,
         axis: Axis | None = ...,
         inplace: bool = ...,
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> DataFrame | None:
         ...
 
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 7f0d4266b2e6c..5c605a6b441c6 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -4588,8 +4588,8 @@ def fillna(
         method: str | None = ...,
         axis: Axis | None = ...,
         inplace: Literal[False] = ...,
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> Series:
         ...
 
@@ -4600,8 +4600,8 @@ def fillna(
         method: str | None,
         axis: Axis | None,
         inplace: Literal[True],
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> None:
         ...
 
@@ -4610,8 +4610,8 @@ def fillna(
         self,
         *,
         inplace: Literal[True],
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> None:
         ...
 
@@ -4621,8 +4621,8 @@ def fillna(
         value,
         *,
         inplace: Literal[True],
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> None:
         ...
 
@@ -4632,8 +4632,8 @@ def fillna(
         *,
         method: str | None,
         inplace: Literal[True],
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> None:
         ...
 
@@ -4643,8 +4643,8 @@ def fillna(
         *,
         axis: Axis | None,
         inplace: Literal[True],
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> None:
         ...
 
@@ -4655,8 +4655,8 @@ def fillna(
         method: str | None,
         axis: Axis | None,
         inplace: Literal[True],
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> None:
         ...
 
@@ -4667,8 +4667,8 @@ def fillna(
         *,
         axis: Axis | None,
         inplace: Literal[True],
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> None:
         ...
 
@@ -4679,8 +4679,8 @@ def fillna(
         method: str | None,
         *,
         inplace: Literal[True],
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> None:
         ...
 
@@ -4691,8 +4691,8 @@ def fillna(
         method: str | None = ...,
         axis: Axis | None = ...,
         inplace: bool = ...,
-        limit: int | None = ...,
-        downcast: dict | str | None = ...,
+        limit=...,
+        downcast=...,
     ) -> Series | None:
         ...