Blackened

Author: Sylvain MARIE

pandas/_libs/tslibs/strftime.py

@@ -3,8 +3,7 @@
 
 
 class UnsupportedStrFmtDirective(ValueError):
-    """The format contains a directive that is not supported in this context.
-    """
+    """The format contains a directive that is not supported in this context."""
 
 
 _COMMON_UNSUPPORTED = (
@@ -32,25 +31,28 @@ class UnsupportedStrFmtDirective(ValueError):
 
 
 _COMMON_MAP = {
-    "%d": ("day", "02d"),    # Day of the month as a zero-padded decimal number.
+    "%d": ("day", "02d"),  # Day of the month as a zero-padded decimal number.
     "%m": ("month", "02d"),  # Month as a zero-padded decimal number.
-    "%Y": ("year", "d"),     # Year with century as a decimal number.
-    "%H": ("hour", "02d"),   # Hour (24-hour clock) as a zero-padded decimal number.
-    "%M": ("min", "02d"),    # Minute as a zero-padded decimal number.
-    "%S": ("sec", "02d"),    # Second as a zero-padded decimal number.
+    "%Y": ("year", "d"),  # Year with century as a decimal number.
+    "%H": ("hour", "02d"),  # Hour (24-hour clock) as a zero-padded decimal number.
+    "%M": ("min", "02d"),  # Minute as a zero-padded decimal number.
+    "%S": ("sec", "02d"),  # Second as a zero-padded decimal number.
 }
 
 _DATETIME_MAP = {
-    "%f": ("us", "06d"),     # Microsecond as a decimal number, zero-padded to 6 digits.
+    "%f": ("us", "06d"),  # Microsecond as a decimal number, zero-padded to 6 digits.
 }
 
 _PERIOD_MAP = {
-    "%f": ("fyear", "02d"),  # 'Fiscal' year without century as zero-padded decimal number [00,99]
-    "%F": ("Fyear", "d"),    # 'Fiscal' year with century as a decimal number
-    "%q": ("q", "d"),        # Quarter as a decimal number [1,4]
-    "%l": ("ms", "03d"),     # Microsecond as a decimal number, zero-padded to 3 digits.
-    "%u": ("us", "06d"),     # Microsecond as a decimal number, zero-padded to 6 digits.
-    "%n": ("ns", "09d"),     # Microsecond as a decimal number, zero-padded to 9 digits.
+    "%f": (
+        "fyear",
+        "02d",
+    ),  # 'Fiscal' year without century as zero-padded decimal number [00,99]
+    "%F": ("Fyear", "d"),  # 'Fiscal' year with century as a decimal number
+    "%q": ("q", "d"),  # Quarter as a decimal number [1,4]
+    "%l": ("ms", "03d"),  # Microsecond as a decimal number, zero-padded to 3 digits.
+    "%u": ("us", "06d"),  # Microsecond as a decimal number, zero-padded to 6 digits.
+    "%n": ("ns", "09d"),  # Microsecond as a decimal number, zero-padded to 9 digits.
 }
 
 
@@ -153,7 +155,9 @@ def convert_strftime_format(
         for _map in directive_maps:
             for key, (_name, _fmt) in _map.items():
                 # for example replace "%d" by "{day:02d}" but with escaped { and }
-                strftime_fmt = strftime_fmt.replace(key, f"{esc_l}{_name}:{_fmt}{esc_r}")
+                strftime_fmt = strftime_fmt.replace(
+                    key, f"{esc_l}{_name}:{_fmt}{esc_r}"
+                )
 
         # Restore the %% into %
         strftime_fmt = strftime_fmt.replace(esc, "%")

pandas/core/arrays/datetimelike.py

@@ -294,7 +294,9 @@ def asi8(self) -> npt.NDArray[np.int64]:
     # ----------------------------------------------------------------
     # Rendering Methods
 
-    def _format_native_types(self, *, na_rep="NaT", date_format=None, fast_strftime=True):
+    def _format_native_types(
+        self, *, na_rep="NaT", date_format=None, fast_strftime=True
+    ):
         """
         Helper method for astype when converting to strings.
 
@@ -1589,7 +1591,9 @@ class DatelikeOps(DatetimeLikeArrayMixin):
         URL="https://docs.python.org/3/library/datetime.html"
         "#strftime-and-strptime-behavior"
     )
-    def strftime(self, date_format: str, fast_strftime: bool = True) -> npt.NDArray[np.object_]:
+    def strftime(
+        self, date_format: str, fast_strftime: bool = True
+    ) -> npt.NDArray[np.object_]:
         """
         Convert to Index using specified date_format.
 
@@ -1630,7 +1634,9 @@ def strftime(self, date_format: str, fast_strftime: bool = True) -> npt.NDArray[
                'March 10, 2018, 09:00:02 AM'],
               dtype='object')
         """
-        result = self._format_native_types(date_format=date_format, na_rep=np.nan, fast_strftime=fast_strftime)
+        result = self._format_native_types(
+            date_format=date_format, na_rep=np.nan, fast_strftime=fast_strftime
+        )
         return result.astype(object, copy=False)
 
 

pandas/core/arrays/datetimes.py

@@ -680,7 +680,10 @@ def _format_native_types(
         fmt = get_format_datetime64_from_values(self, date_format)
 
         return tslib.format_array_from_datetime(
-            self.asi8, tz=self.tz, format=fmt, na_rep=na_rep,
+            self.asi8,
+            tz=self.tz,
+            format=fmt,
+            na_rep=na_rep,
             fast_strftime=fast_strftime,
         )
 

pandas/core/indexes/datetimelike.py

@@ -176,14 +176,22 @@ def format(
         if formatter is not None:
             return header + list(self.map(formatter))
 
-        return self._format_with_header(header, na_rep=na_rep, date_format=date_format, fast_strftime=fast_strftime)
+        return self._format_with_header(
+            header, na_rep=na_rep, date_format=date_format, fast_strftime=fast_strftime
+        )
 
     def _format_with_header(
-        self, header: list[str], na_rep: str = "NaT", date_format: str | None = None, fast_strftime: bool = True,
+        self,
+        header: list[str],
+        na_rep: str = "NaT",
+        date_format: str | None = None,
+        fast_strftime: bool = True,
     ) -> list[str]:
         # matches base class except for whitespace padding and date_format
         return header + list(
-            self._format_native_types(na_rep=na_rep, date_format=date_format, fast_strftime=fast_strftime)
+            self._format_native_types(
+                na_rep=na_rep, date_format=date_format, fast_strftime=fast_strftime
+            )
         )
 
     @property

pandas/core/indexes/datetimes.py

@@ -259,7 +259,7 @@ class DatetimeIndex(DatetimeTimedeltaMixin):
     # methods that dispatch to DatetimeArray and wrap result
 
     @doc(DatetimeArray.strftime)
-    def strftime(self, date_format, fast_strftime : bool = True) -> Index:
+    def strftime(self, date_format, fast_strftime: bool = True) -> Index:
         arr = self._data.strftime(date_format, fast_strftime=fast_strftime)
         return Index(arr, name=self.name)
 

pandas/core/tools/datetimes.py

@@ -1316,8 +1316,13 @@ def fast_strftime(
     """
     # common dict used for formatting
     fmt_dct = dict(
-        year=dt.year, month=dt.month, day=dt.day, hour=dt.hour,
-        min=dt.minute, sec=dt.second, us=dt.microsecond
+        year=dt.year,
+        month=dt.month,
+        day=dt.day,
+        hour=dt.hour,
+        min=dt.minute,
+        sec=dt.second,
+        us=dt.microsecond,
     )
 
     # get the formatting template

pandas/io/formats/format.py

@@ -1634,8 +1634,9 @@ def _format_strings(self) -> list[str]:
             return [self.formatter(x) for x in values]
 
         fmt_values = values._data._format_native_types(
-            na_rep=self.nat_rep, date_format=self.date_format,
-            fast_strftime=self.fast_strftime
+            na_rep=self.nat_rep,
+            date_format=self.date_format,
+            fast_strftime=self.fast_strftime,
         )
         return fmt_values.tolist()
 
@@ -1780,8 +1781,13 @@ def _format_datetime64_dateonly(
         if str_date_fmt:
             # Faster, using string formatting
             return str_date_fmt % dict(
-                year=x.year, month=x.month, day=x.day, hour=x.hour,
-                min=x.min, sec=x.sec, us=x.us
+                year=x.year,
+                month=x.month,
+                day=x.day,
+                hour=x.hour,
+                min=x.min,
+                sec=x.sec,
+                us=x.us,
             )
         else:
             # Slower
@@ -1794,7 +1800,10 @@ def _format_datetime64_dateonly(
 
 
 def get_format_datetime64(
-    is_dates_only: bool, nat_rep: str = "NaT", date_format: str | None = None, fast_strftime : bool = True,
+    is_dates_only: bool,
+    nat_rep: str = "NaT",
+    date_format: str | None = None,
+    fast_strftime: bool = True,
 ) -> Callable:
     """Return a formatter callable taking a datetime64 as input and providing
     a string as output"""
@@ -1810,8 +1819,7 @@ def get_format_datetime64(
                 pass
 
         return lambda x: _format_datetime64_dateonly(
-            x, nat_rep=nat_rep, date_format=date_format,
-            str_date_fmt=str_date_fmt
+            x, nat_rep=nat_rep, date_format=date_format, str_date_fmt=str_date_fmt
         )
     else:
         return lambda x: _format_datetime64(x, nat_rep=nat_rep)

pandas/tests/io/formats/test_format.py

@@ -3188,10 +3188,16 @@ def test_datetime_tz_custom(self):
         # This timestamp is in 2013 in Europe/Paris but is 2012 in UTC
         dt = pd.to_datetime(["2013-01-01 00:00:00+01:00"], utc=True)
         # If tz is currently set as utc, we'll see 2012
-        assert dt.format(date_format="%Y-%m-%d__foo__%H:%M:%S")[0] == "2012-12-31__foo__23:00:00"
+        assert (
+            dt.format(date_format="%Y-%m-%d__foo__%H:%M:%S")[0]
+            == "2012-12-31__foo__23:00:00"
+        )
         # If tz is currently set as paris, we'll see 2013
         dt = dt.tz_convert("Europe/Paris")
-        assert dt.format(date_format="%Y-%m-%d__foo__%H:%M:%S")[0] == "2013-01-01__foo__00:00:00"
+        assert (
+            dt.format(date_format="%Y-%m-%d__foo__%H:%M:%S")[0]
+            == "2013-01-01__foo__00:00:00"
+        )
 
     def test_date(self):
         formatted = pd.to_datetime([datetime(2003, 1, 1), NaT]).format()
@@ -3279,12 +3285,15 @@ class TestDatetimeFastFormatter:
     kind of date/time objects.
     """
 
-    @pytest.mark.parametrize("strftime_format", (
-        "%Y-%m-%d %H:%M:%S",
-        "%Y%%Y",
-        "%Y{%Y}",
-        "%Y-%m-%dT%H:%M:%S.%fZ",
-    ))
+    @pytest.mark.parametrize(
+        "strftime_format",
+        (
+            "%Y-%m-%d %H:%M:%S",
+            "%Y%%Y",
+            "%Y{%Y}",
+            "%Y-%m-%dT%H:%M:%S.%fZ",
+        ),
+    )
     @pytest.mark.parametrize("new_style", (False, True))
     def test_fast_strftime_basic(self, strftime_format, new_style):
         """Test that formatting standard `datetime` objects with our utils works as good as strftime."""
@@ -3297,8 +3306,13 @@ def test_fast_strftime_basic(self, strftime_format, new_style):
 
         # common dict used for formatting
         fmt_dct = dict(
-            year=dt.year, month=dt.month, day=dt.day, hour=dt.hour,
-            min=dt.minute, sec=dt.second, us=dt.microsecond
+            year=dt.year,
+            month=dt.month,
+            day=dt.day,
+            hour=dt.hour,
+            min=dt.minute,
+            sec=dt.second,
+            us=dt.microsecond,
         )
 
         # get the formatting string
@@ -3315,11 +3329,14 @@ def test_fast_strftime_basic(self, strftime_format, new_style):
         res2 = fast_strftime(dt, strftime_format, new_style_fmt=new_style)
         assert res2 == res
 
-    @pytest.mark.parametrize("strftime_format", (
-        "%Y-%m-%d %H:%M:%S",
-        "%Y %Y",
-        "%Y-%m-%dT%H:%M:%S.%fZ",
-    ))
+    @pytest.mark.parametrize(
+        "strftime_format",
+        (
+            "%Y-%m-%d %H:%M:%S",
+            "%Y %Y",
+            "%Y-%m-%dT%H:%M:%S.%fZ",
+        ),
+    )
     def test_fast_strftime_perf(self, strftime_format):
         """Test that formatting standard `datetime` objects with our utils is faster than strftime."""
 
@@ -3332,8 +3349,13 @@ def test_fast_strftime_perf(self, strftime_format):
 
         # Perf comparison: confirm the results in https://stackoverflow.com/a/43495629/7262247
         fmt_dct = dict(
-            year=dt.year, month=dt.month, day=dt.day, hour=dt.hour,
-            min=dt.minute, sec=dt.second, us=dt.microsecond
+            year=dt.year,
+            month=dt.month,
+            day=dt.day,
+            hour=dt.hour,
+            min=dt.minute,
+            sec=dt.second,
+            us=dt.microsecond,
         )
 
         glob = globals()
@@ -3350,7 +3372,7 @@ def test_fast_strftime_perf(self, strftime_format):
             Timer("old_style_format % fmt_dct", globals=glob).repeat(7, 1000)
         )
         #   Out[5]: 0.0030
-        assert new_style_best < strftime_best   # much better
+        assert new_style_best < strftime_best  # much better
         assert old_style_best < new_style_best  # even better !
 
     def test_bad_strftime_directive(self):
@@ -3364,21 +3386,31 @@ def test_bad_strftime_directive(self):
         # We align with the same behaviour
         x.dt.strftime(date_format="%Y-%M-%D___")
 
-    @pytest.mark.parametrize("date_format", (
-        # note: "%Y-%m-%d %H:%M:%S and "%Y-%m-%d %H:%M:%S.%f are always accelerated (hardcoded)
-        "%Y-%m-%d__foo__%H:%M:%S",
-        "%Y %Y",
-        "%Y-%m-%dT%H:%M:%S.%fZ",
-    ))
+    @pytest.mark.parametrize(
+        "date_format",
+        (
+            # note: "%Y-%m-%d %H:%M:%S and "%Y-%m-%d %H:%M:%S.%f are always accelerated (hardcoded)
+            "%Y-%m-%d__foo__%H:%M:%S",
+            "%Y %Y",
+            "%Y-%m-%dT%H:%M:%S.%fZ",
+        ),
+    )
     def test_perf_datetime64_strftime(self, date_format):
         x = Series(date_range("20130101 09:00:00", periods=100, freq="min"))
         # res = x.dt.strftime(date_format=date_format)
         # slow_res = x.dt.strftime(date_format=date_format, fast_strftime=False)
 
         glob = globals()
         glob.update(locals())
-        fast_best = min(Timer("x.dt.strftime(date_format=date_format)", globals=glob).repeat(3, 100))
-        strftime_best = min(Timer("x.dt.strftime(date_format=date_format, fast_strftime=False)", globals=glob).repeat(3, 100))
+        fast_best = min(
+            Timer("x.dt.strftime(date_format=date_format)", globals=glob).repeat(3, 100)
+        )
+        strftime_best = min(
+            Timer(
+                "x.dt.strftime(date_format=date_format, fast_strftime=False)",
+                globals=glob,
+            ).repeat(3, 100)
+        )
         assert fast_best < strftime_best  # much better
 
         # How many alternative are worth doing here ?

pandas/tests/scalar/test_nat.py

@@ -198,7 +198,7 @@ def test_nat_iso_format(get_nat):
                 "normalize",
                 "to_julian_date",
                 "to_period",
-                "tz"
+                "tz",
             ]
         ),
         (