CLN: remove redundant return value (#31065)

Author: jbrockmendel

pandas/_libs/tslibs/parsing.pyx

@@ -217,7 +217,7 @@ def parse_datetime_string(date_string: str, freq=None, dayfirst=False,
         return dt
 
     try:
-        dt, _, _ = _parse_dateabbr_string(date_string, _DEFAULT_DATETIME, freq)
+        dt, _ = _parse_dateabbr_string(date_string, _DEFAULT_DATETIME, freq)
         return dt
     except DateParseError:
         raise
@@ -280,7 +280,6 @@ cdef parse_datetime_string_with_reso(str date_string, freq=None, dayfirst=False,
     Returns
     -------
     datetime
-    datetime/dateutil.parser._result
     str
         Inferred resolution of the parsed string.
 
@@ -297,7 +296,7 @@ cdef parse_datetime_string_with_reso(str date_string, freq=None, dayfirst=False,
 
     parsed, reso = _parse_delimited_date(date_string, dayfirst)
     if parsed is not None:
-        return parsed, parsed, reso
+        return parsed, reso
 
     try:
         return _parse_dateabbr_string(date_string, _DEFAULT_DATETIME, freq)
@@ -315,7 +314,7 @@ cdef parse_datetime_string_with_reso(str date_string, freq=None, dayfirst=False,
         raise DateParseError(err)
     if parsed is None:
         raise DateParseError(f"Could not parse {date_string}")
-    return parsed, parsed, reso
+    return parsed, reso
 
 
 cpdef bint _does_string_look_like_datetime(str py_string):
@@ -375,7 +374,7 @@ cdef inline object _parse_dateabbr_string(object date_string, object default,
     assert isinstance(date_string, str)
 
     if date_string in nat_strings:
-        return NaT, NaT, ''
+        return NaT, ''
 
     date_string = date_string.upper()
     date_len = len(date_string)
@@ -384,7 +383,7 @@ cdef inline object _parse_dateabbr_string(object date_string, object default,
         # parse year only like 2000
         try:
             ret = default.replace(year=int(date_string))
-            return ret, ret, 'year'
+            return ret, 'year'
         except ValueError:
             pass
 
@@ -441,7 +440,7 @@ cdef inline object _parse_dateabbr_string(object date_string, object default,
                 month = (quarter - 1) * 3 + 1
 
             ret = default.replace(year=year, month=month)
-            return ret, ret, 'quarter'
+            return ret, 'quarter'
 
     except DateParseError:
         raise
@@ -454,14 +453,14 @@ cdef inline object _parse_dateabbr_string(object date_string, object default,
         month = int(date_string[4:6])
         try:
             ret = default.replace(year=year, month=month)
-            return ret, ret, 'month'
+            return ret, 'month'
         except ValueError:
             pass
 
     for pat in ['%Y-%m', '%b %Y', '%b-%Y']:
         try:
             ret = datetime.strptime(date_string, pat)
-            return ret, ret, 'month'
+            return ret, 'month'
         except ValueError:
             pass
 

pandas/_libs/tslibs/period.pyx

@@ -2466,7 +2466,7 @@ class Period(_Period):
             if util.is_integer_object(value):
                 value = str(value)
             value = value.upper()
-            dt, _, reso = parse_time_string(value, freq)
+            dt, reso = parse_time_string(value, freq)
             if dt is NaT:
                 ordinal = NPY_NAT
 

pandas/core/indexes/datetimes.py

@@ -750,7 +750,7 @@ def _maybe_cast_slice_bound(self, label, side, kind):
 
         if isinstance(label, str):
             freq = getattr(self, "freqstr", getattr(self, "inferred_freq", None))
-            _, parsed, reso = parsing.parse_time_string(label, freq)
+            parsed, reso = parsing.parse_time_string(label, freq)
             lower, upper = self._parsed_string_to_bounds(reso, parsed)
             # lower, upper form the half-open interval:
             #   [parsed, parsed + 1 freq)
@@ -766,7 +766,7 @@ def _maybe_cast_slice_bound(self, label, side, kind):
 
     def _get_string_slice(self, key: str, use_lhs: bool = True, use_rhs: bool = True):
         freq = getattr(self, "freqstr", getattr(self, "inferred_freq", None))
-        _, parsed, reso = parsing.parse_time_string(key, freq)
+        parsed, reso = parsing.parse_time_string(key, freq)
         loc = self._partial_date_slice(reso, parsed, use_lhs=use_lhs, use_rhs=use_rhs)
         return loc
 

pandas/core/indexes/period.py

@@ -5,6 +5,7 @@
 
 from pandas._libs import index as libindex
 from pandas._libs.tslibs import NaT, frequencies as libfrequencies, resolution
+from pandas._libs.tslibs.parsing import parse_time_string
 from pandas._libs.tslibs.period import Period
 from pandas.util._decorators import Appender, Substitution, cache_readonly
 
@@ -44,7 +45,7 @@
 from pandas.core.indexes.datetimes import DatetimeIndex, Index
 from pandas.core.indexes.numeric import Int64Index
 from pandas.core.ops import get_op_result_name
-from pandas.core.tools.datetimes import DateParseError, parse_time_string
+from pandas.core.tools.datetimes import DateParseError
 
 from pandas.tseries import frequencies
 from pandas.tseries.offsets import DateOffset, Tick
@@ -511,7 +512,7 @@ def get_value(self, series, key):
             return series.iat[key]
 
         if isinstance(key, str):
-            asdt, parsed, reso = parse_time_string(key, self.freq)
+            asdt, reso = parse_time_string(key, self.freq)
             grp = resolution.Resolution.get_freq_group(reso)
             freqn = resolution.get_freq_group(self.freq)
 
@@ -601,7 +602,7 @@ def get_loc(self, key, method=None, tolerance=None):
 
         if isinstance(key, str):
             try:
-                asdt, parsed, reso = parse_time_string(key, self.freq)
+                asdt, reso = parse_time_string(key, self.freq)
                 key = asdt
             except DateParseError:
                 # A string with invalid format
@@ -659,7 +660,7 @@ def _maybe_cast_slice_bound(self, label, side, kind):
             return Period(label, freq=self.freq)
         elif isinstance(label, str):
             try:
-                _, parsed, reso = parse_time_string(label, self.freq)
+                parsed, reso = parse_time_string(label, self.freq)
                 bounds = self._parsed_string_to_bounds(reso, parsed)
                 return bounds[0 if side == "left" else 1]
             except ValueError:
@@ -716,7 +717,7 @@ def _get_string_slice(self, key):
         if not self.is_monotonic:
             raise ValueError("Partial indexing only valid for ordered time series")
 
-        key, parsed, reso = parse_time_string(key, self.freq)
+        parsed, reso = parse_time_string(key, self.freq)
         grp = resolution.Resolution.get_freq_group(reso)
         freqn = resolution.get_freq_group(self.freq)
         if reso in ["day", "hour", "minute", "second"] and not grp < freqn:

pandas/core/tools/datetimes.py

@@ -12,7 +12,6 @@
     DateParseError,
     _format_is_iso,
     _guess_datetime_format,
-    parse_time_string,
 )
 from pandas._libs.tslibs.strptime import array_strptime
 from pandas._typing import ArrayLike

pandas/tests/indexes/datetimes/test_tools.py

@@ -1874,7 +1874,7 @@ def test_parsers(self, date_str, expected, cache):
         # https://github.com/dateutil/dateutil/issues/217
         yearfirst = True
 
-        result1, _, _ = parsing.parse_time_string(date_str, yearfirst=yearfirst)
+        result1, _ = parsing.parse_time_string(date_str, yearfirst=yearfirst)
         result2 = to_datetime(date_str, yearfirst=yearfirst)
         result3 = to_datetime([date_str], yearfirst=yearfirst)
         # result5 is used below
@@ -1910,7 +1910,7 @@ def test_na_values_with_cache(
 
     def test_parsers_nat(self):
         # Test that each of several string-accepting methods return pd.NaT
-        result1, _, _ = parsing.parse_time_string("NaT")
+        result1, _ = parsing.parse_time_string("NaT")
         result2 = to_datetime("NaT")
         result3 = Timestamp("NaT")
         result4 = DatetimeIndex(["NaT"])[0]
@@ -1986,7 +1986,7 @@ def test_parsers_dayfirst_yearfirst(self, cache):
                 )
                 assert dateutil_result == expected
 
-                result1, _, _ = parsing.parse_time_string(
+                result1, _ = parsing.parse_time_string(
                     date_str, dayfirst=dayfirst, yearfirst=yearfirst
                 )
 
@@ -2016,7 +2016,7 @@ def test_parsers_timestring(self, cache):
         }
 
         for date_str, (exp_now, exp_def) in cases.items():
-            result1, _, _ = parsing.parse_time_string(date_str)
+            result1, _ = parsing.parse_time_string(date_str)
             result2 = to_datetime(date_str)
             result3 = to_datetime([date_str])
             result4 = Timestamp(date_str)

pandas/tests/tslibs/test_parsing.py

@@ -15,10 +15,9 @@
 
 
 def test_parse_time_string():
-    (date, parsed, reso) = parse_time_string("4Q1984")
-    (date_lower, parsed_lower, reso_lower) = parse_time_string("4q1984")
+    (parsed, reso) = parse_time_string("4Q1984")
+    (parsed_lower, reso_lower) = parse_time_string("4q1984")
 
-    assert date == date_lower
     assert reso == reso_lower
     assert parsed == parsed_lower
 
@@ -34,10 +33,9 @@ def test_parse_time_string_invalid_type():
 )
 def test_parse_time_quarter_with_dash(dashed, normal):
     # see gh-9688
-    (date_dash, parsed_dash, reso_dash) = parse_time_string(dashed)
-    (date, parsed, reso) = parse_time_string(normal)
+    (parsed_dash, reso_dash) = parse_time_string(dashed)
+    (parsed, reso) = parse_time_string(normal)
 
-    assert date_dash == date
     assert parsed_dash == parsed
     assert reso_dash == reso
 
@@ -106,7 +104,7 @@ def test_parsers_quarterly_with_freq_error(date_str, kwargs, msg):
     ],
 )
 def test_parsers_quarterly_with_freq(date_str, freq, expected):
-    result, _, _ = parsing.parse_time_string(date_str, freq=freq)
+    result, _ = parsing.parse_time_string(date_str, freq=freq)
     assert result == expected
 
 
@@ -131,7 +129,7 @@ def test_parsers_quarter_invalid(date_str):
     [("201101", datetime(2011, 1, 1, 0, 0)), ("200005", datetime(2000, 5, 1, 0, 0))],
 )
 def test_parsers_month_freq(date_str, expected):
-    result, _, _ = parsing.parse_time_string(date_str, freq="M")
+    result, _ = parsing.parse_time_string(date_str, freq="M")
     assert result == expected
 
 
@@ -223,5 +221,5 @@ def test_parse_time_string_check_instance_type_raise_exception():
         parse_time_string((1, 2, 3))
 
     result = parse_time_string("2019")
-    expected = (datetime(2019, 1, 1), datetime(2019, 1, 1), "year")
+    expected = (datetime(2019, 1, 1), "year")
     assert result == expected