From 5c34a35a8323c2429fb1af87cd6629a50d9b0bb4 Mon Sep 17 00:00:00 2001
From: Austin Robinson <austinziech@gmail.com>
Date: Wed, 2 Dec 2020 11:02:14 -0700
Subject: [PATCH 1/9] converted all C408 errors to dict literals

---
 pandas/core/strings/accessor.py | 126 ++++++++++++++++----------------
 1 file changed, 63 insertions(+), 63 deletions(-)

diff --git a/pandas/core/strings/accessor.py b/pandas/core/strings/accessor.py
index 9d16beba669ca..8b84a59f53052 100644
--- a/pandas/core/strings/accessor.py
+++ b/pandas/core/strings/accessor.py
@@ -26,7 +26,7 @@
 
 from pandas.core.base import NoNewAttributesMixin
 
-_shared_docs: Dict[str, str] = dict()
+_shared_docs: Dict[str, str] = {}
 _cpython_optimized_encoders = (
     "utf-8",
     "utf8",
@@ -236,12 +236,12 @@ def __iter__(self):
             g = self.get(i)
 
     def _wrap_result(
-        self,
-        result,
-        name=None,
-        expand=None,
-        fill_value=np.nan,
-        returns_string=True,
+            self,
+            result,
+            name=None,
+            expand=None,
+            fill_value=np.nan,
+            returns_string=True,
     ):
         from pandas import Index, MultiIndex
 
@@ -371,9 +371,9 @@ def _get_series_list(self, others):
             # in case of list-like `others`, all elements must be
             # either Series/Index/np.ndarray (1-dim)...
             if all(
-                isinstance(x, (ABCSeries, ABCIndexClass))
-                or (isinstance(x, np.ndarray) and x.ndim == 1)
-                for x in others
+                    isinstance(x, (ABCSeries, ABCIndexClass))
+                    or (isinstance(x, np.ndarray) and x.ndim == 1)
+                    for x in others
             ):
                 los: List[Series] = []
                 while others:  # iterate through list and append each element
@@ -840,7 +840,7 @@ def rsplit(self, pat=None, n=-1, expand=False):
         % {
             "side": "first",
             "return": "3 elements containing the string itself, followed by two "
-            "empty strings",
+                      "empty strings",
             "also": "rpartition : Split the string at the last occurrence of `sep`.",
         }
     )
@@ -854,7 +854,7 @@ def partition(self, sep=" ", expand=True):
         % {
             "side": "last",
             "return": "3 elements containing two empty strings, followed by the "
-            "string itself",
+                      "string itself",
             "also": "partition : Split the string at the first occurrence of `sep`.",
         }
     )
@@ -1446,17 +1446,17 @@ def pad(self, width, side="left", fillchar=" "):
     filled : Series/Index of objects.
     """
 
-    @Appender(_shared_docs["str_pad"] % dict(side="left and right", method="center"))
+    @Appender(_shared_docs["str_pad"] % {"side": "left and right", "method": "center"})
     @forbid_nonstring_types(["bytes"])
     def center(self, width, fillchar=" "):
         return self.pad(width, side="both", fillchar=fillchar)
 
-    @Appender(_shared_docs["str_pad"] % dict(side="right", method="ljust"))
+    @Appender(_shared_docs["str_pad"] % {"side": "right", "method": "ljust"})
     @forbid_nonstring_types(["bytes"])
     def ljust(self, width, fillchar=" "):
         return self.pad(width, side="right", fillchar=fillchar)
 
-    @Appender(_shared_docs["str_pad"] % dict(side="left", method="rjust"))
+    @Appender(_shared_docs["str_pad"] % {"side": "left", "method": "rjust"})
     @forbid_nonstring_types(["bytes"])
     def rjust(self, width, fillchar=" "):
         return self.pad(width, side="left", fillchar=fillchar)
@@ -1790,9 +1790,9 @@ def encode(self, encoding, errors="strict"):
 
     @Appender(
         _shared_docs["str_strip"]
-        % dict(
-            side="left and right sides", method="strip", position="leading and trailing"
-        )
+        % {
+            "side": "left and right sides", "method": "strip", "position": "leading and trailing"
+        }
     )
     @forbid_nonstring_types(["bytes"])
     def strip(self, to_strip=None):
@@ -1801,7 +1801,7 @@ def strip(self, to_strip=None):
 
     @Appender(
         _shared_docs["str_strip"]
-        % dict(side="left side", method="lstrip", position="leading")
+        % {"side": "left side", "method": "lstrip", "position": "leading"}
     )
     @forbid_nonstring_types(["bytes"])
     def lstrip(self, to_strip=None):
@@ -1810,7 +1810,7 @@ def lstrip(self, to_strip=None):
 
     @Appender(
         _shared_docs["str_strip"]
-        % dict(side="right side", method="rstrip", position="trailing")
+        % {"side": "right side", "method": "rstrip", "position": "trailing"}
     )
     @forbid_nonstring_types(["bytes"])
     def rstrip(self, to_strip=None):
@@ -2412,11 +2412,11 @@ def extractall(self, pat, flags=0):
 
     @Appender(
         _shared_docs["find"]
-        % dict(
-            side="lowest",
-            method="find",
-            also="rfind : Return highest indexes in each strings.",
-        )
+        % {
+            "side": "lowest",
+            "method": "find",
+            "also": "rfind : Return highest indexes in each strings.",
+        }
     )
     @forbid_nonstring_types(["bytes"])
     def find(self, sub, start=0, end=None):
@@ -2429,11 +2429,11 @@ def find(self, sub, start=0, end=None):
 
     @Appender(
         _shared_docs["find"]
-        % dict(
-            side="highest",
-            method="rfind",
-            also="find : Return lowest indexes in each strings.",
-        )
+        % {
+            "side": "highest",
+            "method": "rfind",
+            "also": "find : Return lowest indexes in each strings.",
+        }
     )
     @forbid_nonstring_types(["bytes"])
     def rfind(self, sub, start=0, end=None):
@@ -2495,12 +2495,12 @@ def normalize(self, form):
 
     @Appender(
         _shared_docs["index"]
-        % dict(
-            side="lowest",
-            similar="find",
-            method="index",
-            also="rindex : Return highest indexes in each strings.",
-        )
+        % {
+            "side": "lowest",
+            "similar": "find",
+            "method": "index",
+            "also": "rindex : Return highest indexes in each strings.",
+        }
     )
     @forbid_nonstring_types(["bytes"])
     def index(self, sub, start=0, end=None):
@@ -2513,12 +2513,12 @@ def index(self, sub, start=0, end=None):
 
     @Appender(
         _shared_docs["index"]
-        % dict(
-            side="highest",
-            similar="rfind",
-            method="rindex",
-            also="index : Return lowest indexes in each strings.",
-        )
+        % {
+            "side": "highest",
+            "similar": "rfind",
+            "method": "rindex",
+            "also": "index : Return lowest indexes in each strings.",
+        }
     )
     @forbid_nonstring_types(["bytes"])
     def rindex(self, sub, start=0, end=None):
@@ -2653,18 +2653,18 @@ def len(self):
     #     isalpha, isnumeric isalnum isdigit isdecimal isspace islower isupper istitle
     # _doc_args holds dict of strings to use in substituting casemethod docs
     _doc_args: Dict[str, Dict[str, str]] = {}
-    _doc_args["lower"] = dict(type="lowercase", method="lower", version="")
-    _doc_args["upper"] = dict(type="uppercase", method="upper", version="")
-    _doc_args["title"] = dict(type="titlecase", method="title", version="")
-    _doc_args["capitalize"] = dict(
-        type="be capitalized", method="capitalize", version=""
-    )
-    _doc_args["swapcase"] = dict(type="be swapcased", method="swapcase", version="")
-    _doc_args["casefold"] = dict(
-        type="be casefolded",
-        method="casefold",
-        version="\n    .. versionadded:: 0.25.0\n",
-    )
+    _doc_args["lower"] = {"type": "lowercase", "method": "lower", "version": ""}
+    _doc_args["upper"] = {"type": "uppercase", "method": "upper", "version": ""}
+    _doc_args["title"] = {"type": "titlecase", "method": "title", "version": ""}
+    _doc_args["capitalize"] = {
+        "type": "be capitalized", "method": "capitalize", "version": ""
+    }
+    _doc_args["swapcase"] = {"type": "be swapcased", "method": "swapcase", "version": ""}
+    _doc_args["casefold"] = {
+     "type": "be casefolded",
+     "method": "casefold",
+     "version": "\n    .. versionadded:: 0.25.0\n"}
+
 
     @Appender(_shared_docs["casemethods"] % _doc_args["lower"])
     @forbid_nonstring_types(["bytes"])
@@ -2844,15 +2844,15 @@ def casefold(self):
     3    False
     dtype: bool
     """
