Refactor/validate utils (#43551)

Author: zyc09

pandas/core/arrays/datetimelike.py

@@ -1823,39 +1823,6 @@ def validate_periods(periods):
  return periods
 
 
-def validate_endpoints(closed):
- """
- Check that the `closed` argument is among [None, "left", "right"]
-
- Parameters
- ----------
- closed : {None, "left", "right"}
-
- Returns
- -------
- left_closed : bool
- right_closed : bool
-
- Raises
- ------
- ValueError : if argument is not among valid values
- """
- left_closed = False
- right_closed = False
-
- if closed is None:
- left_closed = True
- right_closed = True
- elif closed == "left":
- left_closed = True
- elif closed == "right":
- right_closed = True
- else:
- raise ValueError("Closed has to be either 'left', 'right' or None")
-
- return left_closed, right_closed
-
-
 def validate_inferred_freq(freq, inferred_freq, freq_infer):
  """
  If the user passes a freq and another freq is inferred from passed data,

pandas/core/arrays/datetimes.py

@@ -39,6 +39,7 @@
 )
 from pandas._typing import npt
 from pandas.errors import PerformanceWarning
+from pandas.util._validators import validate_endpoints
 
 from pandas.core.dtypes.cast import astype_dt64_to_dt64tz
 from pandas.core.dtypes.common import (
@@ -416,7 +417,7 @@ def _generate_range(
  if start is NaT or end is NaT:
  raise ValueError("Neither `start` nor `end` can be NaT")
 
- left_closed, right_closed = dtl.validate_endpoints(closed)
+ left_closed, right_closed = validate_endpoints(closed)
  start, end, _normalized = _maybe_normalize_endpoints(start, end, normalize)
  tz = _infer_tz_from_endpoints(start, end, tz)
 

pandas/core/arrays/timedeltas.py

@@ -36,6 +36,7 @@
  NpDtype,
 )
 from pandas.compat.numpy import function as nv
+from pandas.util._validators import validate_endpoints
 
 from pandas.core.dtypes.cast import astype_td64_unit_conversion
 from pandas.core.dtypes.common import (
@@ -312,7 +313,7 @@ def _generate_range(cls, start, end, periods, freq, closed=None):
  if end is not None:
  end = Timedelta(end)
 
- left_closed, right_closed = dtl.validate_endpoints(closed)
+ left_closed, right_closed = validate_endpoints(closed)
 
  if freq is not None:
  index = generate_regular_range(start, end, periods, freq)

pandas/core/generic.py

@@ -72,6 +72,7 @@
  validate_ascending,
  validate_bool_kwarg,
  validate_fillna_kwargs,
+ validate_inclusive,
 )
 
 from pandas.core.dtypes.common import (
@@ -7694,16 +7695,18 @@ def between_time(
  if not isinstance(index, DatetimeIndex):
  raise TypeError("Index must be DatetimeIndex")
 
- if (include_start != lib.no_default or include_end != lib.no_default) and (
- inclusive is not None
- ):
+ old_include_arg_used = (include_start != lib.no_default) or (
+ include_end != lib.no_default
+ )
+
+ if old_include_arg_used and inclusive is not None:
  raise ValueError(
  "Deprecated arguments `include_start` and `include_end` "
  "cannot be passed if `inclusive` has been given."
  )
  # If any of the deprecated arguments ('include_start', 'include_end')
  # have been passed
- elif (include_start != lib.no_default) or (include_end != lib.no_default):
+ elif old_include_arg_used:
  warnings.warn(
  "`include_start` and `include_end` are deprecated in "
  "favour of `inclusive`.",
@@ -7720,20 +7723,15 @@ def between_time(
  (False, False): "neither",
  }
  inclusive = inc_dict[(left, right)]
- else: # On arg removal inclusive can default to "both"
- if inclusive is None:
- inclusive = "both"
- elif inclusive not in ["both", "neither", "left", "right"]:
- raise ValueError(
- f"Inclusive has to be either string of 'both', "
- f"'left', 'right', or 'neither'. Got {inclusive}."
- )
-
+ elif inclusive is None:
+ # On arg removal inclusive can default to "both"
+ inclusive = "both"
+ left_inclusive, right_inclusive = validate_inclusive(inclusive)
  indexer = index.indexer_between_time(
  start_time,
  end_time,
- include_start=inclusive in ["both", "left"],
- include_end=inclusive in ["both", "right"],
+ include_start=left_inclusive,
+ include_end=right_inclusive,
  )
  return self._take_with_is_copy(indexer, axis=axis)
 

pandas/tests/frame/methods/test_between_time.py

@@ -236,10 +236,7 @@ def test_between_time_incorr_arg_inclusive(self):
  stime = time(0, 0)
  etime = time(1, 0)
  inclusive = "bad_string"
- msg = (
- "Inclusive has to be either string of 'both', 'left', 'right', "
- "or 'neither'. Got bad_string."
- )
+ msg = "Inclusive has to be either 'both', 'neither', 'left' or 'right'"
  with pytest.raises(ValueError, match=msg):
  ts.between_time(stime, etime, inclusive=inclusive)
 

pandas/tests/util/test_validate_inclusive.py

@@ -0,0 +1,40 @@
+import numpy as np
+import pytest
+
+from pandas.util._validators import validate_inclusive
+
+import pandas as pd
+
+
+@pytest.mark.parametrize(
+ "invalid_inclusive",
+ (
+ "ccc",
+ 2,
+ object(),
+ None,
+ np.nan,
+ pd.NA,
+ pd.DataFrame(),
+ ),
+)
+def test_invalid_inclusive(invalid_inclusive):
+ with pytest.raises(
+ ValueError,
+ match="Inclusive has to be either 'both', 'neither', 'left' or 'right'",
+ ):
+ validate_inclusive(invalid_inclusive)
+
+
+@pytest.mark.parametrize(
+ "valid_inclusive, expected_tuple",
+ (
+ ("left", (True, False)),
+ ("right", (False, True)),
+ ("both", (True, True)),
+ ("neither", (False, False)),
+ ),
+)
+def test_valid_inclusive(valid_inclusive, expected_tuple):
+ resultant_tuple = validate_inclusive(valid_inclusive)
+ assert expected_tuple == resultant_tuple

pandas/util/_validators.py

@@ -427,3 +427,70 @@ def validate_ascending(
  return validate_bool_kwarg(ascending, "ascending", **kwargs)
 
  return [validate_bool_kwarg(item, "ascending", **kwargs) for item in ascending]
+
+
+def validate_endpoints(closed: str | None) -> tuple[bool, bool]:
+ """
+ Check that the `closed` argument is among [None, "left", "right"]
+
+ Parameters
+ ----------
+ closed : {None, "left", "right"}
+
+ Returns
+ -------
+ left_closed : bool
+ right_closed : bool
+
+ Raises
+ ------
+ ValueError : if argument is not among valid values
+ """
+ left_closed = False
+ right_closed = False
+
+ if closed is None:
+ left_closed = True
+ right_closed = True
+ elif closed == "left":
+ left_closed = True
+ elif closed == "right":
+ right_closed = True
+ else:
+ raise ValueError("Closed has to be either 'left', 'right' or None")
+
+ return left_closed, right_closed
+
+
+def validate_inclusive(inclusive: str | None) -> tuple[bool, bool]:
+ """
+ Check that the `inclusive` argument is among {"both", "neither", "left", "right"}.
+
+ Parameters
+ ----------
+ inclusive : {"both", "neither", "left", "right"}
+
+ Returns
+ -------
+ left_right_inclusive : tuple[bool, bool]
+
+ Raises
+ ------
+ ValueError : if argument is not among valid values
+ """
+ left_right_inclusive: tuple[bool, bool] | None = None
+
+ if isinstance(inclusive, str):
+ left_right_inclusive = {
+ "both": (True, True),
+ "left": (True, False),
+ "right": (False, True),
+ "neither": (False, False),
+ }.get(inclusive)
+
+ if left_right_inclusive is None:
+ raise ValueError(
+ "Inclusive has to be either 'both', 'neither', 'left' or 'right'"
+ )
+
+ return left_right_inclusive