+ xȇi ^RIHt^RIt^RIt^RIHtHt^RIt^RI t ^RI H t H t HtHtHt^RIHtHtHtHtHtHt^RIHt^RIHtHt^RIHt^R I H!t!H"t"^R I#H$t$^R I%H&t&^R I'H(t(H)t)^R I*H+t+^RI,H-t-^RI.H/t/H0t0^RI1H2uH3t4^RI5H6t6H7t7^RI8H9t9^RI:H;t;^RIH?t?^RI@HAtAHBtBHCtCHDtDHEtEHFtFHGtGHHtH^RIIHJtJHKtK^RIHLtLRtM];!]/P]/PUu.uFpVR'9gK VNK up,]/RR7];!R.]/RR7];!.R(O]/PO]/4]"!R4!RR]944444tQ]"!R4R)R R/R!R"lll4tR]"!R4R*R#R$ll4tSR%R&ltTR#uupi)+) annotationsN) TYPE_CHECKINGSelf)NaTPeriod Timestampindexlib) ResolutionTick Timedeltaperiods_per_day timezones to_offset)abbrev_to_npy_unit) DateOffsetprefix_mapping)Pandas4Warning)cache_readonly set_module)find_stack_level) is_scalar) ArrowDtypeDatetimeTZDtype) ABCSeries)is_valid_na_for_dtype) DatetimeArray tz_to_dtype)Indexmaybe_extract_name)DatetimeTimedeltaMixin) inherit_names)to_time)Hashable)DtypeDtypeObj FrequencyIntervalClosedType TimeAmbiguousTimeNonexistentnptTimeUnit) DataFrame PeriodIndex)OFFSET_TO_PERIOD_FREQSTRcRV9d\VR,\4'gVPR4p\V\4'gFVPR4pVPR4p\P!V\ V4VR7pMR3lt#] R4R5l4t$R?R6R7llt%R@R8R9llt&R:t'V;t(#)Ar7aw 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. .. versionchanged:: 2.0.0 The various numeric date/time attributes (:attr:`~DatetimeIndex.day`, :attr:`~DatetimeIndex.month`, :attr:`~DatetimeIndex.year` etc.) now have dtype ``int32``. Previously they had dtype ``int64``. Parameters ---------- data : array-like (1-dimensional) 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 : zoneinfo.ZoneInfo, pytz.timezone, dateutil.tz.tzfile, datetime.tzinfo or str Set the Timezone of the data. 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 a ValueError 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 None Whether to copy input data, only relevant for array, Series, and Index inputs (for other input, e.g. a list, a new array is created anyway). Defaults to True for array input and False for Index/Series. Set to False to avoid copying array input at your own risk (if you know the input data won't be modified elsewhere). Set to True to force copying Series/Index up front. 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 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_pydatetime to_series to_frame to_julian_date 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 :ref:`this link`. Examples -------- >>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"]) >>> idx DatetimeIndex(['2020-01-01 10:00:00+00:00', '2020-02-01 11:00:00+00:00'], dtype='datetime64[us, UTC]', freq=None) datetimeindexTcV^8dQhRR/#)returnztype[libindex.DatetimeEngine])formats"rD __annotate__DatetimeIndex.__annotate__s'';'c "\P#N)libindexDatetimeEngineselfs&rD _engine_typeDatetimeIndex._engine_types&&&rSr_data_valueszdt.tzinfo | Noner2cV^8dQhRR/#rMrNrrO)rPs"rDrQrRs,G,Gu,GrSc |VPPV4p\W PVPRR7#)a Convert to Index using specified date_format. Return an Index of formatted strings specified by date_format, which supports the same string format as the python standard library. Details of the string format can be found in `python string format doc `__. Formats supported by the C `strftime` API but not by the python string format doc (such as `"%R"`, `"%r"`) are not officially supported and should be preferably replaced with their supported equivalents (such as `"%H:%M"`, `"%I:%M:%S %p"`). Note that `PeriodIndex` support additional directives, detailed in `Period.strftime`. Parameters ---------- date_format : str Date format string (e.g. "%Y-%m-%d"). Returns ------- ndarray[object] NumPy ndarray of formatted strings. See Also -------- to_datetime : Convert the given argument to datetime. DatetimeIndex.normalize : Return DatetimeIndex with times to midnight. DatetimeIndex.round : Round the DatetimeIndex to the specified freq. DatetimeIndex.floor : Floor the DatetimeIndex to the specified freq. Timestamp.strftime : Format a single Timestamp. Period.strftime : Format a single Period. Examples -------- >>> rng = pd.date_range(pd.Timestamp("2018-03-10 09:00"), periods=3, freq="s") >>> rng.strftime("%B %d, %Y, %r") Index(['March 10, 2018, 09:00:00 AM', 'March 10, 2018, 09:00:01 AM', 'March 10, 2018, 09:00:02 AM'], dtype='str') F)namer4copy)r\strftimerrar4)rY date_formatarrs&& rDrcDatetimeIndex.strftimes0Vjj!!+.Syy FFrScV^8dQhRR/#)rMrNrrO)rPs"rDrQrRHsDRDRDRrSc VPPV4p\V4PW PVP R7#)a Convert tz-aware Datetime Array/Index from one time zone to another. Parameters ---------- tz : str, zoneinfo.ZoneInfo, pytz.timezone, dateutil.tz.tzfile, datetime.tzinfo or None Time zone for time. Corresponding timestamps would be converted to this time zone of the Datetime Array/Index. A `tz` of None will convert to UTC and remove the timezone information. Returns ------- Array or Index Datetme Array/Index with target `tz`. Raises ------ TypeError If Datetime Array/Index is tz-naive. See Also -------- DatetimeIndex.tz : A timezone that has a variable offset from UTC. DatetimeIndex.tz_localize : Localize tz-naive DatetimeIndex to a given time zone, or remove timezone from a tz-aware DatetimeIndex. Examples -------- With the `tz` parameter, we can change the DatetimeIndex to other time zones: >>> dti = pd.date_range( ... start="2014-08-01 09:00", freq="h", periods=3, tz="Europe/Berlin" ... ) >>> dti DatetimeIndex(['2014-08-01 09:00:00+02:00', '2014-08-01 10:00:00+02:00', '2014-08-01 11:00:00+02:00'], dtype='datetime64[us, Europe/Berlin]', freq='h') >>> dti.tz_convert("US/Central") DatetimeIndex(['2014-08-01 02:00:00-05:00', '2014-08-01 03:00:00-05:00', '2014-08-01 04:00:00-05:00'], dtype='datetime64[us, US/Central]', freq='h') With the ``tz=None``, we can remove the timezone (after converting to UTC if necessary): >>> dti = pd.date_range( ... start="2014-08-01 09:00", freq="h", periods=3, tz="Europe/Berlin" ... ) >>> dti DatetimeIndex(['2014-08-01 09:00:00+02:00', '2014-08-01 10:00:00+02:00', '2014-08-01 11:00:00+02:00'], dtype='datetime64[us, Europe/Berlin]', freq='h') >>> dti.tz_convert(None) DatetimeIndex(['2014-08-01 07:00:00', '2014-08-01 08:00:00', '2014-08-01 09:00:00'], dtype='datetime64[us]', freq='h') rarefs)r\ tz_converttyper9ra _references)rYr2res&& rDrkDatetimeIndex.tz_convertHs=Fjj##B'Dz%%c @P@P%QQrSraisec$V^8dQhRRRRRR/#)rM ambiguousr) nonexistentr*rNrrO)rPs"rDrQrRs/R;R;!R;% R;  R;rSc VPPWV4p\V4PW@PR7#)aL Localize tz-naive Datetime Array/Index to tz-aware Datetime Array/Index. This method takes a time zone (tz) naive Datetime Array/Index object and makes this time zone aware. It does not move the time to another time zone. This method can also be used to do the inverse -- to create a time zone unaware object from an aware object. To that end, pass `tz=None`. Parameters ---------- tz : str, zoneinfo.ZoneInfo,, pytz.timezone, dateutil.tz.tzfile, datetime.tzinfo or None Time zone to convert timestamps to. Passing ``None`` will remove the time zone information preserving local time. ambiguous : 'infer', 'NaT', bool array, 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 a ValueError if there are ambiguous times. nonexistent : 'shift_forward', 'shift_backward, 'NaT', timedelta, default 'raise' A nonexistent time does not exist in a particular timezone where clocks moved forward due to DST. - 'shift_forward' will shift the nonexistent time forward to the closest existing time - 'shift_backward' will shift the nonexistent time backward to the closest existing time - 'NaT' will return NaT where there are nonexistent times - timedelta objects will shift nonexistent times by the timedelta - 'raise' will raise a ValueError if there are nonexistent times. Returns ------- Same type as self Array/Index converted to the specified time zone. Raises ------ TypeError If the Datetime Array/Index is tz-aware and tz is not None. See Also -------- DatetimeIndex.tz_convert : Convert tz-aware DatetimeIndex from one time zone to another. Examples -------- >>> tz_naive = pd.date_range('2018-03-01 09:00', periods=3) >>> tz_naive DatetimeIndex(['2018-03-01 09:00:00', '2018-03-02 09:00:00', '2018-03-03 09:00:00'], dtype='datetime64[us]', freq='D') Localize DatetimeIndex in US/Eastern time zone: >>> tz_aware = tz_naive.tz_localize(tz='US/Eastern') >>> tz_aware DatetimeIndex(['2018-03-01 09:00:00-05:00', '2018-03-02 09:00:00-05:00', '2018-03-03 09:00:00-05:00'], dtype='datetime64[us, US/Eastern]', freq=None) With the ``tz=None``, we can remove the time zone information while keeping the local time (not converted to UTC): >>> tz_aware.tz_localize(None) DatetimeIndex(['2018-03-01 09:00:00', '2018-03-02 09:00:00', '2018-03-03 09:00:00'], dtype='datetime64[us]', freq=None) Be careful with DST changes. When there is sequential data, pandas can infer the DST time: >>> s = pd.to_datetime(pd.Series(['2018-10-28 01:30:00', ... '2018-10-28 02:00:00', ... '2018-10-28 02:30:00', ... '2018-10-28 02:00:00', ... '2018-10-28 02:30:00', ... '2018-10-28 03:00:00', ... '2018-10-28 03:30:00'])) >>> s.dt.tz_localize('CET', ambiguous='infer') 0 2018-10-28 01:30:00+02:00 1 2018-10-28 02:00:00+02:00 2 2018-10-28 02:30:00+02:00 3 2018-10-28 02:00:00+01:00 4 2018-10-28 02:30:00+01:00 5 2018-10-28 03:00:00+01:00 6 2018-10-28 03:30:00+01:00 dtype: datetime64[us, CET] In some cases, inferring the DST is impossible. In such cases, you can pass an ndarray to the ambiguous parameter to set the DST explicitly >>> s = pd.to_datetime(pd.Series(['2018-10-28 01:20:00', ... '2018-10-28 02:36:00', ... '2018-10-28 03:46:00'])) >>> s.dt.tz_localize('CET', ambiguous=np.array([True, True, False])) 0 2018-10-28 01:20:00+02:00 1 2018-10-28 02:36:00+02:00 2 2018-10-28 03:46:00+01:00 dtype: datetime64[us, CET] If the DST transition causes nonexistent times, you can shift these dates forward or backwards with a timedelta object or `'shift_forward'` or `'shift_backwards'`. >>> s = pd.to_datetime(pd.Series(['2015-03-29 02:30:00', ... '2015-03-29 03:30:00'], dtype="M8[ns]")) >>> s.dt.tz_localize('Europe/Warsaw', nonexistent='shift_forward') 0 2015-03-29 03:00:00+02:00 1 2015-03-29 03:30:00+02:00 dtype: datetime64[ns, Europe/Warsaw] >>> s.dt.tz_localize('Europe/Warsaw', nonexistent='shift_backward') 0 2015-03-29 01:59:59.999999999+01:00 1 2015-03-29 03:30:00+02:00 dtype: datetime64[ns, Europe/Warsaw] >>> s.dt.tz_localize('Europe/Warsaw', nonexistent=pd.Timedelta('1h')) 0 2015-03-29 03:30:00+02:00 1 2015-03-29 03:30:00+02:00 dtype: datetime64[ns, Europe/Warsaw] ra)r\ tz_localizerlr9ra)rYr2rqrrres&&&& rDruDatetimeIndex.tz_localizes7bjj$$RK@Dz%%c %::rSNcV^8dQhRR/#)rMrNr.rO)rPs"rDrQrR"s6<6` or a Period object. Will be inferred by default. Returns ------- PeriodArray/PeriodIndex Immutable ndarray holding ordinal values at a particular frequency. Raises ------ ValueError When converting a DatetimeArray/Index with non-regular values, so that a frequency cannot be inferred. See Also -------- PeriodIndex: Immutable ndarray holding ordinal values. DatetimeIndex.to_pydatetime: Return DatetimeIndex as object. Examples -------- >>> df = pd.DataFrame( ... {"y": [1, 2, 3]}, ... index=pd.to_datetime( ... [ ... "2000-03-31 00:00:00", ... "2000-05-31 00:00:00", ... "2000-08-31 00:00:00", ... ] ... ), ... ) >>> df.index.to_period("M") PeriodIndex(['2000-03', '2000-05', '2000-08'], dtype='period[M]') Infer the daily frequency >>> idx = pd.date_range("2017-01-01", periods=2) >>> idx.to_period() PeriodIndex(['2017-01-01', '2017-01-02'], dtype='period[D]') )r.rt)pandas.core.indexes.apir.r\ to_periodr9ra)rYr3r.res&& rDrzDatetimeIndex.to_period"s1f 8jj""4(&&s;;rScV^8dQhRR/#r_rO)rPs"rDrQrRZs666rSc xVPP4p\P!WPR7#)a Convert TimeStamp to a Julian Date. This method returns the number of days as a float since noon January 1, 4713 BC. https://en.wikipedia.org/wiki/Julian_day Returns ------- ndarray or Index Float values that represent each date in Julian Calendar. See Also -------- Timestamp.to_julian_date : Equivalent method on ``Timestamp`` objects. Examples -------- >>> idx = pd.DatetimeIndex(["2028-08-12 00:54", "2028-08-12 02:06"]) >>> idx.to_julian_date() Index([2461995.5375, 2461995.5875], dtype='float64') rt)r\to_julian_daterr9ra)rYres& rDr~DatetimeIndex.to_julian_dateZs+.jj'')  9955rScV^8dQhRR/#)rMrNr-rO)rPs"rDrQrRts""Y"rSc XVPP4pVPV4#)a Calculate year, week, and day according to the ISO 8601 standard. Returns ------- DataFrame With columns year, week and day. See Also -------- Timestamp.isocalendar : Function return a 3-tuple containing ISO year, week number, and weekday for the given Timestamp object. datetime.date.isocalendar : Return a named tuple object with three components: year, week and weekday. Examples -------- >>> idx = pd.date_range(start="2019-12-29", freq="D", periods=4) >>> idx.isocalendar() year week day 2019-12-29 2019 52 7 2019-12-30 2020 1 1 2019-12-31 2020 1 2 2020-01-01 2020 1 3 >>> idx.isocalendar().week 2019-12-29 52 2019-12-30 1 2019-12-31 1 2020-01-01 1 Freq: D, Name: week, dtype: UInt32 )r\ isocalendar set_index)rYdfs& rDrDatetimeIndex.isocalendarts%<ZZ # # %||D!!rScV^8dQhRR/#)rMrNr rO)rPs"rDrQrRs***rSc .VPP#rU)r\_resolution_objrXs&rDrDatetimeIndex._resolution_objszz)))rSFc8V^8dQhRRRRRRRRRR R R R R RR/#)rMr3zFrequency | lib.NoDefaultrqr)dayfirstbool yearfirstr4z Dtype | Nonerbz bool | NoneraHashable | NonerNrrO)rPs"rDrQrRs\11(1 ! 1  11111 1rSc  (\V4'dVPV4\WV4p VPWV4wr\ V\ 4'dWV\ PJdCV\ PJd/Vf+V'dVP4pVPWR7#\ P!VVVVVVVVR7p Rp V'g)\ V\\34'd VPp VPWV R7p V #)Nrt)r4rbr2r3rrrqri)r_raise_scalar_data_errorr _maybe_copy_array_inputr6rr no_defaultrbr9_from_sequence_not_strictrrrm) r?r1r3r2rqrrr4rbradtarrrjsubarrs &&&&&&&&&& rDr>DatetimeIndex.__new__s T??  ( ( ."$c200UC  t] + +&cnn$ yy{??4?3 377    4%);<<##D= rScV^8dQhRR/#rMrNrrO)rPs"rDrQrRs+++rSc \VP\4'dP\VP4pV\P !^R7,\P !^R78wdR#VP P#)zY Return a boolean if we are only dates (and don't have a timezone) Returns ------- bool )daysF)r6r3r r dt timedeltar]_is_dates_only)rYdeltas& rDrDatetimeIndex._is_dates_onlysU dii & &dii(Er||++r||/CC||***rSc ^RVPRVP/p\\V4V3R3#)r1raN)r\rarErl)rYr@s& rD __reduce__DatetimeIndex.__reduce__s- TZZ 3!DJ?D88rSc V^8dQhRRRR/#)rMr4r&rNrrO)rPs"rDrQrRs++(+t+rSc ,\V\4'dKVPR8wdR#VPpVPRJVPRJ, 'dR#R#VPe\V\ 4#\ P!VR4#)z6 Can we compare values of the given dtype to our own? MFNT)r6rkind pyarrow_dtyper2rr is_np_dtype)rYr4pa_dtypes&& rD_is_comparable_dtype"DatetimeIndex._is_comparable_dtypesu eZ ( (zzS **H t#488 77 e_5 5uc**rSc Ba^RIHpV!VPR7oV3Rl#)r)get_format_datetime64) is_dates_onlyc<RS!V4 R2#)'rO)x formatters&rD/DatetimeIndex._formatter_func..s1Yq\N!,rS)pandas.io.formats.formatrr)rYrrs& @rD_formatter_funcDatetimeIndex._formatter_funcs C)8K8KL ,,rScV^8dQhRR/#rrO)rPs"rDrQrR s///rSc <VPeO\P!VP4'g)\P!VP4'gR#VPeO\P!VP4'g)\P!VP4'gR#\SV`V4#)NF)r2ris_utcis_fixed_offsetsuper_can_range_setop)rYother __class__s&&rDrDatetimeIndex._can_range_setop s GG $$TWW----dgg66 HH $$UXX..--ehh77w'..rScV^8dQhRR/#)rMrNznpt.NDArray[np.int64]rO)rPs"rDrQrRs"7rSc VPP4p\VPP4pW,pVPR8Xd VR,pM_VPR8XdTpMKVPR8Xd VR,pM0VPR8Xd VR,pM\ VP4hRW@P &V#)zU Return the number of microseconds since midnight. Returns ------- ndarray[int64_t] nsiusmss@B)r\_local_timestampsr_cresounitNotImplementedError_isnan)rYvaluesppdfracmicross& rD_get_time_microsDatetimeIndex._get_time_micross--/djj//0| 99 T\F YY$ F YY$ D[F YY# I%F%dii0 0 {{ rSc V^8dQhRRRR/#)rMr3r'rNr7rO)rPs"rDrQrR7s4>4>4>]4>rSc \V4pVPP4p\V4Fnwr4TpVP V4'gMVP V4pVP V4p\WV, 4\Wu, 48dTpMTpWRV&Kp \PW PR7#)a Snap time stamps to nearest occurring frequency. Parameters ---------- freq : str, Timedelta, datetime.timedelta, or DateOffset, default 'S' Frequency strings can have multiples, e.g. '5h'. See :ref:`here ` for a list of frequency aliases. Returns ------- DatetimeIndex Time stamps to nearest occurring `freq`. See Also -------- DatetimeIndex.round : Perform round operation on the data to the specified `freq`. DatetimeIndex.floor : Perform floor operation on the data to the specified `freq`. Examples -------- >>> idx = pd.DatetimeIndex( ... ["2023-01-01", "2023-01-02", "2023-02-01", "2023-02-02"], ... dtype="M8[ns]", ... ) >>> idx DatetimeIndex(['2023-01-01', '2023-01-02', '2023-02-01', '2023-02-02'], dtype='datetime64[ns]', freq=None) >>> idx.snap("MS") DatetimeIndex(['2023-01-01', '2023-01-01', '2023-02-01', '2023-02-01'], dtype='datetime64[ns]', freq=None) rt) rr\rb enumerate is_on_offsetrollback rollforwardabsr7r9ra)rYr3rAivrt0t1s&& rDsnapDatetimeIndex.snap7sJjjoodODAA$$Q'']]1%%%a(qv;RV,AAF$((99(==rSc$V^8dQhRRRRRR/#)rMresor parsedz dt.datetimerNztuple[Timestamp, Timestamp]rO)rPs"rDrQrRps$***(3* $*rSc \P!VPVP4p\W#R7pVPpV^,P\ P !^R4, pVPVP4pVPVP4pVPVP4pVPVP4pVPeVPf \R4hWV3#)z Calculate datetime bounds for parsed time string and its resolution. Parameters ---------- reso : Resolution Resolution provided by parsed string. parsed : datetime Datetime from parsed string. Returns ------- lower, upper: pd.Timestamp )r3rzSThe index must be timezone aware when indexing with a date string with a UTC offset) r/get attr_abbrevr start_timenp timedelta64as_unitrrutzinfor2 ValueError)rYrrr3perstartends&&& rD_parsed_string_to_bounds&DatetimeIndex._parsed_string_to_boundsps"(++D,<,N>NOV'Qw""R^^At%<< dii(kk$))$ !!&--0oofmm, == $ww ;zrSc V^8dQhRRRR/#)rMlabelstrrNztuple[Timestamp, Resolution]rO)rPs"rDrQrRs  c .J rSc <\SV`V4wr#\V4pVPe*VPfVP VP4pW#3#rU)r_parse_with_resorr2rru)rYrrrrs&& rDrDatetimeIndex._parse_with_resosOw/6 6" 77 6==#8''0F|rScV^8dQhRR/#)rMrNNonerO)rPs"rDrQrRs ) )D )rSc |VPPV4R# \dp\T4ThRp?ii;i)zE Check for mismatched-tzawareness indexing and re-raise as KeyError. N)r\_assert_tzawareness_compat TypeErrorKeyError)rYrBerrs&& rD_disallow_mismatched_indexing+DatetimeIndex._disallow_mismatched_indexings5  ) JJ 1 1# 6 )3-S ( )s ; 6;c VPV4Tp\WP4'd\p\ WP P 4'dVPV4\V4pM\ V\4'dRVPV4wr4TPT4TPT4'dTPYC4#TpM\ V\P 4'd8\#R\%V4P& R\%V4P& 24h\ V\P(4'dVP+V4#\V4h\,P.!W4# \dp\T4ThRp?ii;i \dp\T4ThRp?ii;i \dp\T4ThRp?ii;i)zE Get integer location for requested label Returns ------- loc : int Nz Cannot index z with )_check_indexing_errorrr4rr6r\_recognized_scalarsrrrrrr_can_partial_date_slice_partial_date_slicerrrrl__name__timeindexer_at_timerget_loc)rYrBorig_keyrrrs&& rDr DatetimeIndex.get_locs ""3' jj 1 1C c::99 : :  . .s 3C.C S ! ! -#44S9   . .v 6++D11133DAAC R\\ * *T 3 34F49;M;M:NO RWW % %'', ,3-  .==+ +5 -sm, - 1"3-S01( .8$# - .sHF F'2G F$ FF$' G2 F>>G G" GG"cV^8dQhRR/#)rMsiderrO)rPs"rDrQrRs" " 3" rSc j<\V\P4'd_\V\P4'g?\ V4P 4p\ P!R\\4R7\SV`-W4pVPPV4\ V4#)aY This function should be overloaded in subclasses that allow non-trivial casting on label-slice bounds, e.g. datetime-like indices allowing strings containing formatted datetimes. Parameters ---------- label : object side : {'left', 'right'} Returns ------- label : object Notes ----- Value of `side` parameter should be validated in caller. zXSlicing with a datetime.date object is deprecated. Explicitly cast to Timestamp instead. stacklevel)r6rdatedatetimer to_pydatetimer;warnrrr_maybe_cast_slice_boundr\r)rYrr rs&&&rDr%DatetimeIndex._maybe_cast_slice_bounds( eRWW % %j .L.Le$224E MM8+-  /< --e4rSc \V\P4'dH\V\P4'd(VeV^8wd \R4hVP W4#\V\P4'g!\V\P4'd \ R4hRRlpV!V4'g!V!V4'gVP 'd\P!WW#4#\P!R4pRpVe0VPVR4pWp8*pWgV8HP4,pVe7VPVR4pW8*V,pWhV8HP4,pV'g \ R 4hVP4^,RRV1,p \V 4\V48Xd \R4#V #) a 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. Nz)Must have step size of 1 with time slicesz'Cannot mix time and non-time slice keyscV^8dQhRR/#rrO)rPs"rDrQ1DatetimeIndex.slice_indexer..__annotate__%s D D DrScDVRJ;'d\V\4'*#rU)r6r)points&rDcheck_str_or_none6DatetimeIndex.slice_indexer..check_str_or_none%s$CCZs-C)C CrSTleftrightzcValue based partial slicing on non-monotonic DatetimeIndexes with non-existing keys is not allowed.)r6rrrindexer_between_timeris_monotonic_increasingr slice_indexerrarrayranynonzerolenslice) rYrrsteprmaskin_index start_casted end_castedindexers &&&& rDr"DatetimeIndex.slice_indexer s" eRWW % %*S"''*B*BDAI !LMM,,U8 8 eRWW % %C)A)ADE E D e $ $ %%+++&&tC> >xx~  77vFL'D -224 4H ?55c7CJ&$.D t+002 2H9 ,,.#FdF+ w<3t9 $; NrScV^8dQhRR/#)rMrNrrO)rPs"rDrQrRLssrSc R#) datetime64rOrXs&rD inferred_typeDatetimeIndex.inferred_typeKsrSc V^8dQhRRRR/#)rMasofrrNnpt.NDArray[np.intp]rO)rPs"rDrQrRQsM4M4$M4;OM4rSc  V'd \R4h\V\4'da^RIHpTp\ V4pV!V4P 4pWQ8wd0\P!RV RV RV R2\\4R7VP'dDVPf \R 4hVPVP4P4pMVP4p\!V4pWg8HP#4^,# \dTpLi;i \dC\P!RT R2\\4R7T!T4P 4pLi;i) a Return index locations of values at particular time of day. 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"). asof : bool, default False This parameter is currently not supported. Returns ------- np.ndarray[np.intp] Index locations of values at given `time` of day. 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. Examples -------- >>> idx = pd.DatetimeIndex( ... ["1/1/2020 10:00", "2/1/2020 11:00", "3/1/2020 10:00"] ... ) >>> idx.indexer_at_time("10:00") array([0, 2]) z 'asof' argument is not supported)parsez The string 'z' is currently parsed as z+ but in a future version will be parsed as z, consistentwith `between_time` behavior. To avoid this warning, use an unambiguous string format or explicitly cast to `datetime.time` before calling.rz' cannot be parsed using pd.core.tools.to_time and in a future version will raise. Use an unambiguous time string format or explicitly cast to `datetime.time` before calling.zIndex must be timezone aware.)rr6rdateutil.parserr8r#rrr;rrrrr2rkr_time_to_microsr%)rYrr5r8origalt time_microsrs&&& rDrDatetimeIndex.indexer_at_timeQs]@ %&HI I dC -D dm ;++-D;MM&tf,EdVLEEHEJ:: '#3#5  ;;;ww !@AA//$++6GGIK//1K &%..033-"D * "4&)66#/1T{'') *s# D&D D#"D#&A E32E3c$V^8dQhRRRRRR/#)rM include_startr include_endrNr6rO)rPs"rDrQrRs$=!=!37=!MQ=! =!rSc *\V4p\V4pVP4p\V4p\V4pV'dV'd\P;rMcV'd"\Pp\P p M:V'd"\P p\Pp M\P ;rW8:d\P p M\Pp V !V!We4V !WW44p V P4^,#)ag Return index locations of values between particular times of day. 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 boundaries; whether to set start bound as closed or open. include_end : bool, default True Include boundaries; whether to set end bound as closed or open. Returns ------- np.ndarray[np.intp] Index locations of values between particular times of day. 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. Examples -------- >>> idx = pd.date_range("2023-01-01", periods=4, freq="h") >>> idx DatetimeIndex(['2023-01-01 00:00:00', '2023-01-01 01:00:00', '2023-01-01 02:00:00', '2023-01-01 03:00:00'], dtype='datetime64[us]', freq='h') >>> idx.indexer_between_time("00:00", "2:00", include_end=False) array([0, 1]) ) r#rr:operatorleltand_or_r%) rYrend_timer@rAr= start_micros end_microslopropjoin_opr)s &&&&& rDr "DatetimeIndex.indexer_between_timesJZ( 8$++- &z2 $X. [ #C# ++C++C ++C++C #C  !mmGllGs<5s;7ST||~a  rSrO)rororU)S)NNN)F)TT))r __module__ __qualname____firstlineno____doc___typr _data_cls!_supports_partial_string_indexingpropertyrZ__annotations__rcrkrurzr~rrrr rr>rrrrrrrrrrr rr"r2rr __static_attributes__ __classcell__)rs@rDr7r7ts@6yv DI(,% ''   ,G\DRLR;h6>#*" $1j++ 9+.--//&64>r*X   )2.h" " H;~ M4^=!=!rSr7rc ,V^8dQhRRRRRRRRR R /#) rM normalizerrar inclusiver(rzTimeUnit | NonerNr7rO)rPs"rDrQrQsE}7}7  }7 }7"}7 }7}7rSc Vf \P!W V4'dRpVe \V4pV\Jg V\Jd \ R4hVEfVebVe^\ V4p\ V4p\ VP4\ VP48dVPpMPVPpMCVe\ V4pVPpM'Ve\ V4pVPpM \ R4hVEe\ V4p \V\4'd)VPV 8dVPPpM\VR4'dKVPe=\VP4p \ V P4V 8d V PpM_\!V4\"JdM\%VR^4^8wdRpM7\%VR^4^8wd VR8wdRpM\%VR ^4^8wd VR9dR p\&P(!RR VR VR VRVRVRVRVRV/V Bp \*P-WR7#)a 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 fall in the range `[start, 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 ``freq`` is positive, the points satisfy `start <[=] x <[=] end`, and if ``freq`` is negative, the points satisfy `end <[=] x <[=] start`. (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, Timedelta, datetime.timedelta, or DateOffset, default 'D' Frequency strings can have multiples, e.g. '5h'. See :ref:`here ` 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 : Hashable, 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. unit : {'s', 'ms', 'us', 'ns', None}, default None Specify the desired resolution of the result. If not specified, this is inferred from the 'start', 'end', and 'freq' using the same inference as :class:`Timestamp` taking the highest resolution of the three that are provided. .. versionadded:: 2.0.0 **kwargs For compatibility. Has no effect on the result. Returns ------- DatetimeIndex A DatetimeIndex object of the generated dates. 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``, a maximum of three can be specified at once. Of the three parameters ``start``, ``end``, and ``periods``, at least two 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 :ref:`this link`. 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[us]', 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[us, 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[us]', 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[us]', 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[us]', freq=None) **Other Parameters** Changed the `freq` (frequency) to ``'ME'`` (month end frequency). >>> pd.date_range(start="1/1/2018", periods=5, freq="ME") DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31', '2018-04-30', '2018-05-31'], dtype='datetime64[us]', freq='ME') Multiples are allowed >>> pd.date_range(start="1/1/2018", periods=5, freq="3ME") DatetimeIndex(['2018-01-31', '2018-04-30', '2018-07-31', '2018-10-31', '2019-01-31'], dtype='datetime64[us]', freq='3ME') `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[us]', freq='3ME') 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[us, 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[us]', 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[us]', 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[us]', freq='D') **Specify a unit** >>> pd.date_range(start="2017-01-01", periods=10, freq="100YS", 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='100YS-JAN') Dz$Neither `start` nor `end` can be NaTzVOf the four parameters: start, end, periods, and freq, exactly three must be specifiedoffset nanosecondsr microsecondsr millisecondsrrrperiodsr3r2r\r]rrt)rrrO)comany_nonerrrrrrr6r rbasefreqstrhasattrr`r rlrr:r_generate_ranger7r9) rrrdr3r2r\rar]rkwargscresotdrs &&&&&&&&$, rD date_rangerns+~ | WS99  |scz?@@ |  e$EC.C!%**-0B3880LLzzxx  e$E::D _C.C88D<   &t,E$%%;;&99,,Dx((T[[-Dt{{+%bgg.677Ddz)42a7DT>15:tt|DT>15:t`. 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[us]', freq='B') Nz>freq must be specified for bdate_range; use date_range insteadCz!invalid custom frequency string: CBHz, did you mean cbh?zMon Tue Wed Thu Fri)holidaysweekmaskzZa custom frequency string is required when holidays or weekmask are passed, got frequency rrrdr3r2r\rar]rO) rr6rupper startswithrrrrn) rrrdr3r2r\rartrsr]rkmsgrs &&&&&&&&&&, rD bdate_rangerxs1\ |Nn$!8!8!=!=1$8 5=u$789 9 +88#8H!$'MD X 226 9 o                )$ +S/s * +s(C1CC& C!!C&c V^8dQhRRRR/#)rMtime_objzdt.timerNintrO)rPs"rDrQrQPs66g6#6rScVP^<,^<,^rs":)5/1<! D7+(    @B$999F B B 9    -t<      HO!*O! = 4O!d" H}7!}7}7@ Hkk\6u.s 2 F F