code: def date_range(
      start=None,
      end=None,
      periods=None,
      freq=None,
      tz=None,
      normalize: bool = False,
      name: Hashable = None,
      inclusive: IntervalClosedType = "both",
      *,
      unit: str | None = 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, datetime.timedelta, 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 unless timezone-aware datetime-likes are passed.
      normalize : bool, default False
          Normalize start/end dates to midnight before generating date range.
      name : str, default None
          Name of the resulting DatetimeIndex.
      inclusive : {"both", "neither", "left", "right"}, default "both"
          Include boundaries; Whether to set each bound as closed or open.
  
          .. versionadded:: 1.4.0
      unit : str, default None
          Specify the desired resolution of the result.
  
          .. versionadded:: 2.0.0
      **kwargs
          For compatibility. Has no effect on the result.
  
      Returns
      -------
      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 timezone-aware `start` and `end`, with the default daily frequency.
  
      >>> pd.date_range(
      ...     start=pd.to_datetime("1/1/2018").tz_localize("Europe/Berlin"),
      ...     end=pd.to_datetime("1/08/2018").tz_localize("Europe/Berlin"),
      ... )
      DatetimeIndex(['2018-01-01 00:00:00+01:00', '2018-01-02 00:00:00+01:00',
                     '2018-01-03 00:00:00+01:00', '2018-01-04 00:00:00+01:00',
                     '2018-01-05 00:00:00+01:00', '2018-01-06 00:00:00+01:00',
                     '2018-01-07 00:00:00+01:00', '2018-01-08 00:00:00+01:00'],
                    dtype='datetime64[ns, Europe/Berlin]', 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')
  
      `inclusive` controls whether to include `start` and `end` that are on the
      boundary. The default, "both", includes boundary points on either end.
  
      >>> pd.date_range(start='2017-01-01', end='2017-01-04', inclusive="both")
      DatetimeIndex(['2017-01-01', '2017-01-02', '2017-01-03', '2017-01-04'],
                    dtype='datetime64[ns]', freq='D')
  
      Use ``inclusive='left'`` to exclude `end` if it falls on the boundary.
  
      >>> pd.date_range(start='2017-01-01', end='2017-01-04', inclusive='left')
      DatetimeIndex(['2017-01-01', '2017-01-02', '2017-01-03'],
                    dtype='datetime64[ns]', freq='D')
  
      Use ``inclusive='right'`` to exclude `start` if it falls on the boundary, and
      similarly ``inclusive='neither'`` will exclude both `start` and `end`.
  
      >>> pd.date_range(start='2017-01-01', end='2017-01-04', inclusive='right')
      DatetimeIndex(['2017-01-02', '2017-01-03', '2017-01-04'],
                    dtype='datetime64[ns]', freq='D')
  
      **Specify a unit**
  
      >>> pd.date_range(start="2017-01-01", periods=10, freq="100AS", unit="s")
      DatetimeIndex(['2017-01-01', '2117-01-01', '2217-01-01', '2317-01-01',
                     '2417-01-01', '2517-01-01', '2617-01-01', '2717-01-01',
                     '2817-01-01', '2917-01-01'],
                    dtype='datetime64[s]', freq='100AS-JAN')
      """
      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,
          inclusive=inclusive,
          unit=unit,
          **kwargs,
      )
      return DatetimeIndex._simple_new(dtarr, name=name)
  
imports: from __future__ import annotations
  import datetime
  import operator
  from typing import TYPE_CHECKING, Hashable
  import warnings
  import numpy
  import pytz
  from pandas._libs import NaT, Period, Timestamp, index, lib
  from pandas._libs.tslibs import Resolution, periods_per_day, timezones, to_offset
  from pandas._libs.tslibs.offsets import prefix_mapping
  from pandas._typing import Dtype, DtypeObj, Frequency, IntervalClosedType, TimeAmbiguous, TimeNonexistent, npt
  from pandas.util._decorators import cache_readonly, doc
  from pandas.core.dtypes.common import is_datetime64_dtype, is_datetime64tz_dtype, is_scalar
  from pandas.core.dtypes.generic import ABCSeries
  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
  from pandas.core.indexes.base import Index, 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
label_desc: Use image node_id 2 for calling a global function with example usage: date_range(start, end, periods, freq, tz, normalize, name, inclusive) and returns: DatetimeIndex