-    _doc_args["isalnum"] = dict(type="alphanumeric", method="isalnum")
-    _doc_args["isalpha"] = dict(type="alphabetic", method="isalpha")
-    _doc_args["isdigit"] = dict(type="digits", method="isdigit")
-    _doc_args["isspace"] = dict(type="whitespace", method="isspace")
-    _doc_args["islower"] = dict(type="lowercase", method="islower")
-    _doc_args["isupper"] = dict(type="uppercase", method="isupper")
-    _doc_args["istitle"] = dict(type="titlecase", method="istitle")
-    _doc_args["isnumeric"] = dict(type="numeric", method="isnumeric")
-    _doc_args["isdecimal"] = dict(type="decimal", method="isdecimal")
+    _doc_args["isalnum"] = {"type": "alphanumeric", "method": "isalnum"}
+    _doc_args["isalpha"] = {"type": "alphabetic", "method": "isalpha"}
+    _doc_args["isdigit"] = {"type": "digits", "method": "isdigit"}
+    _doc_args["isspace"] = {"type": "whitespace", "method": "isspace"}
+    _doc_args["islower"] = {"type": "lowercase", "method": "islower"}
+    _doc_args["isupper"] = {"type": "uppercase", "method": "isupper"}
+    _doc_args["istitle"] = {"type": "titlecase", "method": "istitle"}
+    _doc_args["isnumeric"] = {"type": "numeric", "method": "isnumeric"}
+    _doc_args["isdecimal"] = {"type": "decimal", "method": "isdecimal"}
     # force _noarg_wrapper return type with dtype=np.dtype(bool) (GH 29624)
 
     isalnum = _map_and_wrap(

From 54baccdc14f1ae07aae13145e8021484577ad72d Mon Sep 17 00:00:00 2001
From: Austin Robinson <austinziech@gmail.com>
Date: Wed, 2 Dec 2020 11:23:48 -0700
Subject: [PATCH 2/9] fixed all C408 errors in core/arrays

---
 pandas/core/arrays/base.py     |  4 +-
 pandas/core/arrays/floating.py |  4 +-
 pandas/core/arrays/interval.py | 78 +++++++++++++++++-----------------
 pandas/core/arrays/numpy_.py   | 18 ++++----
 4 files changed, 52 insertions(+), 52 deletions(-)

diff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py
index 76b7877b0ac70..4197f25ed9e6c 100644
--- a/pandas/core/arrays/base.py
+++ b/pandas/core/arrays/base.py
@@ -49,7 +49,7 @@
 from pandas.core.missing import get_fill_func
 from pandas.core.sorting import nargminmax, nargsort
 
-_extension_array_shared_docs: Dict[str, str] = dict()
+_extension_array_shared_docs: Dict[str, str] = {}
 
 ExtensionArrayT = TypeVar("ExtensionArrayT", bound="ExtensionArray")
 
@@ -952,7 +952,7 @@ def factorize(self, na_sentinel: int = -1) -> Tuple[np.ndarray, ExtensionArray]:
     @Substitution(klass="ExtensionArray")
     @Appender(_extension_array_shared_docs["repeat"])
     def repeat(self, repeats, axis=None):
-        nv.validate_repeat(tuple(), dict(axis=axis))
+        nv.validate_repeat((), {'axis': axis})
         ind = np.arange(len(self)).repeat(repeats)
         return self.take(ind)
 
diff --git a/pandas/core/arrays/floating.py b/pandas/core/arrays/floating.py
index 4aed39d7edb92..fe3a7ae3c8631 100644
--- a/pandas/core/arrays/floating.py
+++ b/pandas/core/arrays/floating.py
@@ -386,9 +386,9 @@ def astype(self, dtype, copy: bool = True) -> ArrayLike:
         # coerce
         if is_float_dtype(dtype):
             # In astype, we consider dtype=float to also mean na_value=np.nan
-            kwargs = dict(na_value=np.nan)
+            kwargs = {"na_value": np.nan}
         elif is_datetime64_dtype(dtype):
-            kwargs = dict(na_value=np.datetime64("NaT"))
+            kwargs = {"na_value": np.datetime64("NaT")}
         else:
             kwargs = {}
 
diff --git a/pandas/core/arrays/interval.py b/pandas/core/arrays/interval.py
index 757cea2c710b2..142f07cf39e4d 100644
--- a/pandas/core/arrays/interval.py
+++ b/pandas/core/arrays/interval.py
@@ -57,9 +57,9 @@
 
 _interval_shared_docs = {}
 
-_shared_docs_kwargs = dict(
-    klass="IntervalArray", qualname="arrays.IntervalArray", name=""
-)
+_shared_docs_kwargs = {
+    "klass": "IntervalArray", "qualname": "arrays.IntervalArray", "name": ""
+}
 
 
 _interval_shared_docs[
@@ -127,14 +127,14 @@
 
 @Appender(
     _interval_shared_docs["class"]
-    % dict(
-        klass="IntervalArray",
-        summary="Pandas array for interval data that are closed on the same side.",
-        versionadded="0.24.0",
-        name="",
-        extra_attributes="",
-        extra_methods="",
-        examples=textwrap.dedent(
+    % {
+        "klass": "IntervalArray",
+        "summary": "Pandas array for interval data that are closed on the same side.",
+        "versionadded": "0.24.0",
+        "name": "",
+        "extra_attributes": "",
+        "extra_methods": "",
+        "examples": textwrap.dedent(
             """\
     Examples
     --------
@@ -151,7 +151,7 @@
     :meth:`IntervalArray.from_breaks`, and :meth:`IntervalArray.from_tuples`.
     """
         ),
-    )
+    }
 )
 class IntervalArray(IntervalMixin, ExtensionArray):
     ndim = 1
@@ -319,9 +319,9 @@ def _from_factorized(cls, values, original):
     @classmethod
     @Appender(
         _interval_shared_docs["from_breaks"]
-        % dict(
-            klass="IntervalArray",
-            examples=textwrap.dedent(
+        % {
+            "klass": "IntervalArray",
+            "examples": textwrap.dedent(
                 """\
         Examples
         --------
@@ -331,7 +331,7 @@ def _from_factorized(cls, values, original):
         Length: 3, closed: right, dtype: interval[int64]
         """
             ),
-        )
+        }
     )
     def from_breaks(cls, breaks, closed="right", copy=False, dtype=None):
         breaks = maybe_convert_platform_interval(breaks)
@@ -390,9 +390,9 @@ def from_breaks(cls, breaks, closed="right", copy=False, dtype=None):
     @classmethod
     @Appender(
         _interval_shared_docs["from_arrays"]
-        % dict(
-            klass="IntervalArray",
-            examples=textwrap.dedent(
+        % {
+            "klass": "IntervalArray",
+            "examples": textwrap.dedent(
                 """\
         >>> pd.arrays.IntervalArray.from_arrays([0, 1, 2], [1, 2, 3])
         <IntervalArray>
@@ -400,7 +400,7 @@ def from_breaks(cls, breaks, closed="right", copy=False, dtype=None):
         Length: 3, closed: right, dtype: interval[int64]
         """
             ),
-        )
+        }
     )
     def from_arrays(cls, left, right, closed="right", copy=False, dtype=None):
         left = maybe_convert_platform_interval(left)
@@ -445,9 +445,9 @@ def from_arrays(cls, left, right, closed="right", copy=False, dtype=None):
     @classmethod
     @Appender(
         _interval_shared_docs["from_tuples"]
-        % dict(
-            klass="IntervalArray",
-            examples=textwrap.dedent(
+        % {
+            "klass": "IntervalArray",
+            "examples": textwrap.dedent(
                 """\
         Examples
         --------
@@ -457,7 +457,7 @@ def from_arrays(cls, left, right, closed="right", copy=False, dtype=None):
         Length: 2, closed: right, dtype: interval[int64]
         """
             ),
-        )
+        }
     )
     def from_tuples(cls, data, closed="right", copy=False, dtype=None):
         if len(data):
@@ -904,7 +904,7 @@ def take(self, indices, *, allow_fill=False, fill_value=None, axis=None, **kwarg
             When `indices` contains negative values other than ``-1``
             and `allow_fill` is True.
         """
-        nv.validate_take(tuple(), kwargs)
+        nv.validate_take((), kwargs)
 
         fill_left = fill_right = fill_value
         if allow_fill:
@@ -1144,9 +1144,9 @@ def mid(self):
 
     @Appender(
         _interval_shared_docs["overlaps"]
-        % dict(
-            klass="IntervalArray",
-            examples=textwrap.dedent(
+        % {
+            "klass": "IntervalArray",
+            "examples": textwrap.dedent(
                 """\
         >>> data = [(0, 1), (1, 3), (2, 4)]
         >>> intervals = pd.arrays.IntervalArray.from_tuples(data)
@@ -1156,7 +1156,7 @@ def mid(self):
         Length: 3, closed: right, dtype: interval[int64]
         """
             ),
-        )
+        }
     )
     def overlaps(self, other):
         if isinstance(other, (IntervalArray, ABCIntervalIndex)):
@@ -1207,9 +1207,9 @@ def closed(self):
 
     @Appender(
         _interval_shared_docs["set_closed"]
-        % dict(
-            klass="IntervalArray",
-            examples=textwrap.dedent(
+        % {
+            "klass": "IntervalArray",
+            "examples": textwrap.dedent(
                 """\
         Examples
         --------
@@ -1224,7 +1224,7 @@ def closed(self):
         Length: 3, closed: both, dtype: interval[int64]
         """
             ),
-        )
+        }
     )
     def set_closed(self, closed):
         if closed not in VALID_CLOSED:
@@ -1360,7 +1360,7 @@ def __arrow_array__(self, type=None):
         """
 
     @Appender(
-        _interval_shared_docs["to_tuples"] % dict(return_type="ndarray", examples="")
+        _interval_shared_docs["to_tuples"] % {"return_type": "ndarray", "examples": ""}
     )
     def to_tuples(self, na_tuple=True):
         tuples = com.asarray_tuplesafe(zip(self._left, self._right))
@@ -1373,7 +1373,7 @@ def to_tuples(self, na_tuple=True):
 
     @Appender(_extension_array_shared_docs["repeat"] % _shared_docs_kwargs)
     def repeat(self, repeats, axis=None):
-        nv.validate_repeat(tuple(), dict(axis=axis))
+        nv.validate_repeat((), {"axis": axis})
         left_repeat = self.left.repeat(repeats)
         right_repeat = self.right.repeat(repeats)
         return self._shallow_copy(left=left_repeat, right=right_repeat)
@@ -1412,9 +1412,9 @@ def repeat(self, repeats, axis=None):
 
     @Appender(
         _interval_shared_docs["contains"]
-        % dict(
-            klass="IntervalArray",
-            examples=textwrap.dedent(
+        % {
+            "klass": "IntervalArray",
+            "examples": textwrap.dedent(
                 """\
         >>> intervals = pd.arrays.IntervalArray.from_tuples([(0, 1), (1, 3), (2, 4)])
         >>> intervals
@@ -1423,7 +1423,7 @@ def repeat(self, repeats, axis=None):
         Length: 3, closed: right, dtype: interval[int64]
         """
             ),
-        )
+        }
     )
     def contains(self, other):
         if isinstance(other, Interval):
diff --git a/pandas/core/arrays/numpy_.py b/pandas/core/arrays/numpy_.py
index 4eb67dcd12728..50d12703c3a30 100644
--- a/pandas/core/arrays/numpy_.py
+++ b/pandas/core/arrays/numpy_.py
@@ -273,12 +273,12 @@ def _values_for_factorize(self) -> Tuple[np.ndarray, int]:
     # Reductions
 
     def any(self, *, axis=None, out=None, keepdims=False, skipna=True):
-        nv.validate_any((), dict(out=out, keepdims=keepdims))
+        nv.validate_any((), {"out": out, "keepdims": keepdims})
         result = nanops.nanany(self._ndarray, axis=axis, skipna=skipna)
         return self._wrap_reduction_result(axis, result)
 
     def all(self, *, axis=None, out=None, keepdims=False, skipna=True):
-        nv.validate_all((), dict(out=out, keepdims=keepdims))
+        nv.validate_all((), {"out": out, "keepdims": keepdims})
         result = nanops.nanall(self._ndarray, axis=axis, skipna=skipna)
         return self._wrap_reduction_result(axis, result)
 
@@ -311,7 +311,7 @@ def prod(self, *, axis=None, skipna=True, min_count=0, **kwargs) -> Scalar:
         return self._wrap_reduction_result(axis, result)
 
     def mean(self, *, axis=None, dtype=None, out=None, keepdims=False, skipna=True):
-        nv.validate_mean((), dict(dtype=dtype, out=out, keepdims=keepdims))
+        nv.validate_mean((), {"dtype": dtype, "out": out, "keepdims": keepdims})
         result = nanops.nanmean(self._ndarray, axis=axis, skipna=skipna)
         return self._wrap_reduction_result(axis, result)
 
@@ -319,7 +319,7 @@ def median(
         self, *, axis=None, out=None, overwrite_input=False, keepdims=False, skipna=True
     ):
         nv.validate_median(
-            (), dict(out=out, overwrite_input=overwrite_input, keepdims=keepdims)
+            (), {"out": out, "overwrite_input": overwrite_input, "keepdims": keepdims}
         )
         result = nanops.nanmedian(self._ndarray, axis=axis, skipna=skipna)
         return self._wrap_reduction_result(axis, result)
@@ -328,7 +328,7 @@ def std(
         self, *, axis=None, dtype=None, out=None, ddof=1, keepdims=False, skipna=True
     ):
         nv.validate_stat_ddof_func(
-            (), dict(dtype=dtype, out=out, keepdims=keepdims), fname="std"
+            (), {"dtype": dtype, "out": out, "keepdims": keepdims}, fname="std"
         )
         result = nanops.nanstd(self._ndarray, axis=axis, skipna=skipna, ddof=ddof)
         return self._wrap_reduction_result(axis, result)
@@ -337,7 +337,7 @@ def var(
         self, *, axis=None, dtype=None, out=None, ddof=1, keepdims=False, skipna=True
     ):
         nv.validate_stat_ddof_func(
-            (), dict(dtype=dtype, out=out, keepdims=keepdims), fname="var"
+            (), {"dtype": dtype, "out": out, "keepdims": keepdims}, fname="var"
         )
         result = nanops.nanvar(self._ndarray, axis=axis, skipna=skipna, ddof=ddof)
         return self._wrap_reduction_result(axis, result)
@@ -346,21 +346,21 @@ def sem(
         self, *, axis=None, dtype=None, out=None, ddof=1, keepdims=False, skipna=True
     ):
         nv.validate_stat_ddof_func(
-            (), dict(dtype=dtype, out=out, keepdims=keepdims), fname="sem"
+            (), {"dtype": dtype, "out": out, "keepdims": keepdims}, fname="sem"
         )
         result = nanops.nansem(self._ndarray, axis=axis, skipna=skipna, ddof=ddof)
         return self._wrap_reduction_result(axis, result)
 
     def kurt(self, *, axis=None, dtype=None, out=None, keepdims=False, skipna=True):
         nv.validate_stat_ddof_func(
-            (), dict(dtype=dtype, out=out, keepdims=keepdims), fname="kurt"
+            (), {"dtype": dtype, "out": out, "keepdims": keepdims}, fname="kurt"
         )
         result = nanops.nankurt(self._ndarray, axis=axis, skipna=skipna)
         return self._wrap_reduction_result(axis, result)
 
     def skew(self, *, axis=None, dtype=None, out=None, keepdims=False, skipna=True):
         nv.validate_stat_ddof_func(
-            (), dict(dtype=dtype, out=out, keepdims=keepdims), fname="skew"
+            (), {"dtype": dtype, "out": out, "keepdims": keepdims}, fname="skew"
         )
         result = nanops.nanskew(self._ndarray, axis=axis, skipna=skipna)
         return self._wrap_reduction_result(axis, result)

From 15bac7fca41b4a4cf2f0ac568fb8d0d8fe91c320 Mon Sep 17 00:00:00 2001
From: Austin Robinson <austinziech@gmail.com>
Date: Wed, 2 Dec 2020 11:25:06 -0700
Subject: [PATCH 3/9] fixed C408 error in core/dtypes

---
 pandas/core/dtypes/dtypes.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py
index 07280702cf06f..fc46f0ee8e15d 100644
--- a/pandas/core/dtypes/dtypes.py
+++ b/pandas/core/dtypes/dtypes.py
@@ -53,7 +53,7 @@ class PandasExtensionDtype(ExtensionDtype):
     subdtype = None
     str: str_type
     num = 100
-    shape: Tuple[int, ...] = tuple()
+    shape: Tuple[int, ...] = ()
     itemsize = 8
     base = None
     isbuiltin = 0

From c64ded0c7c972eb212c9766da09d58e510e734e0 Mon Sep 17 00:00:00 2001
From: Austin Robinson <austinziech@gmail.com>
Date: Wed, 2 Dec 2020 11:25:21 -0700
Subject: [PATCH 4/9] fixed all C408 errors in core/computation

---
 pandas/core/computation/expressions.py | 2 +-
 pandas/core/computation/pytables.py    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/pandas/core/computation/expressions.py b/pandas/core/computation/expressions.py
index 23cf3019df461..e5ede3cd885be 100644
--- a/pandas/core/computation/expressions.py
+++ b/pandas/core/computation/expressions.py
@@ -22,7 +22,7 @@
     import numexpr as ne
 
 _TEST_MODE = None
-_TEST_RESULT: List[bool] = list()
+_TEST_RESULT: List[bool] = []
 USE_NUMEXPR = NUMEXPR_INSTALLED
 _evaluate = None
 _where = None
diff --git a/pandas/core/computation/pytables.py b/pandas/core/computation/pytables.py
index 0498d4d171c00..b819886687817 100644
--- a/pandas/core/computation/pytables.py
+++ b/pandas/core/computation/pytables.py
@@ -35,7 +35,7 @@ def __init__(
         queryables: Optional[Dict[str, Any]] = None,
     ):
         super().__init__(level + 1, global_dict=global_dict, local_dict=local_dict)
-        self.queryables = queryables or dict()
+        self.queryables = queryables or {}
 
 
 class Term(ops.Term):

From 880d86c17e882ac8bd9c283ddc0e4442e0bbd372 Mon Sep 17 00:00:00 2001
From: Austin Robinson <austinziech@gmail.com>
Date: Wed, 2 Dec 2020 12:01:29 -0700
Subject: [PATCH 5/9] fixed all C408 errors in core/indexes

---
 pandas/core/indexes/base.py     | 24 +++++++-------
 pandas/core/indexes/interval.py | 56 ++++++++++++++++-----------------
 pandas/core/indexes/multi.py    | 20 ++++++------
 pandas/core/indexes/numeric.py  | 16 +++++-----
 4 files changed, 58 insertions(+), 58 deletions(-)

diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 40fcc824992b7..bdac0d800cd18 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -107,15 +107,15 @@
 
 _unsortable_types = frozenset(("mixed", "mixed-integer"))
 
-_index_doc_kwargs = dict(
-    klass="Index",
-    inplace="",
-    target_klass="Index",
-    raises_section="",
-    unique="Index",
-    duplicated="np.ndarray",
-)
-_index_shared_docs = dict()
+_index_doc_kwargs = {
+    "klass": "Index",
+    "inplace": "",
+    "target_klass": "Index",
+    "raises_section": "",
+    "unique": "Index",
+    "duplicated": "np.ndarray",
+}
+_index_shared_docs = {}
 str_t = str
 
 
@@ -743,7 +743,7 @@ def astype(self, dtype, copy=True):
     @Appender(_index_shared_docs["take"] % _index_doc_kwargs)
     def take(self, indices, axis=0, allow_fill=True, fill_value=None, **kwargs):
         if kwargs:
-            nv.validate_take(tuple(), kwargs)
+            nv.validate_take((), kwargs)
         indices = ensure_platform_int(indices)
         allow_fill = self._maybe_disallow_fill(allow_fill, fill_value, indices)
 
@@ -818,7 +818,7 @@ def _maybe_disallow_fill(self, allow_fill: bool, fill_value, indices) -> bool:
     @Appender(_index_shared_docs["repeat"] % _index_doc_kwargs)
     def repeat(self, repeats, axis=None):
         repeats = ensure_platform_int(repeats)
-        nv.validate_repeat(tuple(), dict(axis=axis))
+        nv.validate_repeat((), {"axis": axis})
         return self._shallow_copy(self._values.repeat(repeats))
 
     # --------------------------------------------------------------------
@@ -2156,7 +2156,7 @@ def is_all_dates(self):
     # Pickle Methods
 
     def __reduce__(self):
-        d = dict(data=self._data)
+        d = {"data": self._data}
         d.update(self._get_attributes_dict())
         return _new_Index, (type(self), d), None
 
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index 18be4bf225da5..cbba8c2e38cb3 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -63,17 +63,17 @@
 _index_doc_kwargs = dict(ibase._index_doc_kwargs)
 
 _index_doc_kwargs.update(
-    dict(
-        klass="IntervalIndex",
-        qualname="IntervalIndex",
-        target_klass="IntervalIndex or list of Intervals",
-        name=textwrap.dedent(
+    {
+        "klass": "IntervalIndex",
+        "qualname": "IntervalIndex",
+        "target_klass": "IntervalIndex or list of Intervals",
+        "name": textwrap.dedent(
             """\
          name : object, optional
               Name to be stored in the index.
          """
         ),
-    )
+    }
 )
 
 
@@ -143,14 +143,14 @@ def wrapped(self, other, sort=False):
 
 @Appender(
     _interval_shared_docs["class"]
-    % dict(
-        klass="IntervalIndex",
-        summary="Immutable index of intervals that are closed on the same side.",
-        name=_index_doc_kwargs["name"],
-        versionadded="0.20.0",
-        extra_attributes="is_overlapping\nvalues\n",
-        extra_methods="",
-        examples=textwrap.dedent(
+    % {
+        "klass": "IntervalIndex",
+        "summary": "Immutable index of intervals that are closed on the same side.",
+        "name": _index_doc_kwargs["name"],
+        "versionadded": "0.20.0",
+        "extra_attributes": "is_overlapping\nvalues\n",
+        "extra_methods": "",
+        "examples": textwrap.dedent(
             """\
     Examples
     --------
@@ -170,7 +170,7 @@ def wrapped(self, other, sort=False):
     mentioned constructor methods.
     """
         ),
-    )
+    }
 )
 @inherit_names(["set_closed", "to_tuples"], IntervalArray, wrap=True)
 @inherit_names(["__array__", "overlaps", "contains"], IntervalArray)
@@ -236,9 +236,9 @@ def _simple_new(cls, array: IntervalArray, name: Label = None):
     @classmethod
     @Appender(
         _interval_shared_docs["from_breaks"]
-        % dict(
-            klass="IntervalIndex",
-            examples=textwrap.dedent(
+        % {
+            "klass": "IntervalIndex",
+            "examples": textwrap.dedent(
                 """\
         Examples
         --------
@@ -248,7 +248,7 @@ def _simple_new(cls, array: IntervalArray, name: Label = None):
                       dtype='interval[int64]')
         """
             ),
-        )
+        }
     )
     def from_breaks(
         cls, breaks, closed: str = "right", name=None, copy: bool = False, dtype=None
@@ -262,9 +262,9 @@ def from_breaks(
     @classmethod
     @Appender(
         _interval_shared_docs["from_arrays"]
-        % dict(
-            klass="IntervalIndex",
-            examples=textwrap.dedent(
+        % {
+            "klass": "IntervalIndex",
+            "examples": textwrap.dedent(
                 """\
         Examples
         --------
@@ -274,7 +274,7 @@ def from_breaks(
                       dtype='interval[int64]')
         """
             ),
-        )
+        }
     )
     def from_arrays(
         cls,
@@ -294,9 +294,9 @@ def from_arrays(
     @classmethod
     @Appender(
         _interval_shared_docs["from_tuples"]
-        % dict(
-            klass="IntervalIndex",
-            examples=textwrap.dedent(
+        % {
+            "klass": "IntervalIndex",
+            "examples": textwrap.dedent(
                 """\
         Examples
         --------
@@ -306,7 +306,7 @@ def from_arrays(
                        dtype='interval[int64]')
         """
             ),
-        )
+        }
     )
     def from_tuples(
         cls, data, closed: str = "right", name=None, copy: bool = False, dtype=None
@@ -362,7 +362,7 @@ def __array_wrap__(self, result, context=None):
         return result
 
     def __reduce__(self):
-        d = dict(left=self.left, right=self.right)
+        d = {"left": self.left, "right": self.right}
         d.update(self._get_attributes_dict())
         return _new_IntervalIndex, (type(self), d), None
 
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index d575c67cb36aa..05dca0fe048a4 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -74,7 +74,7 @@
 
 _index_doc_kwargs = dict(ibase._index_doc_kwargs)
 _index_doc_kwargs.update(
-    dict(klass="MultiIndex", target_klass="MultiIndex or list of tuples")
+    {"klass": "MultiIndex", "target_klass": "MultiIndex or list of tuples"}
 )
 
 
@@ -2007,12 +2007,12 @@ def remove_unused_levels(self):
 
     def __reduce__(self):
         """Necessary for making this object picklable"""
-        d = dict(
-            levels=list(self.levels),
-            codes=list(self.codes),
-            sortorder=self.sortorder,
-            names=list(self.names),
-        )
+        d = {
+            "levels": list(self.levels),
+            "codes": list(self.codes),
+            "sortorder": self.sortorder,
+            "names": list(self.names),
+        }
         return ibase._new_Index, (type(self), d), None
 
     # --------------------------------------------------------------------
@@ -2052,7 +2052,7 @@ def __getitem__(self, key):
 
     @Appender(_index_shared_docs["take"] % _index_doc_kwargs)
     def take(self, indices, axis=0, allow_fill=True, fill_value=None, **kwargs):
-        nv.validate_take(tuple(), kwargs)
+        nv.validate_take((), kwargs)
         indices = ensure_platform_int(indices)
 
         # only fill if we are passing a non-None fill_value
@@ -2116,7 +2116,7 @@ def argsort(self, *args, **kwargs) -> np.ndarray:
 
     @Appender(_index_shared_docs["repeat"] % _index_doc_kwargs)
     def repeat(self, repeats, axis=None):
-        nv.validate_repeat(tuple(), dict(axis=axis))
+        nv.validate_repeat((), {'axis': axis})
         repeats = ensure_platform_int(repeats)
         return MultiIndex(
             levels=self.levels,
@@ -3347,7 +3347,7 @@ def _reorder_indexer(
                 return indexer
 
         n = len(self)
-        keys: Tuple[np.ndarray, ...] = tuple()
+        keys: Tuple[np.ndarray, ...] = ()
         # For each level of the sequence in seq, map the level codes with the
         # order they appears in a list-like sequence
         # This mapping is then use to reorder the indexer
diff --git a/pandas/core/indexes/numeric.py b/pandas/core/indexes/numeric.py
index 12f61fc44582d..6f2e380d95e83 100644
--- a/pandas/core/indexes/numeric.py
+++ b/pandas/core/indexes/numeric.py
@@ -29,7 +29,7 @@
 import pandas.core.common as com
 from pandas.core.indexes.base import Index, maybe_extract_name
 
-_num_index_shared_docs = dict()
+_num_index_shared_docs = {}
 
 
 class NumericIndex(Index):
@@ -224,7 +224,7 @@ def _union(self, other, sort):
     An Index instance can **only** contain hashable objects.
 """
 
-_int64_descr_args = dict(klass="Int64Index", ltype="integer", dtype="int64", extra="")
+_int64_descr_args = {"klass": "Int64Index", "ltype": "integer", "dtype": "int64", "extra": ""}
 
 
 class IntegerIndex(NumericIndex):
@@ -286,9 +286,9 @@ class Int64Index(IntegerIndex):
     _default_dtype = np.dtype(np.int64)
 
 
-_uint64_descr_args = dict(
-    klass="UInt64Index", ltype="unsigned integer", dtype="uint64", extra=""
-)
+_uint64_descr_args = {
+    "klass": "UInt64Index", "ltype": "unsigned integer", "dtype": "uint64", "extra": ""
+}
 
 
 class UInt64Index(IntegerIndex):
@@ -314,9 +314,9 @@ def _convert_arr_indexer(self, keyarr):
         return com.asarray_tuplesafe(keyarr, dtype=dtype)
 
 
-_float64_descr_args = dict(
-    klass="Float64Index", dtype="float64", ltype="float", extra=""
-)
+_float64_descr_args = {
+    "klass": "Float64Index", "dtype": "float64", "ltype": "float", "extra": ""
+}
 
 
 class Float64Index(NumericIndex):

From efe54374413ed64602cb65f618bcde755edcdc90 Mon Sep 17 00:00:00 2001
From: Austin Robinson <austinziech@gmail.com>
Date: Wed, 2 Dec 2020 12:01:49 -0700
Subject: [PATCH 6/9] fixed all C408 errors in core/ops

---
 pandas/core/ops/methods.py | 58 +++++++++++++++++++-------------------
 1 file changed, 29 insertions(+), 29 deletions(-)

diff --git a/pandas/core/ops/methods.py b/pandas/core/ops/methods.py
index 96a691da38b99..4866905d32b83 100644
--- a/pandas/core/ops/methods.py
+++ b/pandas/core/ops/methods.py
@@ -62,11 +62,11 @@ def add_flex_arithmetic_methods(cls):
     flex_arith_method, flex_comp_method = _get_method_wrappers(cls)
     new_methods = _create_methods(cls, flex_arith_method, flex_comp_method)
     new_methods.update(
-        dict(
-            multiply=new_methods["mul"],
-            subtract=new_methods["sub"],
-            divide=new_methods["div"],
-        )
+        {
+            "multiply": new_methods["mul"],
+            "subtract": new_methods["sub"],
+            "divide": new_methods["div"],
+        }
     )
     # opt out of bool flex methods for now
     assert not any(kname in new_methods for kname in ("ror_", "rxor", "rand_"))
@@ -84,22 +84,22 @@ def _create_methods(cls, arith_method, comp_method):
     new_methods = {}
 
     new_methods.update(
-        dict(
-            add=arith_method(operator.add),
-            radd=arith_method(radd),
-            sub=arith_method(operator.sub),
-            mul=arith_method(operator.mul),
-            truediv=arith_method(operator.truediv),
-            floordiv=arith_method(operator.floordiv),
-            mod=arith_method(operator.mod),
-            pow=arith_method(operator.pow),
-            rmul=arith_method(rmul),
-            rsub=arith_method(rsub),
-            rtruediv=arith_method(rtruediv),
-            rfloordiv=arith_method(rfloordiv),
-            rpow=arith_method(rpow),
-            rmod=arith_method(rmod),
-        )
+        {
+            "add": arith_method(operator.add),
+            "radd": arith_method(radd),
+            "sub": arith_method(operator.sub),
+            "mul": arith_method(operator.mul),
+            "truediv": arith_method(operator.truediv),
+            "floordiv": arith_method(operator.floordiv),
+            "mod": arith_method(operator.mod),
+            "pow": arith_method(operator.pow),
+            "rmul": arith_method(rmul),
+            "rsub": arith_method(rsub),
+            "rtruediv": arith_method(rtruediv),
+            "rfloordiv": arith_method(rfloordiv),
+            "rpow": arith_method(rpow),
+            "rmod": arith_method(rmod),
+        }
     )
     new_methods["div"] = new_methods["truediv"]
     new_methods["rdiv"] = new_methods["rtruediv"]
@@ -109,14 +109,14 @@ def _create_methods(cls, arith_method, comp_method):
         new_methods["rdivmod"] = arith_method(rdivmod)
 
     new_methods.update(
-        dict(
-            eq=comp_method(operator.eq),
-            ne=comp_method(operator.ne),
-            lt=comp_method(operator.lt),
-            gt=comp_method(operator.gt),
-            le=comp_method(operator.le),
-            ge=comp_method(operator.ge),
-        )
+        {
+            "eq": comp_method(operator.eq),
+            "ne": comp_method(operator.ne),
+            "lt": comp_method(operator.lt),
+            "gt": comp_method(operator.gt),
+            "le": comp_method(operator.le),
+            "ge": comp_method(operator.ge),
+        }
     )
 
     new_methods = {k.strip("_"): v for k, v in new_methods.items()}

From ea764262fa3fb4f69e07882218e948a936d8df28 Mon Sep 17 00:00:00 2001
From: Austin Robinson <austinziech@gmail.com>
Date: Wed, 2 Dec 2020 12:02:41 -0700
Subject: [PATCH 7/9] fixed all C408 errors in io/pytables.py

---
 pandas/io/pytables.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/pandas/io/pytables.py b/pandas/io/pytables.py
index d7ee4acc2e670..3fe251d300856 100644
--- a/pandas/io/pytables.py
+++ b/pandas/io/pytables.py
@@ -2037,7 +2037,7 @@ def convert(self, values: np.ndarray, nan_rep, encoding: str, errors: str):
         val_kind = _ensure_decoded(self.kind)
         values = _maybe_convert(values, val_kind, encoding, errors)
 
-        kwargs = dict()
+        kwargs = {}
         kwargs["name"] = _ensure_decoded(self.index_name)
 
         if self.freq is not None:
@@ -3237,7 +3237,7 @@ def __init__(
         self.non_index_axes = non_index_axes or []
         self.values_axes = values_axes or []
         self.data_columns = data_columns or []
-        self.info = info or dict()
+        self.info = info or {}
         self.nan_rep = nan_rep
 
     @property
@@ -3446,7 +3446,7 @@ def get_attrs(self):
         """ retrieve our attributes """
         self.non_index_axes = getattr(self.attrs, "non_index_axes", None) or []
         self.data_columns = getattr(self.attrs, "data_columns", None) or []
-        self.info = getattr(self.attrs, "info", None) or dict()
+        self.info = getattr(self.attrs, "info", None) or {}
         self.nan_rep = getattr(self.attrs, "nan_rep", None)
         self.encoding = _ensure_encoding(getattr(self.attrs, "encoding", None))
         self.errors = _ensure_decoded(getattr(self.attrs, "errors", "strict"))
@@ -3596,7 +3596,7 @@ def create_index(self, columns=None, optlevel=None, kind: Optional[str] = None):
         if not isinstance(columns, (tuple, list)):
             columns = [columns]
 
-        kw = dict()
+        kw = {}
         if optlevel is not None:
             kw["optlevel"] = optlevel
         if kind is not None:
@@ -3689,7 +3689,7 @@ def validate_data_columns(self, data_columns, min_itemsize, non_index_axes):
             return []
 
         axis, axis_labels = non_index_axes[0]
-        info = self.info.get(axis, dict())
+        info = self.info.get(axis, {})
         if info.get("type") == "MultiIndex" and data_columns:
             raise ValueError(
                 f"cannot use a multi-index on axis [{axis}] with "
@@ -4071,7 +4071,7 @@ def create_description(
         if expectedrows is None:
             expectedrows = max(self.nrows_expected, 10000)
 
-        d = dict(name="table", expectedrows=expectedrows)
+        d = {"name": "table", "expectedrows": expectedrows}
 
         # description from the axes & values
         d["description"] = {a.cname: a.typ for a in self.axes}
@@ -4458,9 +4458,9 @@ def read(
         result = self._read_axes(where=where, start=start, stop=stop)
 
         info = (
-            self.info.get(self.non_index_axes[0][0], dict())
+            self.info.get(self.non_index_axes[0][0], {})
             if len(self.non_index_axes)
-            else dict()
+            else {}
         )
 
         inds = [i for i, ax in enumerate(self.axes) if ax is self.index_axes[0]]

From 14386bad2261f4f88733648d7f852fbf250a6da6 Mon Sep 17 00:00:00 2001
From: Austin Robinson <austinziech@gmail.com>
Date: Wed, 2 Dec 2020 12:07:07 -0700
Subject: [PATCH 8/9] fixed all C408 errors in tests/dtypes,
 tests/io/generate_legacy_storage_files.py,
 tests/frame/methods/test_to_records.py,
 tests/groupby/transform/test_transform.py

---
 pandas/tests/dtypes/test_inference.py         |   6 +-
 pandas/tests/frame/methods/test_to_records.py |   2 +-
 .../tests/groupby/transform/test_transform.py |   4 +-
 .../tests/io/generate_legacy_storage_files.py | 126 +++++++++---------
 4 files changed, 68 insertions(+), 70 deletions(-)

diff --git a/pandas/tests/dtypes/test_inference.py b/pandas/tests/dtypes/test_inference.py
index c9ca5cb34d271..ce9d5b1dca505 100644
--- a/pandas/tests/dtypes/test_inference.py
+++ b/pandas/tests/dtypes/test_inference.py
@@ -66,7 +66,7 @@ def coerce(request):
     ([1], True, "list"),
     ([], True, "list-empty"),
     ((1,), True, "tuple"),
-    (tuple(), True, "tuple-empty"),
+    ((), True, "tuple-empty"),
     ({"a": 1}, True, "dict"),
     ({}, True, "dict-empty"),
     ({"a", 1}, "set", "set"),
@@ -161,7 +161,7 @@ class DtypeList(list):
     assert inference.is_array_like(DtypeList())
 
     assert not inference.is_array_like([1, 2, 3])
-    assert not inference.is_array_like(tuple())
+    assert not inference.is_array_like(())
     assert not inference.is_array_like("foo")
     assert not inference.is_array_like(123)
 
@@ -326,7 +326,7 @@ class UnhashableClass2:
         def __hash__(self):
             raise TypeError("Not hashable")
 
-    hashable = (1, 3.14, np.float64(3.14), "a", tuple(), (1,), HashableClass())
+    hashable = (1, 3.14, np.float64(3.14), "a", (), (1,), HashableClass())
     not_hashable = ([], UnhashableClass1())
     abc_hashable_not_really_hashable = (([],), UnhashableClass2())
 
diff --git a/pandas/tests/frame/methods/test_to_records.py b/pandas/tests/frame/methods/test_to_records.py
index 4d40f191a904b..e83882be9c680 100644
--- a/pandas/tests/frame/methods/test_to_records.py
+++ b/pandas/tests/frame/methods/test_to_records.py
@@ -238,7 +238,7 @@ def test_to_records_with_categorical(self):
             ),
             # Invalid dype values.
             (
-                {"index": False, "column_dtypes": list()},
+                {"index": False, "column_dtypes": []},
                 (ValueError, "Invalid dtype \\[\\] specified for column A"),
             ),
             (
diff --git a/pandas/tests/groupby/transform/test_transform.py b/pandas/tests/groupby/transform/test_transform.py
index 8acd051fbc643..72637400ff023 100644
--- a/pandas/tests/groupby/transform/test_transform.py
+++ b/pandas/tests/groupby/transform/test_transform.py
@@ -162,7 +162,7 @@ def test_transform_axis_1(transformation_func):
     # GH 36308
     if transformation_func == "tshift":
         pytest.xfail("tshift is deprecated")
-    args = ("ffill",) if transformation_func == "fillna" else tuple()
+    args = ("ffill",) if transformation_func == "fillna" else ()
 
     df = DataFrame({"a": [1, 2], "b": [3, 4], "c": [5, 6]}, index=["x", "y"])
     result = df.groupby([0, 0, 1], axis=1).transform(transformation_func, *args)
@@ -803,7 +803,7 @@ def test_group_fill_methods(
         keys = ["a", "b"] * len(vals)
 
         def interweave(list_obj):
-            temp = list()
+            temp = []
             for x in list_obj:
                 temp.extend([x, x])
 
diff --git a/pandas/tests/io/generate_legacy_storage_files.py b/pandas/tests/io/generate_legacy_storage_files.py
index 61e1fc019faac..920643f68960c 100644
--- a/pandas/tests/io/generate_legacy_storage_files.py
+++ b/pandas/tests/io/generate_legacy_storage_files.py
@@ -142,26 +142,25 @@ def create_data():
         "E": [0.0, 1, Timestamp("20100101"), "foo", 2.0],
     }
 
-    scalars = dict(timestamp=Timestamp("20130101"), period=Period("2012", "M"))
-
-    index = dict(
-        int=Index(np.arange(10)),
-        date=date_range("20130101", periods=10),
-        period=period_range("2013-01-01", freq="M", periods=10),
-        float=Index(np.arange(10, dtype=np.float64)),
-        uint=Index(np.arange(10, dtype=np.uint64)),
-        timedelta=timedelta_range("00:00:00", freq="30T", periods=10),
-    )
-
-    index["range"] = RangeIndex(10)
+    scalars = {"timestamp": Timestamp("20130101"), "period": Period("2012", "M")}
+
+    index = {
+        "int": Index(np.arange(10)),
+        "date": date_range("20130101", periods=10),
+        "period": period_range("2013-01-01", freq="M", periods=10),
+        "float": Index(np.arange(10, dtype=np.float64)),
+        "uint": Index(np.arange(10, dtype=np.uint64)),
+        "timedelta": timedelta_range("00:00:00", freq="30T", periods=10),
+        "range": RangeIndex(10)
+    }
 
     if _loose_version >= LooseVersion("0.21"):
         from pandas import interval_range
 
         index["interval"] = interval_range(0, periods=10)
 
-    mi = dict(
-        reg2=MultiIndex.from_tuples(
+    mi = {
+        "reg2": MultiIndex.from_tuples(
             tuple(
                 zip(
                     *[
@@ -172,35 +171,35 @@ def create_data():
             ),
             names=["first", "second"],
         )
-    )
+    }
 
-    series = dict(
-        float=Series(data["A"]),
-        int=Series(data["B"]),
-        mixed=Series(data["E"]),
-        ts=Series(
+    series = {
+        "float": Series(data["A"]),
+        "int": Series(data["B"]),
+        "mixed": Series(data["E"]),
+        "ts": Series(
             np.arange(10).astype(np.int64), index=date_range("20130101", periods=10)
         ),
-        mi=Series(
+        "mi": Series(
             np.arange(5).astype(np.float64),
             index=MultiIndex.from_tuples(
                 tuple(zip(*[[1, 1, 2, 2, 2], [3, 4, 3, 4, 5]])), names=["one", "two"]
             ),
         ),
-        dup=Series(np.arange(5).astype(np.float64), index=["A", "B", "C", "D", "A"]),
-        cat=Series(Categorical(["foo", "bar", "baz"])),
-        dt=Series(date_range("20130101", periods=5)),
-        dt_tz=Series(date_range("20130101", periods=5, tz="US/Eastern")),
-        period=Series([Period("2000Q1")] * 5),
-    )
+        "dup": Series(np.arange(5).astype(np.float64), index=["A", "B", "C", "D", "A"]),
+        "cat": Series(Categorical(["foo", "bar", "baz"])),
+        "dt": Series(date_range("20130101", periods=5)),
+        "dt_tz": Series(date_range("20130101", periods=5, tz="US/Eastern")),
+        "period": Series([Period("2000Q1")] * 5),
+    }
 
     mixed_dup_df = DataFrame(data)
     mixed_dup_df.columns = list("ABCDA")
-    frame = dict(
-        float=DataFrame({"A": series["float"], "B": series["float"] + 1}),
-        int=DataFrame({"A": series["int"], "B": series["int"] + 1}),
-        mixed=DataFrame({k: data[k] for k in ["A", "B", "C", "D"]}),
-        mi=DataFrame(
+    frame = {
+        "float": DataFrame({"A": series["float"], "B": series["float"] + 1}),
+        "int": DataFrame({"A": series["int"], "B": series["int"] + 1}),
+        "mixed": DataFrame({k: data[k] for k in ["A", "B", "C", "D"]}),
+        "mi": DataFrame(
             {"A": np.arange(5).astype(np.float64), "B": np.arange(5).astype(np.int64)},
             index=MultiIndex.from_tuples(
                 tuple(
@@ -214,25 +213,25 @@ def create_data():
                 names=["first", "second"],
             ),
         ),
-        dup=DataFrame(
+        "dup": DataFrame(
             np.arange(15).reshape(5, 3).astype(np.float64), columns=["A", "B", "A"]
         ),
-        cat_onecol=DataFrame({"A": Categorical(["foo", "bar"])}),
-        cat_and_float=DataFrame(
+        "cat_onecol": DataFrame({"A": Categorical(["foo", "bar"])}),
+        "cat_and_float": DataFrame(
             {
                 "A": Categorical(["foo", "bar", "baz"]),
                 "B": np.arange(3).astype(np.int64),
             }
         ),
-        mixed_dup=mixed_dup_df,
-        dt_mixed_tzs=DataFrame(
+        "mixed_dup": mixed_dup_df,
+        "dt_mixed_tzs": DataFrame(
             {
                 "A": Timestamp("20130102", tz="US/Eastern"),
                 "B": Timestamp("20130603", tz="CET"),
             },
             index=range(5),
         ),
-        dt_mixed2_tzs=DataFrame(
+        "dt_mixed2_tzs": DataFrame(
             {
                 "A": Timestamp("20130102", tz="US/Eastern"),
                 "B": Timestamp("20130603", tz="CET"),
@@ -240,22 +239,21 @@ def create_data():
             },
             index=range(5),
         ),
-    )
-
-    cat = dict(
-        int8=Categorical(list("abcdefg")),
-        int16=Categorical(np.arange(1000)),
-        int32=Categorical(np.arange(10000)),
-    )
+    }
 
-    timestamp = dict(
-        normal=Timestamp("2011-01-01"),
-        nat=NaT,
-        tz=Timestamp("2011-01-01", tz="US/Eastern"),
-    )
+    cat = {
+        "int8": Categorical(list("abcdefg")),
+        "int16": Categorical(np.arange(1000)),
+        "int32": Categorical(np.arange(10000)),
+    }
 
-    timestamp["freq"] = Timestamp("2011-01-01", freq="D")
-    timestamp["both"] = Timestamp("2011-01-01", tz="Asia/Tokyo", freq="M")
+    timestamp = {
+        "normal": Timestamp("2011-01-01"),
+        "nat": NaT,
+        "tz": Timestamp("2011-01-01", tz="US/Eastern"),
+        "freq": Timestamp("2011-01-01", freq="D"),
+        "both": Timestamp("2011-01-01", tz="Asia/Tokyo", freq="M")
+    }
 
     off = {
         "DateOffset": DateOffset(years=1),
@@ -282,18 +280,18 @@ def create_data():
         "Minute": Minute(1),
     }
 
-    return dict(
-        series=series,
-        frame=frame,
-        index=index,
-        scalars=scalars,
-        mi=mi,
-        sp_series=dict(float=_create_sp_series(), ts=_create_sp_tsseries()),
-        sp_frame=dict(float=_create_sp_frame()),
-        cat=cat,
-        timestamp=timestamp,
-        offsets=off,
-    )
+    return {
+        "series": series,
+        "frame": frame,
+        "index": index,
+        "scalars": scalars,
+        "mi": mi,
+        "sp_series": {"float": _create_sp_series(), "ts": _create_sp_tsseries()},
+        "sp_frame": {"float": _create_sp_frame()},
+        "cat": cat,
+        "timestamp": timestamp,
+        "offsets": off,
+    }
 
 
 def create_pickle_data():

From 5753bacef679842c204cdaf8dcbfdee8f34bd25f Mon Sep 17 00:00:00 2001
From: Austin Robinson <austinziech@gmail.com>
Date: Wed, 2 Dec 2020 12:54:26 -0700
Subject: [PATCH 9/9] resubmitting with pre-commit

---
 pandas/core/arrays/base.py                    |  2 +-
 pandas/core/arrays/interval.py                |  4 +-
 pandas/core/indexes/multi.py                  |  2 +-
 pandas/core/indexes/numeric.py                | 17 +++++--
 pandas/core/strings/accessor.py               | 44 +++++++++++--------
 .../tests/io/generate_legacy_storage_files.py |  4 +-
 6 files changed, 47 insertions(+), 26 deletions(-)

diff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py
index 4197f25ed9e6c..95470422f2ccd 100644
--- a/pandas/core/arrays/base.py
+++ b/pandas/core/arrays/base.py
@@ -952,7 +952,7 @@ def factorize(self, na_sentinel: int = -1) -> Tuple[np.ndarray, ExtensionArray]:
     @Substitution(klass="ExtensionArray")
     @Appender(_extension_array_shared_docs["repeat"])
     def repeat(self, repeats, axis=None):
-        nv.validate_repeat((), {'axis': axis})
+        nv.validate_repeat((), {"axis": axis})
         ind = np.arange(len(self)).repeat(repeats)
         return self.take(ind)
 
diff --git a/pandas/core/arrays/interval.py b/pandas/core/arrays/interval.py
index 142f07cf39e4d..53a98fc43becc 100644
--- a/pandas/core/arrays/interval.py
+++ b/pandas/core/arrays/interval.py
@@ -58,7 +58,9 @@
 _interval_shared_docs = {}
 
 _shared_docs_kwargs = {
-    "klass": "IntervalArray", "qualname": "arrays.IntervalArray", "name": ""
+    "klass": "IntervalArray",
+    "qualname": "arrays.IntervalArray",
+    "name": "",
 }
 
 
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index 05dca0fe048a4..7a3c7ec920265 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -2116,7 +2116,7 @@ def argsort(self, *args, **kwargs) -> np.ndarray:
 
     @Appender(_index_shared_docs["repeat"] % _index_doc_kwargs)
     def repeat(self, repeats, axis=None):
-        nv.validate_repeat((), {'axis': axis})
+        nv.validate_repeat((), {"axis": axis})
         repeats = ensure_platform_int(repeats)
         return MultiIndex(
             levels=self.levels,
diff --git a/pandas/core/indexes/numeric.py b/pandas/core/indexes/numeric.py
index 6f2e380d95e83..b2bd5ef587a00 100644
--- a/pandas/core/indexes/numeric.py
+++ b/pandas/core/indexes/numeric.py
@@ -224,7 +224,12 @@ def _union(self, other, sort):
     An Index instance can **only** contain hashable objects.
 """
 
-_int64_descr_args = {"klass": "Int64Index", "ltype": "integer", "dtype": "int64", "extra": ""}
+_int64_descr_args = {
+    "klass": "Int64Index",
+    "ltype": "integer",
+    "dtype": "int64",
+    "extra": "",
+}
 
 
 class IntegerIndex(NumericIndex):
@@ -287,7 +292,10 @@ class Int64Index(IntegerIndex):
 
 
 _uint64_descr_args = {
-    "klass": "UInt64Index", "ltype": "unsigned integer", "dtype": "uint64", "extra": ""
+    "klass": "UInt64Index",
+    "ltype": "unsigned integer",
+    "dtype": "uint64",
+    "extra": "",
 }
 
 
@@ -315,7 +323,10 @@ def _convert_arr_indexer(self, keyarr):
 
 
 _float64_descr_args = {
-    "klass": "Float64Index", "dtype": "float64", "ltype": "float", "extra": ""
+    "klass": "Float64Index",
+    "dtype": "float64",
+    "ltype": "float",
+    "extra": "",
 }
 
 
diff --git a/pandas/core/strings/accessor.py b/pandas/core/strings/accessor.py
index 8b84a59f53052..2713b76189157 100644
--- a/pandas/core/strings/accessor.py
+++ b/pandas/core/strings/accessor.py
@@ -236,12 +236,12 @@ def __iter__(self):
             g = self.get(i)
 
     def _wrap_result(
-            self,
-            result,
-            name=None,
-            expand=None,
-            fill_value=np.nan,
-            returns_string=True,
+        self,
+        result,
+        name=None,
+        expand=None,
+        fill_value=np.nan,
+        returns_string=True,
     ):
         from pandas import Index, MultiIndex
 
@@ -371,9 +371,9 @@ def _get_series_list(self, others):
             # in case of list-like `others`, all elements must be
             # either Series/Index/np.ndarray (1-dim)...
             if all(
-                    isinstance(x, (ABCSeries, ABCIndexClass))
-                    or (isinstance(x, np.ndarray) and x.ndim == 1)
-                    for x in others
+                isinstance(x, (ABCSeries, ABCIndexClass))
+                or (isinstance(x, np.ndarray) and x.ndim == 1)
+                for x in others
             ):
                 los: List[Series] = []
                 while others:  # iterate through list and append each element
@@ -840,7 +840,7 @@ def rsplit(self, pat=None, n=-1, expand=False):
         % {
             "side": "first",
             "return": "3 elements containing the string itself, followed by two "
-                      "empty strings",
+            "empty strings",
             "also": "rpartition : Split the string at the last occurrence of `sep`.",
         }
     )
@@ -854,7 +854,7 @@ def partition(self, sep=" ", expand=True):
         % {
             "side": "last",
             "return": "3 elements containing two empty strings, followed by the "
-                      "string itself",
+            "string itself",
             "also": "partition : Split the string at the first occurrence of `sep`.",
         }
     )
@@ -1791,7 +1791,9 @@ def encode(self, encoding, errors="strict"):
     @Appender(
         _shared_docs["str_strip"]
         % {
-            "side": "left and right sides", "method": "strip", "position": "leading and trailing"
+            "side": "left and right sides",
+            "method": "strip",
+            "position": "leading and trailing",
         }
     )
     @forbid_nonstring_types(["bytes"])
@@ -2657,14 +2659,20 @@ def len(self):
     _doc_args["upper"] = {"type": "uppercase", "method": "upper", "version": ""}
     _doc_args["title"] = {"type": "titlecase", "method": "title", "version": ""}
     _doc_args["capitalize"] = {
-        "type": "be capitalized", "method": "capitalize", "version": ""
+        "type": "be capitalized",
+        "method": "capitalize",
+        "version": "",
+    }
+    _doc_args["swapcase"] = {
+        "type": "be swapcased",
+        "method": "swapcase",
+        "version": "",
     }
-    _doc_args["swapcase"] = {"type": "be swapcased", "method": "swapcase", "version": ""}
     _doc_args["casefold"] = {
-     "type": "be casefolded",
-     "method": "casefold",
-     "version": "\n    .. versionadded:: 0.25.0\n"}
-
+        "type": "be casefolded",
+        "method": "casefold",
+        "version": "\n    .. versionadded:: 0.25.0\n",
+    }
 
     @Appender(_shared_docs["casemethods"] % _doc_args["lower"])
     @forbid_nonstring_types(["bytes"])
diff --git a/pandas/tests/io/generate_legacy_storage_files.py b/pandas/tests/io/generate_legacy_storage_files.py
index 920643f68960c..d8c3b36773a6a 100644
--- a/pandas/tests/io/generate_legacy_storage_files.py
+++ b/pandas/tests/io/generate_legacy_storage_files.py
@@ -151,7 +151,7 @@ def create_data():
         "float": Index(np.arange(10, dtype=np.float64)),
         "uint": Index(np.arange(10, dtype=np.uint64)),
         "timedelta": timedelta_range("00:00:00", freq="30T", periods=10),
-        "range": RangeIndex(10)
+        "range": RangeIndex(10),
     }
 
     if _loose_version >= LooseVersion("0.21"):
@@ -252,7 +252,7 @@ def create_data():
         "nat": NaT,
         "tz": Timestamp("2011-01-01", tz="US/Eastern"),
         "freq": Timestamp("2011-01-01", freq="D"),
-        "both": Timestamp("2011-01-01", tz="Asia/Tokyo", freq="M")
+        "both": Timestamp("2011-01-01", tz="Asia/Tokyo", freq="M"),
     }
 
     off = {