text: from __future__ import annotations
  
  from datetime import date, datetime, time, timedelta, tzinfo
  import operator
  from typing import TYPE_CHECKING, Optional, Tuple
  import warnings
  
  import numpy as np
  
  from pandas._libs import NaT, Period, Timestamp, index as libindex, lib
  from pandas._libs.tslibs import (
      Resolution,
      ints_to_pydatetime,
      parsing,
      timezones,
      to_offset,
  )
  from pandas._libs.tslibs.offsets import prefix_mapping
  from pandas._typing import Dtype, DtypeObj
  from pandas.errors import InvalidIndexError
  from pandas.util._decorators import cache_readonly, doc
  
  from pandas.core.dtypes.common import (
      DT64NS_DTYPE,
      is_datetime64_dtype,
      is_datetime64tz_dtype,
      is_scalar,
  )
  from pandas.core.dtypes.missing import is_valid_na_for_dtype
  
  from pandas.core.arrays.datetimes import DatetimeArray, tz_to_dtype
  import pandas.core.common as com
  from pandas.core.indexes.base import Index, get_unanimous_names, maybe_extract_name
  from pandas.core.indexes.datetimelike import DatetimeTimedeltaMixin
  from pandas.core.indexes.extension import inherit_names
  from pandas.core.tools.times import to_time
  
  if TYPE_CHECKING:
      from pandas import DataFrame, Float64Index, PeriodIndex, TimedeltaIndex
  
  
  def _new_DatetimeIndex(cls, d):
      """
      This is called upon unpickling, rather than the default which doesn't
      have arguments and breaks __new__
      """
      if "data" in d and not isinstance(d["data"], DatetimeIndex):
          # Avoid need to verify integrity by calling simple_new directly
          data = d.pop("data")
          if not isinstance(data, DatetimeArray):
              # For backward compat with older pickles, we may need to construct
              #  a DatetimeArray to adapt to the newer _simple_new signature
              tz = d.pop("tz")
              freq = d.pop("freq")
              dta = DatetimeArray._simple_new(data, dtype=tz_to_dtype(tz), freq=freq)
          else:
              dta = data
              for key in ["tz", "freq"]:
                  # These are already stored in our DatetimeArray; if they are
                  #  also in the pickle and don't match, we have a problem.
                  if key in d:
                      assert d.pop(key) == getattr(dta, key)
          result = cls._simple_new(dta, **d)
      else:
          with warnings.catch_warnings():
              # TODO: If we knew what was going in to **d, we might be able to
              #  go through _simple_new instead
              warnings.simplefilter("ignore")
              result = cls.__new__(cls, **d)
  
      return result
  
  
  @inherit_names(
      DatetimeArray._field_ops
      + [
          method
          for method in DatetimeArray._datetimelike_methods
          if method not in ("tz_localize", "tz_convert")
      ],
      DatetimeArray,
      wrap=True,
  )
  @inherit_names(["is_normalized", "_resolution_obj"], DatetimeArray, cache=True)
  @inherit_names(
      [
          "_bool_ops",
          "_object_ops",
          "_field_ops",
          "_datetimelike_ops",
          "_datetimelike_methods",
          "tz",
          "tzinfo",
          "dtype",
          "to_pydatetime",
          "_has_same_tz",
          "_format_native_types",
          "date",
          "time",
          "timetz",
          "std",
      ]
      + DatetimeArray._bool_ops,
      DatetimeArray,
  )
  class DatetimeIndex(DatetimeTimedeltaMixin):
      """
      Immutable ndarray-like of datetime64 data.
  
      Represented internally as int64, and which can be boxed to Timestamp objects
      that are subclasses of datetime and carry metadata.
  
      Parameters
      ----------
      data : array-like (1-dimensional), optional
          Optional datetime-like data to construct index with.
      freq : str or pandas offset object, optional
          One of pandas date offset strings or corresponding objects. The string
          'infer' can be passed in order to set the frequency of the index as the
          inferred frequency upon creation.
      tz : pytz.timezone or dateutil.tz.tzfile or datetime.tzinfo or str
          Set the Timezone of the data.
      normalize : bool, default False
          Normalize start/end dates to midnight before generating date range.
      closed : {'left', 'right'}, optional
          Set whether to include `start` and `end` that are on the
          boundary. The default includes boundary points on either end.
      ambiguous : 'infer', bool-ndarray, 'NaT', default 'raise'
          When clocks moved backward due to DST, ambiguous times may arise.
          For example in Central European Time (UTC+01), when going from 03:00
          DST to 02:00 non-DST, 02:30:00 local time occurs both at 00:30:00 UTC
          and at 01:30:00 UTC. In such a situation, the `ambiguous` parameter
          dictates how ambiguous times should be handled.
  
          - 'infer' will attempt to infer fall dst-transition hours based on
            order
          - bool-ndarray where True signifies a DST time, False signifies a
            non-DST time (note that this flag is only applicable for ambiguous
            times)
          - 'NaT' will return NaT where there are ambiguous times
          - 'raise' will raise an AmbiguousTimeError if there are ambiguous times.
      dayfirst : bool, default False
          If True, parse dates in `data` with the day first order.
      yearfirst : bool, default False
          If True parse dates in `data` with the year first order.
      dtype : numpy.dtype or DatetimeTZDtype or str, default None
          Note that the only NumPy dtype allowed is ‘datetime64[ns]’.
      copy : bool, default False
          Make a copy of input ndarray.
      name : label, default None
          Name to be stored in the index.
  
      Attributes
      ----------
      year
      month
      day
      hour
      minute
      second
      microsecond
      nanosecond
      date
      time
      timetz
      dayofyear
      day_of_year
      weekofyear
      week
      dayofweek
      day_of_week
      weekday
      quarter
      tz
      freq
      freqstr
      is_month_start
      is_month_end
      is_quarter_start
      is_quarter_end
      is_year_start
      is_year_end
      is_leap_year
      inferred_freq
  
      Methods
      -------
      normalize
      strftime
      snap
      tz_convert
      tz_localize
      round
      floor
      ceil
      to_period
      to_perioddelta
      to_pydatetime
      to_series
      to_frame
      month_name
      day_name
      mean
      std
  
      See Also
      --------
      Index : The base pandas Index type.
      TimedeltaIndex : Index of timedelta64 data.
      PeriodIndex : Index of Period data.
      to_datetime : Convert argument to datetime.
      date_range : Create a fixed-frequency DatetimeIndex.
  
      Notes
      -----
      To learn more about the frequency strings, please see `this link
      <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
      """
  
      _typ = "datetimeindex"
  
      _data_cls = DatetimeArray
      _engine_type = libindex.DatetimeEngine
      _supports_partial_string_indexing = True
  
      _comparables = ["name", "freqstr", "tz"]
      _attributes = ["name", "tz", "freq"]
  
      _is_numeric_dtype = False
  
      _data: DatetimeArray
      inferred_freq: Optional[str]
      tz: Optional[tzinfo]
  
      # --------------------------------------------------------------------
      # methods that dispatch to DatetimeArray and wrap result
  
      @doc(DatetimeArray.strftime)
      def strftime(self, date_format) -> Index:
          arr = self._data.strftime(date_format)
          return Index(arr, name=self.name)
  
      @doc(DatetimeArray.tz_convert)
      def tz_convert(self, tz) -> DatetimeIndex:
          arr = self._data.tz_convert(tz)
          return type(self)._simple_new(arr, name=self.name)
  
      @doc(DatetimeArray.tz_localize)
      def tz_localize(self, tz, ambiguous="raise", nonexistent="raise") -> DatetimeIndex:
          arr = self._data.tz_localize(tz, ambiguous, nonexistent)
          return type(self)._simple_new(arr, name=self.name)
  
      @doc(DatetimeArray.to_period)
      def to_period(self, freq=None) -> PeriodIndex:
          from pandas.core.indexes.api import PeriodIndex
  
          arr = self._data.to_period(freq)
          return PeriodIndex._simple_new(arr, name=self.name)
  
      @doc(DatetimeArray.to_perioddelta)
      def to_perioddelta(self, freq) -> TimedeltaIndex:
          from pandas.core.indexes.api import TimedeltaIndex
  
          arr = self._data.to_perioddelta(freq)
          return TimedeltaIndex._simple_new(arr, name=self.name)
  
      @doc(DatetimeArray.to_julian_date)
      def to_julian_date(self) -> Float64Index:
          from pandas.core.indexes.api import Float64Index
  
          arr = self._data.to_julian_date()
          return Float64Index._simple_new(arr, name=self.name)
  
      @doc(DatetimeArray.isocalendar)
      def isocalendar(self) -> DataFrame:
          df = self._data.isocalendar()
          return df.set_index(self)
  
      # --------------------------------------------------------------------
      # Constructors
  
      def __new__(
          cls,
          data=None,
          freq=lib.no_default,
          tz=None,
          normalize=False,
          closed=None,
          ambiguous="raise",
          dayfirst=False,
          yearfirst=False,
          dtype: Optional[Dtype] = None,
          copy=False,
          name=None,
      ):
  
          if is_scalar(data):
              raise TypeError(
                  f"{cls.__name__}() must be called with a "
                  f"collection of some kind, {repr(data)} was passed"
              )
  
          # - Cases checked above all return/raise before reaching here - #
  
          name = maybe_extract_name(name, data, cls)
  
          dtarr = DatetimeArray._from_sequence_not_strict(
              data,
              dtype=dtype,
              copy=copy,
              tz=tz,
              freq=freq,
              dayfirst=dayfirst,
              yearfirst=yearfirst,
              ambiguous=ambiguous,
          )
  
          subarr = cls._simple_new(dtarr, name=name)
          return subarr
  
      # --------------------------------------------------------------------
  
      @cache_readonly
      def _is_dates_only(self) -> bool:
          """
          Return a boolean if we are only dates (and don't have a timezone)
  
          Returns
          -------
          bool
          """
          from pandas.io.formats.format import is_dates_only
  
          return self.tz is None and is_dates_only(self._values)
  
      def __reduce__(self):
  
          # we use a special reduce here because we need
          # to simply set the .tz (and not reinterpret it)
  
          d = {"data": self._data}
          d.update(self._get_attributes_dict())
          return _new_DatetimeIndex, (type(self), d), None
  
      def _is_comparable_dtype(self, dtype: DtypeObj) -> bool:
          """
          Can we compare values of the given dtype to our own?
          """
          if self.tz is not None:
              # If we have tz, we can compare to tzaware
              return is_datetime64tz_dtype(dtype)
          # if we dont have tz, we can only compare to tznaive
          return is_datetime64_dtype(dtype)
  
      # --------------------------------------------------------------------
      # Rendering Methods
  
      def _mpl_repr(self):
          # how to represent ourselves to matplotlib
          return ints_to_pydatetime(self.asi8, self.tz)
  
      @property
      def _formatter_func(self):
          from pandas.io.formats.format import get_format_datetime64
  
          formatter = get_format_datetime64(is_dates_only=self._is_dates_only)
          return lambda x: f"'{formatter(x)}'"
  
      # --------------------------------------------------------------------
      # Set Operation Methods
  
      def union_many(self, others):
          """
          A bit of a hack to accelerate unioning a collection of indexes.
          """
          this = self
  
          for other in others:
              if not isinstance(this, DatetimeIndex):
                  this = Index.union(this, other)
                  continue
  
              if not isinstance(other, DatetimeIndex):
                  try:
                      other = DatetimeIndex(other)
                  except TypeError:
                      pass
  
              this, other = this._maybe_utc_convert(other)
  
              if this._can_fast_union(other):
                  this = this._fast_union(other)
              else:
                  this = Index.union(this, other)
  
          res_name = get_unanimous_names(self, *others)[0]
          if this.name != res_name:
              return this.rename(res_name)
          return this
  
      def _maybe_utc_convert(self, other: Index) -> Tuple[DatetimeIndex, Index]:
          this = self
  
          if isinstance(other, DatetimeIndex):
              if (self.tz is None) ^ (other.tz is None):
                  raise TypeError("Cannot join tz-naive with tz-aware DatetimeIndex")
  
              if not timezones.tz_compare(self.tz, other.tz):
                  this = self.tz_convert("UTC")
                  other = other.tz_convert("UTC")
          return this, other
  
      # --------------------------------------------------------------------
  
      def _get_time_micros(self):
          """
          Return the number of microseconds since midnight.
  
          Returns
          -------
          ndarray[int64_t]
          """
          values = self._data._local_timestamps()
  
          nanos = values % (24 * 3600 * 1_000_000_000)
          micros = nanos // 1000
  
          micros[self._isnan] = -1
          return micros
  
      def to_series(self, keep_tz=lib.no_default, index=None, name=None):
          """
          Create a Series with both index and values equal to the index keys
          useful with map for returning an indexer based on an index.
  
          Parameters
          ----------
          keep_tz : optional, defaults True
              Return the data keeping the timezone.
  
              If keep_tz is True:
  
                If the timezone is not set, the resulting
                Series will have a datetime64[ns] dtype.
  
                Otherwise the Series will have an datetime64[ns, tz] dtype; the
                tz will be preserved.
  
              If keep_tz is False:
  
                Series will have a datetime64[ns] dtype. TZ aware
                objects will have the tz removed.
  
              .. versionchanged:: 1.0.0
                  The default value is now True.  In a future version,
                  this keyword will be removed entirely.  Stop passing the
                  argument to obtain the future behavior and silence the warning.
  
          index : Index, optional
              Index of resulting Series. If None, defaults to original index.
          name : str, optional
              Name of resulting Series. If None, defaults to name of original
              index.
  
          Returns
          -------
          Series
          """
          from pandas import Series
  
          if index is None:
              index = self._view()
          if name is None:
              name = self.name
  
          if keep_tz is not lib.no_default:
              if keep_tz:
                  warnings.warn(
                      "The 'keep_tz' keyword in DatetimeIndex.to_series "
                      "is deprecated and will be removed in a future version.  "
                      "You can stop passing 'keep_tz' to silence this warning.",
                      FutureWarning,
                      stacklevel=2,
                  )
              else:
                  warnings.warn(
                      "Specifying 'keep_tz=False' is deprecated and this "
                      "option will be removed in a future release. If "
                      "you want to remove the timezone information, you "
                      "can do 'idx.tz_convert(None)' before calling "
                      "'to_series'.",
                      FutureWarning,
                      stacklevel=2,
                  )
          else:
              keep_tz = True
  
          if keep_tz and self.tz is not None:
              # preserve the tz & copy
              values = self.copy(deep=True)
          else:
              values = self._values.view("M8[ns]").copy()
  
          return Series(values, index=index, name=name)
  
      def snap(self, freq="S"):
          """
          Snap time stamps to nearest occurring frequency.
  
          Returns
          -------
          DatetimeIndex
          """
          # Superdumb, punting on any optimizing
          freq = to_offset(freq)
  
          snapped = np.empty(len(self), dtype=DT64NS_DTYPE)
  
          for i, v in enumerate(self):
              s = v
              if not freq.is_on_offset(s):
                  t0 = freq.rollback(s)
                  t1 = freq.rollforward(s)
                  if abs(s - t0) < abs(t1 - s):
                      s = t0
                  else:
                      s = t1
              snapped[i] = s
  
          dta = DatetimeArray(snapped, dtype=self.dtype)
          return DatetimeIndex._simple_new(dta, name=self.name)
  
      # --------------------------------------------------------------------
      # Indexing Methods
  
      def _parsed_string_to_bounds(self, reso: Resolution, parsed: datetime):
          """
          Calculate datetime bounds for parsed time string and its resolution.
  
          Parameters
          ----------
          reso : str
              Resolution provided by parsed string.
          parsed : datetime
              Datetime from parsed string.
  
          Returns
          -------
          lower, upper: pd.Timestamp
          """
          assert isinstance(reso, Resolution), (type(reso), reso)
          valid_resos = {
              "year",
              "month",
              "quarter",
              "day",
              "hour",
              "minute",
              "second",
              "millisecond",
              "microsecond",
          }
          if reso.attrname not in valid_resos:
              raise KeyError
  
          grp = reso.freq_group
          per = Period(parsed, freq=grp.value)
          start, end = per.start_time, per.end_time
  
          # GH 24076
          # If an incoming date string contained a UTC offset, need to localize
          # the parsed date to this offset first before aligning with the index's
          # timezone
          if parsed.tzinfo is not None:
              if self.tz is None:
                  raise ValueError(
                      "The index must be timezone aware when indexing "
                      "with a date string with a UTC offset"
                  )
              start = start.tz_localize(parsed.tzinfo).tz_convert(self.tz)
              end = end.tz_localize(parsed.tzinfo).tz_convert(self.tz)
          elif self.tz is not None:
              start = start.tz_localize(self.tz)
              end = end.tz_localize(self.tz)
          return start, end
  
      def _validate_partial_date_slice(self, reso: Resolution):
          assert isinstance(reso, Resolution), (type(reso), reso)
          if (
              self.is_monotonic
              and reso.attrname in ["day", "hour", "minute", "second"]
              and self._resolution_obj >= reso
          ):
              # These resolution/monotonicity validations came from GH3931,
              # GH3452 and GH2369.
  
              # See also GH14826
              raise KeyError
  
          if reso == "microsecond":
              # _partial_date_slice doesn't allow microsecond resolution, but
              # _parsed_string_to_bounds allows it.
              raise KeyError
  
      def _deprecate_mismatched_indexing(self, key):
          # GH#36148
          # we get here with isinstance(key, self._data._recognized_scalars)
          try:
              self._data._assert_tzawareness_compat(key)
          except TypeError:
              if self.tz is None:
                  msg = (
                      "Indexing a timezone-naive DatetimeIndex with a "
                      "timezone-aware datetime is deprecated and will "
                      "raise KeyError in a future version.  "
                      "Use a timezone-naive object instead."
                  )
              else:
                  msg = (
                      "Indexing a timezone-aware DatetimeIndex with a "
                      "timezone-naive datetime is deprecated and will "
                      "raise KeyError in a future version.  "
                      "Use a timezone-aware object instead."
                  )
              warnings.warn(msg, FutureWarning, stacklevel=5)
  
      def get_loc(self, key, method=None, tolerance=None):
          """
          Get integer location for requested label
  
          Returns
          -------
          loc : int
          """
          if not is_scalar(key):
              raise InvalidIndexError(key)
  
          orig_key = key
          if is_valid_na_for_dtype(key, self.dtype):
              key = NaT
  
          if isinstance(key, self._data._recognized_scalars):
              # needed to localize naive datetimes
              self._deprecate_mismatched_indexing(key)
              key = self._maybe_cast_for_get_loc(key)
  
          elif isinstance(key, str):
              try:
                  return self._get_string_slice(key)
              except (TypeError, KeyError, ValueError, OverflowError):
                  pass
  
              try:
                  key = self._maybe_cast_for_get_loc(key)
              except ValueError as err:
                  raise KeyError(key) from err
  
          elif isinstance(key, timedelta):
              # GH#20464
              raise TypeError(
                  f"Cannot index {type(self).__name__} with {type(key).__name__}"
              )
  
          elif isinstance(key, time):
              if method is not None:
                  raise NotImplementedError(
                      "cannot yet lookup inexact labels when key is a time object"
                  )
              return self.indexer_at_time(key)
  
          else:
              # unrecognized type
              raise KeyError(key)
  
          try:
              return Index.get_loc(self, key, method, tolerance)
          except KeyError as err:
              raise KeyError(orig_key) from err
  
      def _maybe_cast_for_get_loc(self, key) -> Timestamp:
          # needed to localize naive datetimes or dates (GH 35690)
          key = Timestamp(key)
          if key.tzinfo is None:
              key = key.tz_localize(self.tz)
          else:
              key = key.tz_convert(self.tz)
          return key
  
      def _maybe_cast_slice_bound(self, label, side: str, kind):
          """
          If label is a string, cast it to datetime according to resolution.
  
          Parameters
          ----------
          label : object
          side : {'left', 'right'}
          kind : {'loc', 'getitem'} or None
  
          Returns
          -------
          label : object
  
          Notes
          -----
          Value of `side` parameter should be validated in caller.
          """
          assert kind in ["loc", "getitem", None]
  
          if isinstance(label, str):
              freq = getattr(self, "freqstr", getattr(self, "inferred_freq", None))
              try:
                  parsed, reso = parsing.parse_time_string(label, freq)
              except parsing.DateParseError as err:
                  raise self._invalid_indexer("slice", label) from err
  
              reso = Resolution.from_attrname(reso)
              lower, upper = self._parsed_string_to_bounds(reso, parsed)
              # lower, upper form the half-open interval:
              #   [parsed, parsed + 1 freq)
              # because label may be passed to searchsorted
              # the bounds need swapped if index is reverse sorted and has a
              # length > 1 (is_monotonic_decreasing gives True for empty
              # and length 1 index)
              if self._is_strictly_monotonic_decreasing and len(self) > 1:
                  return upper if side == "left" else lower
              return lower if side == "left" else upper
          elif isinstance(label, (self._data._recognized_scalars, date)):
              self._deprecate_mismatched_indexing(label)
          else:
              raise self._invalid_indexer("slice", label)
  
          return self._maybe_cast_for_get_loc(label)
  
      def _get_string_slice(self, key: str):
          freq = getattr(self, "freqstr", getattr(self, "inferred_freq", None))
          parsed, reso = parsing.parse_time_string(key, freq)
          reso = Resolution.from_attrname(reso)
          return self._partial_date_slice(reso, parsed)
  
      def slice_indexer(self, start=None, end=None, step=None, kind=None):
          """
          Return indexer for specified label slice.
          Index.slice_indexer, customized to handle time slicing.
  
          In addition to functionality provided by Index.slice_indexer, does the
          following:
  
          - if both `start` and `end` are instances of `datetime.time`, it
            invokes `indexer_between_time`
          - if `start` and `end` are both either string or None perform
            value-based selection in non-monotonic cases.
  
          """
          # For historical reasons DatetimeIndex supports slices between two
          # instances of datetime.time as if it were applying a slice mask to
          # an array of (self.hour, self.minute, self.seconds, self.microsecond).
          if isinstance(start, time) and isinstance(end, time):
              if step is not None and step != 1:
                  raise ValueError("Must have step size of 1 with time slices")
              return self.indexer_between_time(start, end)
  
          if isinstance(start, time) or isinstance(end, time):
              raise KeyError("Cannot mix time and non-time slice keys")
  
          # Pandas supports slicing with dates, treated as datetimes at midnight.
          # https://github.com/pandas-dev/pandas/issues/31501
          if isinstance(start, date) and not isinstance(start, datetime):
              start = datetime.combine(start, time(0, 0))
          if isinstance(end, date) and not isinstance(end, datetime):
              end = datetime.combine(end, time(0, 0))
  
          def check_str_or_none(point):
              return point is not None and not isinstance(point, str)
  
          # GH#33146 if start and end are combinations of str and None and Index is not
          # monotonic, we can not use Index.slice_indexer because it does not honor the
          # actual elements, is only searching for start and end
          if (
              check_str_or_none(start)
              or check_str_or_none(end)
              or self.is_monotonic_increasing
          ):
              return Index.slice_indexer(self, start, end, step, kind=kind)
  
          mask = np.array(True)
          deprecation_mask = np.array(True)
          if start is not None:
              start_casted = self._maybe_cast_slice_bound(start, "left", kind)
              mask = start_casted <= self
              deprecation_mask = start_casted == self
  
          if end is not None:
              end_casted = self._maybe_cast_slice_bound(end, "right", kind)
              mask = (self <= end_casted) & mask
              deprecation_mask = (end_casted == self) | deprecation_mask
  
          if not deprecation_mask.any():
              warnings.warn(
                  "Value based partial slicing on non-monotonic DatetimeIndexes "
                  "with non-existing keys is deprecated and will raise a "
                  "KeyError in a future Version.",
                  FutureWarning,
                  stacklevel=5,
              )
          indexer = mask.nonzero()[0][::step]
          if len(indexer) == len(self):
              return slice(None)
          else:
              return indexer
  
      # --------------------------------------------------------------------
  
      @property
      def inferred_type(self) -> str:
          # b/c datetime is represented as microseconds since the epoch, make
          # sure we can't have ambiguous indexing
          return "datetime64"
  
      def indexer_at_time(self, time, asof=False):
          """
          Return index locations of values at particular time of day
          (e.g. 9:30AM).
  
          Parameters
          ----------
          time : datetime.time or str
              Time passed in either as object (datetime.time) or as string in
              appropriate format ("%H:%M", "%H%M", "%I:%M%p", "%I%M%p",
              "%H:%M:%S", "%H%M%S", "%I:%M:%S%p", "%I%M%S%p").
  
          Returns
          -------
          values_at_time : array of integers
  
          See Also
          --------
          indexer_between_time : Get index locations of values between particular
              times of day.
          DataFrame.at_time : Select values at particular time of day.
          """
          if asof:
              raise NotImplementedError("'asof' argument is not supported")
  
          if isinstance(time, str):
              from dateutil.parser import parse
  
              time = parse(time).time()
  
          if time.tzinfo:
              if self.tz is None:
                  raise ValueError("Index must be timezone aware.")
              time_micros = self.tz_convert(time.tzinfo)._get_time_micros()
          else:
              time_micros = self._get_time_micros()
          micros = _time_to_micros(time)
          return (micros == time_micros).nonzero()[0]
  
      def indexer_between_time(
          self, start_time, end_time, include_start=True, include_end=True
      ):
          """
          Return index locations of values between particular times of day
          (e.g., 9:00-9:30AM).
  
          Parameters
          ----------
          start_time, end_time : datetime.time, str
              Time passed either as object (datetime.time) or as string in
              appropriate format ("%H:%M", "%H%M", "%I:%M%p", "%I%M%p",
              "%H:%M:%S", "%H%M%S", "%I:%M:%S%p","%I%M%S%p").
          include_start : bool, default True
          include_end : bool, default True
  
          Returns
          -------
          values_between_time : array of integers
  
          See Also
          --------
          indexer_at_time : Get index locations of values at particular time of day.
          DataFrame.between_time : Select values between particular times of day.
          """
          start_time = to_time(start_time)
          end_time = to_time(end_time)
          time_micros = self._get_time_micros()
          start_micros = _time_to_micros(start_time)
          end_micros = _time_to_micros(end_time)
  
          if include_start and include_end:
              lop = rop = operator.le
          elif include_start:
              lop = operator.le
              rop = operator.lt
          elif include_end:
              lop = operator.lt
              rop = operator.le
          else:
              lop = rop = operator.lt
  
          if start_time <= end_time:
              join_op = operator.and_
          else:
              join_op = operator.or_
  
          mask = join_op(lop(start_micros, time_micros), rop(time_micros, end_micros))
  
          return mask.nonzero()[0]
  
  
  def date_range(
      start=None,
      end=None,
      periods=None,
      freq=None,
      tz=None,
      normalize=False,
      name=None,
      closed=None,
      **kwargs,
  ) -> DatetimeIndex:
      """
      Return a fixed frequency DatetimeIndex.
  
      Returns the range of equally spaced time points (where the difference between any
      two adjacent points is specified by the given frequency) such that they all
      satisfy `start <[=] x <[=] end`, where the first one and the last one are, resp.,
      the first and last time points in that range that fall on the boundary of ``freq``
      (if given as a frequency string) or that are valid for ``freq`` (if given as a
      :class:`pandas.tseries.offsets.DateOffset`). (If exactly one of ``start``,
      ``end``, or ``freq`` is *not* specified, this missing parameter can be computed
      given ``periods``, the number of timesteps in the range. See the note below.)
  
      Parameters
      ----------
      start : str or datetime-like, optional
          Left bound for generating dates.
      end : str or datetime-like, optional
          Right bound for generating dates.
      periods : int, optional
          Number of periods to generate.
      freq : str or DateOffset, default 'D'
          Frequency strings can have multiples, e.g. '5H'. See
          :ref:`here <timeseries.offset_aliases>` for a list of
          frequency aliases.
      tz : str or tzinfo, optional
          Time zone name for returning localized DatetimeIndex, for example
          'Asia/Hong_Kong'. By default, the resulting DatetimeIndex is
          timezone-naive.
      normalize : bool, default False
          Normalize start/end dates to midnight before generating date range.
      name : str, default None
          Name of the resulting DatetimeIndex.
      closed : {None, 'left', 'right'}, optional
          Make the interval closed with respect to the given frequency to
          the 'left', 'right', or both sides (None, the default).
      **kwargs
          For compatibility. Has no effect on the result.
  
      Returns
      -------
      rng : DatetimeIndex
  
      See Also
      --------
      DatetimeIndex : An immutable container for datetimes.
      timedelta_range : Return a fixed frequency TimedeltaIndex.
      period_range : Return a fixed frequency PeriodIndex.
      interval_range : Return a fixed frequency IntervalIndex.
  
      Notes
      -----
      Of the four parameters ``start``, ``end``, ``periods``, and ``freq``,
      exactly three must be specified. If ``freq`` is omitted, the resulting
      ``DatetimeIndex`` will have ``periods`` linearly spaced elements between
      ``start`` and ``end`` (closed on both sides).
  
      To learn more about the frequency strings, please see `this link
      <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
  
      Examples
      --------
      **Specifying the values**
  
      The next four examples generate the same `DatetimeIndex`, but vary
      the combination of `start`, `end` and `periods`.
  
      Specify `start` and `end`, with the default daily frequency.
  
      >>> pd.date_range(start='1/1/2018', end='1/08/2018')
      DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04',
                     '2018-01-05', '2018-01-06', '2018-01-07', '2018-01-08'],
                    dtype='datetime64[ns]', freq='D')
  
      Specify `start` and `periods`, the number of periods (days).
  
      >>> pd.date_range(start='1/1/2018', periods=8)
      DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04',
                     '2018-01-05', '2018-01-06', '2018-01-07', '2018-01-08'],
                    dtype='datetime64[ns]', freq='D')
  
      Specify `end` and `periods`, the number of periods (days).
  
      >>> pd.date_range(end='1/1/2018', periods=8)
      DatetimeIndex(['2017-12-25', '2017-12-26', '2017-12-27', '2017-12-28',
                     '2017-12-29', '2017-12-30', '2017-12-31', '2018-01-01'],
                    dtype='datetime64[ns]', freq='D')
  
      Specify `start`, `end`, and `periods`; the frequency is generated
      automatically (linearly spaced).
  
      >>> pd.date_range(start='2018-04-24', end='2018-04-27', periods=3)
      DatetimeIndex(['2018-04-24 00:00:00', '2018-04-25 12:00:00',
                     '2018-04-27 00:00:00'],
                    dtype='datetime64[ns]', freq=None)
  
      **Other Parameters**
  
      Changed the `freq` (frequency) to ``'M'`` (month end frequency).
  
      >>> pd.date_range(start='1/1/2018', periods=5, freq='M')
      DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31', '2018-04-30',
                     '2018-05-31'],
                    dtype='datetime64[ns]', freq='M')
  
      Multiples are allowed
  
      >>> pd.date_range(start='1/1/2018', periods=5, freq='3M')
      DatetimeIndex(['2018-01-31', '2018-04-30', '2018-07-31', '2018-10-31',
                     '2019-01-31'],
                    dtype='datetime64[ns]', freq='3M')
  
      `freq` can also be specified as an Offset object.
  
      >>> pd.date_range(start='1/1/2018', periods=5, freq=pd.offsets.MonthEnd(3))
      DatetimeIndex(['2018-01-31', '2018-04-30', '2018-07-31', '2018-10-31',
                     '2019-01-31'],
                    dtype='datetime64[ns]', freq='3M')
  
      Specify `tz` to set the timezone.
  
      >>> pd.date_range(start='1/1/2018', periods=5, tz='Asia/Tokyo')
      DatetimeIndex(['2018-01-01 00:00:00+09:00', '2018-01-02 00:00:00+09:00',
                     '2018-01-03 00:00:00+09:00', '2018-01-04 00:00:00+09:00',
                     '2018-01-05 00:00:00+09:00'],
                    dtype='datetime64[ns, Asia/Tokyo]', freq='D')
  
      `closed` controls whether to include `start` and `end` that are on the
      boundary. The default includes boundary points on either end.
  
      >>> pd.date_range(start='2017-01-01', end='2017-01-04', closed=None)
      DatetimeIndex(['2017-01-01', '2017-01-02', '2017-01-03', '2017-01-04'],
                    dtype='datetime64[ns]', freq='D')
  
      Use ``closed='left'`` to exclude `end` if it falls on the boundary.
  
      >>> pd.date_range(start='2017-01-01', end='2017-01-04', closed='left')
      DatetimeIndex(['2017-01-01', '2017-01-02', '2017-01-03'],
                    dtype='datetime64[ns]', freq='D')
  
      Use ``closed='right'`` to exclude `start` if it falls on the boundary.
  
      >>> pd.date_range(start='2017-01-01', end='2017-01-04', closed='right')
      DatetimeIndex(['2017-01-02', '2017-01-03', '2017-01-04'],
                    dtype='datetime64[ns]', freq='D')
      """
      if freq is None and com.any_none(periods, start, end):
          freq = "D"
  
      dtarr = DatetimeArray._generate_range(
          start=start,
          end=end,
          periods=periods,
          freq=freq,
          tz=tz,
          normalize=normalize,
          closed=closed,
          **kwargs,
      )
      return DatetimeIndex._simple_new(dtarr, name=name)
  
  
  def bdate_range(
      start=None,
      end=None,
      periods: Optional[int] = None,
      freq="B",
      tz=None,
      normalize=True,
      name=None,
      weekmask=None,
      holidays=None,
      closed=None,
      **kwargs,
  ) -> DatetimeIndex:
      """
      Return a fixed frequency DatetimeIndex, with business day as the default
      frequency.
  
      Parameters
      ----------
      start : str or datetime-like, default None
          Left bound for generating dates.
      end : str or datetime-like, default None
          Right bound for generating dates.
      periods : int, default None
          Number of periods to generate.
      freq : str or DateOffset, default 'B' (business daily)
          Frequency strings can have multiples, e.g. '5H'.
      tz : str or None
          Time zone name for returning localized DatetimeIndex, for example
          Asia/Beijing.
      normalize : bool, default False
          Normalize start/end dates to midnight before generating date range.
      name : str, default None
          Name of the resulting DatetimeIndex.
      weekmask : str or None, default None
          Weekmask of valid business days, passed to ``numpy.busdaycalendar``,
          only used when custom frequency strings are passed.  The default
          value None is equivalent to 'Mon Tue Wed Thu Fri'.
      holidays : list-like or None, default None
          Dates to exclude from the set of valid business days, passed to
          ``numpy.busdaycalendar``, only used when custom frequency strings
          are passed.
      closed : str, default None
          Make the interval closed with respect to the given frequency to
          the 'left', 'right', or both sides (None).
      **kwargs
          For compatibility. Has no effect on the result.
  
      Returns
      -------
      DatetimeIndex
  
      Notes
      -----
      Of the four parameters: ``start``, ``end``, ``periods``, and ``freq``,
      exactly three must be specified.  Specifying ``freq`` is a requirement
      for ``bdate_range``.  Use ``date_range`` if specifying ``freq`` is not
      desired.
  
      To learn more about the frequency strings, please see `this link
      <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
  
      Examples
      --------
      Note how the two weekend days are skipped in the result.
  
      >>> pd.bdate_range(start='1/1/2018', end='1/08/2018')
      DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04',
                 '2018-01-05', '2018-01-08'],
                dtype='datetime64[ns]', freq='B')
      """
      if freq is None:
          msg = "freq must be specified for bdate_range; use date_range instead"
          raise TypeError(msg)
  
      if isinstance(freq, str) and freq.startswith("C"):
          try:
              weekmask = weekmask or "Mon Tue Wed Thu Fri"
              freq = prefix_mapping[freq](holidays=holidays, weekmask=weekmask)
          except (KeyError, TypeError) as err:
              msg = f"invalid custom frequency string: {freq}"
              raise ValueError(msg) from err
      elif holidays or weekmask:
          msg = (
              "a custom frequency string is required when holidays or "
              f"weekmask are passed, got frequency {freq}"
          )
          raise ValueError(msg)
  
      return date_range(
          start=start,
          end=end,
          periods=periods,
          freq=freq,
          tz=tz,
          normalize=normalize,
          name=name,
          closed=closed,
          **kwargs,
      )
  
  
  def _time_to_micros(time_obj: time) -> int:
      seconds = time_obj.hour * 60 * 60 + 60 * time_obj.minute + time_obj.second
      return 1_000_000 * seconds + time_obj.microsecond
  