uj~ddlmZddlmZmZmZddlmZmZmZm Z m Z ddl Z ddl Z ddlmZddlmZddlmZmZddlmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*dd l+m,Z,m-Z-dd l.m/Z/dd l0m1Z1dd l2m3Z3dd l4m5Z5m6Z6ddl7m8Z8ddl9m:Z:ddl;mZ>m?Z?m@Z@mAZAmBZBmCZCddlDmEZEmFZFmGZGddlHmIZJddlKmLZLmMZMddlNmOcmPZQddlRmSZSddlTmUZUmVZVerFddlWmXZXmYZYddlZZ[ddl\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdddlemfZfddlHmgZgddlhmiZiededZjededZke d3d4dZle d3d5dZl d6 d7d Zld8d9d!Zme8d"Gd#d$eJjeJjZpd%dd%d%d&dd' d:d(Zq d;d)Zr d< d=d*Zsd8d>d+Ztd?d,Zud-Zv d@ dAd.Zw dBd/Zx dCd0Zy dDd1Zz dEd2Z{y)F) annotations)datetime timedeltatzinfo) TYPE_CHECKINGSelfTypeVarcastoverloadN)using_string_dtype)_global_config)libtslib) BaseOffsetNaTNaTTypeOutOfBoundsDatetimeOutOfBoundsTimedelta Timedelta Timestampastype_overflowsafefieldsget_supported_dtypeget_unit_from_dtypeints_to_pydatetimeis_date_array_normalizedis_supported_dtype is_unitlessnormalize_i8_timestamps timezones to_offsettz_convert_from_utc tzconversion) DAYS_FULL MONTHS_FULL)abbrev_to_npy_unit)RelativeDeltaOffset) HAS_PYARROW)Pandas4WarningPerformanceWarning) set_module)find_stack_level)validate_inclusive) DT64NS_DTYPE INT64_DTYPE is_bool_dtypeis_float_dtypeis_string_dtype pandas_dtype)DatetimeTZDtypeExtensionDtype PeriodDtype) datetimelike)generate_daily_offset_rangegenerate_regular_range)get_period_alias)DayTick)Callable Generator) ArrayLikeDateTimeErrorChoicesDtypeObjIntervalClosedType TimeAmbiguousTimeNonexistentTimeUnitnpt DataFrame PeriodArray)ArrowStringArray_TimestampNoneT1_TimestampNoneT2cyNtzunits g/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/pandas/core/arrays/datetimes.py tz_to_dtyperUusFIcyrOrPrQs rTrUrUysLOrVcR|tjd|dSt||S)z Return a datetime64[ns] dtype appropriate for the given timezone. Parameters ---------- tz : tzinfo or None unit : str, default "ns" Returns ------- np.dtype or DatetimeTZDtype M8[]rQ)npdtyper4rQs rTrUrU}s- zxx#dV1 &&"400rVc@fd}||_||_t|S)Nc<|j}|jvrFjdr|jdSt j ||j St j ||j }|j|dd}|S)N)startendfreqresofloat64) fill_valueconvert)_local_timestamps _bool_opsendswith_get_start_end_fieldrget_date_field_creso_maybe_mask_results)selfvaluesresultfields rTfz_field_accessor..fs'') DNN "~~./00T0BB((T[[I I&&vu4;;G))&T9)U rV)__name____doc__property)namerr docstringrss ` rT_field_accessorrys" AJAI A;rVz pandas.arraysceZdZUdZdZeejfZdZ de d<e ddZ e ddZ gdZd e d <gd Zd e d <gd Zd e d<eezezddgzZd e d<gdZd e d<dZde d<edZeef dfd ZedddddZeddej4dddd ddZe dd d! dd"Zdd#Zdd$Zdd%Zdd&Z e dd'Z!e dd(Z"e"jFd)Z"e dd*Z$e dd+Z%ddfd, Z&dd-Z'ddfd/ Z(d0dd1 dd2Z)dd3Z*dd4Z+dd5Z,dd6Z-e.j^ d dd7Z0dd8Z1dd9Z2dd:Z3ddd;Z4ddd<Z5dd=Z6ddd>Z7dd?Z8dd@Z9e:ddAZ;e ddBZddEZ?e@dFdGdHZAe@dIdJdKZBe@dLdMdNZCe@dOdPdQZDe@dRdSdTZEe@dUdVdWZFe@dXdYdZZGe@d[d d\ZHd]ZIe@d^d_eIZJe d`ZKe daZLe@dbdcddZMe deZNe@dfdgdhZOe@didjdkZPe dlZQddmZRdnZSe@dodoeSjdpqZUe@drdreSjdsqZVe@dtdtduZWe@dvdvdwZXe@dxdxdyZYe@dzdzd{ZZe@d|d|d}Z[dd~Z\d.dd dfdZ] d ddZ^xZ_S) DatetimeArraya Pandas ExtensionArray for tz-naive or tz-aware datetime data. .. warning:: DatetimeArray is currently experimental, and its API may change without warning. In particular, :attr:`DatetimeArray.dtype` is expected to change to always be an instance of an ``ExtensionDtype`` subclass. Parameters ---------- data : Series, Index, DatetimeArray, ndarray The datetime data. For DatetimeArray `values` (or a Series or Index boxing one), `dtype` and `freq` will be extracted from `values`. dtype : numpy.dtype or DatetimeTZDtype Note that the only NumPy dtypes allowed are 'datetime64[ns]', 'datetime64[us]', 'datetime64[ms]', 'datetime64[s]'. freq : str or Offset, optional The frequency. copy : bool, default False Whether to copy the underlying array of values. Attributes ---------- None Methods ------- None See Also -------- DatetimeIndex : Immutable Index for datetime-like data. Series : One-dimensional labeled array capable of holding datetime-like data. Timestamp : Pandas replacement for python datetime.datetime object. to_datetime : Convert argument to datetime. period_range : Return a fixed frequency PeriodIndex. Examples -------- >>> pd.arrays.DatetimeArray._from_sequence( ... pd.DatetimeIndex(["2023-01-01", "2023-01-02"], freq="D") ... ) ['2023-01-01 00:00:00', '2023-01-02 00:00:00'] Length: 2, dtype: datetime64[us] datetimearraycRtj|dxst|tSNM)r is_np_dtype isinstancer4)xs rTzDatetimeArray.s! 3A:a#ArVzCallable[[DtypeObj], bool]_is_recognized_dtypecBtjd|jS)Nr)r[ datetime64rSros rT_internal_fill_valuez"DatetimeArray._internal_fill_values}}UDII..rVctSrO)rrs rT _scalar_typezDatetimeArray._scalar_typesrV)is_month_start is_month_endis_quarter_startis_quarter_end is_year_start is_year_end is_leap_yearz list[str]ri) yearmonthdayhourminutesecond day_of_week day_of_yearquarter days_in_month microsecond nanosecond _field_ops)datetimetimetz _other_opsrSrR_datetimelike_ops) to_period tz_localize tz_convert normalizestrftimeroundfloorceil month_nameday_nameas_unit_datetimelike_methodsi)np.dtype[np.datetime64] | DatetimeTZDtype_dtypec*t|}t|jt|tjr|j|k7r t d|Stj |jd}||j k7r t d|S)Nz'Values resolution does not match dtype.r)_validate_dt64_dtyper\rr[ ValueError datetime_datarS)clsrpr\vunits rT_validate_dtypezDatetimeArray._validate_dtypes%U+V\\* eRXX &||u$ !JKK  $$V\\215E " !JKK rVc6t|tjsJ|jdk(sJt|tjr||jk(sJt |r&J|j t|jk(sJt|%||Sr~) rr[ndarraykindr\rrmrsuper _simple_new)rrpr\ __class__s rTrzDatetimeArray._simple_new+s &"**---zzS   eRXX &FLL( (("5) ))<<#6v||#DD DDw"6511rVNFr\copyc*|j|||SNr)_from_sequence_not_strict)rscalarsr\rs rT_from_sequencezDatetimeArray._from_sequence=s,,WE,MMrVraise)r\rrRdayfirst yearfirst ambiguousc :|du}|tjurd}ntj|}t |}t |||}d} |t j|} t j||d\}}t||||||| \} }t |||| |r tdtj| jd} td| } t|| } |j!| | } | | | j"k7r| j%| } | S) z\ A non-strict version of _from_sequence, called from DatetimeIndex.__new__. Nr{)cls_namerrRrrrout_unitz^Passed data is timezone-aware, incompatible with 'tz=None'. Use obj.tz_localize(None) instead.rrEr\)r no_defaultr maybe_get_tzr_validate_tz_from_dtypedtl dtype_to_unit!ensure_arraylike_for_datetimelike_sequence_to_dt64rr[rr\r rUrrSr)rdatar\rrRrrrexplicit_tz_nonerSsubarr data_unit data_dtyperqs rTrz'DatetimeArray._from_sequence_not_strictAs7$:  B''+B$U+ $UB0@ A  $$U+D:: $ d'   r+;< >.5  $$V\\215 Y/  Y/ z:   3 ^^D)F rVnsrSc tj|}| td|||fDr tdt j ||||dk7r tdt |}| t|}| t|}|tus|tur td| | dvr tdd} ||j| d }||j| d }t| \} } t|||\}}t|||}|t|||||}t|||||}|rt|ts>||j |j#d}||j |j#d}t|tt$frt'||||| } nz|j(d k\r|j*r t-||||| } nMt5||||| }t7j8|Dcgc]}|j:c}t6j<} | |j n |j }||t?j@|s%tC| }tEjF| ||||} ||j#|||}|}|j#|||}nitId|}t7jJd|j:|j:z |d|j:z} | jLdk7r| jOd} ||k(r | r| s| d d} n|t|j:ntQ| r| dnd}|t|j:ntQ| r| dnd}| r| s4| stQ| r | d|k(r| d d} | stQ| r | d|k(r| dd} | jSd| d}tU|| }|jW||S#t.t0t2f$rWt5||||| }t7j8|Dcgc]}|j:ncc}wc}t6j<} Y$wxYwcc}w)Nc3$K|]}|du ywrOrP).0rs rT z0DatetimeArray._generate_range..sIaT Isz1Must provide freq argument if no data is suppliedzVOf the four parameters: start, end, periods, and freq, exactly three must be specifiedz$Neither `start` nor `end` can be NaT)smsusrz+'unit' must be one of 's', 'ms', 'us', 'ns'rFround_okr)r_r`periodsoffsetrSrr nonexistentcresointrint64i8z datetime64[rZ),rvalidate_periodsanyrcomcount_not_noner!rrrr-_maybe_normalize_endpoints_infer_tz_from_endpoints_maybe_localize_pointrr<rRrr;r9n_supports_daily_offset_maskr8rr OverflowError_generate_ranger[array_valuerr is_utcr&r#tz_localize_to_utcr linspacer\astypelenviewrUr)rr_r`rrbrRrrr inclusiverSleft_inclusiveright_inclusivei8valuesxdrr endpoint_tzrstart_i8end_i8 dt64_valuesr\s rTrzDatetimeArray._generate_rangesf&&w/ )%r9kRE'T2y+NC   dD)$)=!--d3E?svv'9//$/C$s ,1%gtRVW1!A!AQ:sGT H&# 88s$;!QXX$;288L&+&7%((SVVK~+"5 ''+/t4E+>> "+$/#  H$!--b)[IE?//"iEC 5'*G AszzELL8'Q,, ~~%$??40 C<!#Ab>$% ''x=a[ ?#%%x=b\ "%#h-HQK8 > ##E* C<==tyy9 9==U=;@@ @rVc0t||jS)NrR)rrRrs rT_scalar_from_stringz!DatetimeArray._scalar_from_string/s477++rVc8|tury|j|yrO)r_assert_tzawareness_compat)roothers rTrz$DatetimeArray._check_compatible_with2s C<  ''.rVc|jd}tj||j|j}|S)Nr)rdrR)rr_from_value_and_resormrR)rorrtss rT _box_funczDatetimeArray._box_func:s0t   + +E  P rVc|jS)a% The dtype for the DatetimeArray. .. warning:: A future version of pandas will change dtype to never be a ``numpy.dtype``. Instead, :attr:`DatetimeArray.dtype` will always be an instance of an ``ExtensionDtype`` subclass. Returns ------- numpy.dtype or DatetimeTZDtype If the values are tz-naive, then ``np.dtype('datetime64[ns]')`` is returned. If the values are tz-aware, then the ``DatetimeTZDtype`` is returned. )rrs rTr\zDatetimeArray.dtype@s.{{rVc0t|jddS)a Return the timezone. This property returns the timezone information associated with the datetime data. If the data is timezone-naive (i.e. has no timezone information), it returns None. Returns ------- zoneinfo.ZoneInfo, datetime.tzinfo, pytz.tzinfo.BaseTZInfo, dateutil.tz.tz.tzfile, or None Returns None when the array is tz-naive. See Also -------- DatetimeIndex.tz_localize : Localize tz-naive DatetimeIndex to a given time zone, or remove timezone from a tz-aware DatetimeIndex. DatetimeIndex.tz_convert : Convert tz-aware DatetimeIndex from one time zone to another. Examples -------- For Series: >>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"]) >>> s = pd.to_datetime(s) >>> s 0 2020-01-01 10:00:00+00:00 1 2020-02-01 11:00:00+00:00 dtype: datetime64[us, UTC] >>> s.dt.tz datetime.timezone.utc For DatetimeIndex: >>> idx = pd.DatetimeIndex( ... ["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"] ... ) >>> idx.tz datetime.timezone.utc rRN)getattrr\rs rTrRzDatetimeArray.tzYsVtzz4..rVctd)NzNCannot directly set timezone. Use tz_localize() or tz_convert() as appropriate)AttributeErrorrs rTrRzDatetimeArray.tzs -  rVc|jS)z( Alias for tz attribute rrs rTrzDatetimeArray.tzinfos wwrVcZt|j|j|jS)zN Returns True if all of the dates are at midnight ("no time") rc)rasi8rRrmrs rT is_normalizedzDatetimeArray.is_normalizeds ( 477MMrVcN||jrt}t| ||Sr)rRobjectr __array__)ror\rrs rTr(zDatetimeArray.__array__s( =TWWEw u4 88rVcft|jd|jd|jS)Nr timestamp)rRboxrd)rrrRrm)rors rT_iter_convert_chunkz!DatetimeArray._iter_convert_chunks(! IIdO[t{{  rVTct|}||jk(r|r|jS|St|trt|t st |||S|j tdtj|j}t|j||}t|j||S|jjt!j"|drTt%|sIt'|r>t|j|d}t|j||jS|j!t!j"|dr td|j;t!j"|dr%||jk7rt%|r tdt|t(r|j+|j,St.j0j|||S) NrzCannot use .astype to convert from timezone-naive dtype to timezone-aware dtype. Use obj.tz_localize instead or series.dt.tz_localize insteadrrTzCannot use .astype to convert from timezone-aware dtype to timezone-naive dtype. Use obj.tz_localize(None) or obj.tz_convert('UTC').tz_localize(None) instead.z]Casting to unit-less dtype 'datetime64' is not supported. Pass e.g. 'datetime64[ns]' instead.ra)r3r\rrr5r4rrrR TypeErrorr[strr_ndarraytyperrrrrr6rrbrDatetimeLikeArrayMixin)ror\rnp_dtype res_valuesrs rTrzDatetimeArray.astypes U# DJJ yy{"K ~ .e_5w~e$~77 488EII.0tT Dz--j-FF GGOs+&"5)-T]]EMJ:))*J>uzz>2 2))00udCCrVr)na_rep date_formatc ||jrd}tj|j|j|||j S)Nz%Y-%m-%d)rRformatr6rd)_is_dates_onlyrformat_array_from_datetimer$rRrm)ror6r7kwargss rT_format_native_typesz"DatetimeArray._format_native_typessA  4#6#6$K// II$''+f4;;  rVct|dd}t|dd}t|tr|jj}|t ury|j| t dy| t dy)Nrr\z;Cannot compare tz-naive and tz-aware datetime-like objects.z:Cannot compare tz-naive and tz-aware datetime-like objects)rrr4r\rRrr/)rorother_tz other_dtypes rTrz(DatetimeArray._assert_tzawareness_compats5(D1eWd3 k? 3{{~~H C<  WW_#Q$ L rVcxt|trJ|jUt|trE|js9|j |j }|jr|j}|S|j|jd}n|} |j|j}|jjdk(r%|j|jj}t|j||j}|jr|j}|j|j|j}|S#t $rt"ddr$t%j&dt(t+|j-d|z}|j.}t1|drD|j2r8t5|j2j.}t7|t7|kDr|}t9|j| }t|j;||}Y|SwxYw) Nirmodeperformance_warningszCNon-vectorized DateOffset being applied to Series or DatetimeIndex. stacklevelOrr)rr<rRr'_use_relativedelta_add_timedeltalike_scalar _pd_timedeltarr_add_datetime_ndarrayr1r\rrr2rNotImplementedErrorconfigwarningswarnr*r,rrShasattrrrr&rUr)rorrqrpr5res_unit offset_unitr\s rT _add_offsetzDatetimeArray._add_offsetsfd+++ GG 6#67-- 33F4H4HIF))+M 77 %%d+FF 555fooFJ$$+'__V__-B-BC *$Z++Jj>N>N+OF))+ww"++DGG4 7# Hf~45 %&/1  S)F2JyyHvx(V]]' 6;; %k25G5QQ*Hh7E$Z..z.GF 7 HsAECH98H9c|jtj|jr |jSt |j|j|j S)z Convert to an i8 (unix-like nanosecond timestamp) representation while keeping the local timezone and not using UTC. This is used to calculate time-of-day information as if the timestamps were timezone-naive. rc)rRr rr$r"rmrs rTrhzDatetimeArray._local_timestampsTsC 77?i..tww799 "499dggDKKHHrVctj|}|j tdt ||j }|j |j|S)a Convert tz-aware Datetime Array/Index from one time zone to another. This method converts datetime values from their current timezone to a different timezone. The underlying UTC time remains the same, only the local time representation changes to reflect the target timezone. 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 Datetime 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. Series.dt.tz : A timezone that has a variable offset from UTC. Series.dt.tz_localize : Localize tz-naive Series datetimes to a given time zone, or remove timezone from tz-aware Series datetimes. 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') z?Cannot convert tz-naive timestamps, use tz_localize to localizerr)r rrRr/rUrSrr1)rorRr\s rTrzDatetimeArray.tz_convert`sZT # #B ' 77?Q  BTYY/ U;;rVcd}||vrt|ts td|j:|-t |j |j|j }nNtdtj|}tj|j ||||j }|jd|jd}t||j}|j|| S) ae 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 attach to the tz-naive timestamps; the wall time is preserved. Passing ``None`` detaches the time zone from a tz-aware Array/Index, returning a tz-naive result with the same wall 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. Requires that the timestamps are monotonically increasing. - 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='D') With ``tz=None`` we can remove the time zone information while preserving the wall time (no conversion 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='D') 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_backward'`. >>> 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.000000000+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] )rr shift_forwardshift_backwardzoThe nonexistent argument must be one of 'raise', 'NaT', 'shift_forward', 'shift_backward' or a timedelta objectrcz,Already tz-aware, use tz_convert to convert.rrYrZrr)rrrrRr"r$rmr/r rr#rrrSrUr)rorRrrnonexistent_options new_datesnew_dates_dt64r\s rTrzDatetimeArray.tz_localizesdR 1 1* ; %  77 z/ 477U  NOO''+B%77 #'kk I##dii[(:;BTYY/e<>> idx = pd.date_range("2018-02-27", periods=3) >>> idx.to_pydatetime() array([datetime.datetime(2018, 2, 27, 0, 0), datetime.datetime(2018, 2, 28, 0, 0), datetime.datetime(2018, 3, 1, 0, 0)], dtype=object) )rRrdrr$rRrmrs rT to_pydatetimezDatetimeArray.to_pydatetimejs4"$))dkkJJrVct|j}|j|j|j}|S)a Convert times to midnight. The time component of the date-time is converted to midnight i.e. 00:00:00. This is useful in cases, when the time does not matter. Length is unaltered. The timezones are unaffected. This method is available on Series with datetime values under the ``.dt`` accessor, and directly on Datetime Array/Index. Returns ------- DatetimeArray, DatetimeIndex or Series The same type as the original data. Series will have the same name and index. DatetimeIndex will have the same name. See Also -------- floor : Floor the datetimes to the specified freq. ceil : Ceil the datetimes to the specified freq. round : Round the datetimes to the specified freq. Examples -------- >>> idx = pd.date_range( ... start="2014-08-01 10:00", freq="h", periods=3, tz="Asia/Calcutta" ... ) >>> idx DatetimeIndex(['2014-08-01 10:00:00+05:30', '2014-08-01 11:00:00+05:30', '2014-08-01 12:00:00+05:30'], dtype='datetime64[us, Asia/Calcutta]', freq='h') >>> idx.normalize() DatetimeIndex(['2014-08-01 00:00:00+05:30', '2014-08-01 00:00:00+05:30', '2014-08-01 00:00:00+05:30'], dtype='datetime64[us, Asia/Calcutta]', freq=None) )_normalize_naiverRr)rodtas rTrzDatetimeArray.normalizes4N##% 77 //$''*C rVct|j|j|j}|j |j j }t|j||j S)z3Normalize times to midnight, ignoring the timezone.rcr) rr$rRrmrr1r\r2r)ro new_valuesr s rTr`zDatetimeArray._normalize_naivesT,TYYdkkR  oodmm&9&9: Dz%%k9J9J%KKrVcddlm}|j$tjdt t |*|j}| tdt|}||}|}|j|j||jS)a Cast to PeriodArray/PeriodIndex at a particular frequency. Converts DatetimeArray/Index to PeriodArray/PeriodIndex. Parameters ---------- freq : str, optional One of pandas' :ref:`period aliases `. 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]') rrIzNConverting to PeriodArray/Index representation will drop timezone information.rEz8You must pass a freq argument as current index has none.r) pandas.core.arraysrJrRrNrO UserWarningr,_inferred_freq_strrr:_from_datetime64r1)rorbrJress rTrzDatetimeArray.to_periodsf 3 77  MM2+-   <**D| N#4(C{D+{++DMM4DGGLLrVc8| trtr|jS|j}t j |d||j }|j|d}tr'ddlm }m }|||tjS|S) u Return the month names with specified locale. This method returns the full name of the month (e.g., "January", "February") for each datetime value in the Series/Index. The names can be localized to different languages using the locale parameter. Parameters ---------- locale : str, optional Locale determining the language in which to return the month name. Default is English locale (``'en_US.utf8'``). Use the command ``locale -a`` on your terminal on Unix systems to find your locale language code. Returns ------- Series or Index Series or Index of month names. See Also -------- DatetimeIndex.day_name : Return the day names with specified locale. Examples -------- >>> s = pd.Series(pd.date_range(start="2018-01", freq="ME", periods=3)) >>> s 0 2018-01-31 1 2018-02-28 2 2018-03-31 dtype: datetime64[us] >>> s.dt.month_name() 0 January 1 February 2 March dtype: str >>> idx = pd.date_range(start="2018-01", freq="ME", periods=3) >>> idx DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31'], dtype='datetime64[us]', freq='ME') >>> idx.month_name() Index(['January', 'February', 'March'], dtype='str') Using the ``locale`` parameter you can set a different locale language, for example: ``idx.month_name(locale='pt_BR.utf8')`` will return month names in Brazilian Portuguese language. >>> idx = pd.date_range(start="2018-01", freq="ME", periods=3) >>> idx DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31'], dtype='datetime64[us]', freq='ME') >>> idx.month_name(locale="pt_BR.utf8") # doctest: +SKIP Index(['Janeiro', 'Fevereiro', 'Março'], dtype='str') Nrlocalerdrfr StringDtyperna_valuer) r(r _month_name_arrowrhrget_date_name_fieldrmrnpandasrorr[nanrorlrprqropd_arrays rTrzDatetimeArray.month_name sr >k.@.B))+ +'')++ Ldkk ))&T)B    F+rvv*FG G rVcddl}ddlm}|jt|j }|j }|j||j|}|j|SNr)r2) pyarrowpyarrow.computecomputerr% large_string_to_local_pa_timestamptaker_wrap_pa_str_result)ropapc pa_monthspa_tsrqs rTrrzDatetimeArray._month_name_arrowTsZ$BHH[r/@A ++-BHHUO4''//rVc8| trtr|jS|j}t j |d||j }|j|d}tr'ddlm }m }|||tjS|S) u Return the day names with specified locale. This method returns the full name of the day of the week (e.g., "Monday", "Tuesday") for each datetime value in the Series/Index. The names can be localized to different languages using the locale parameter. Parameters ---------- locale : str, optional Locale determining the language in which to return the day name. Default is English locale (``'en_US.utf8'``). Use the command ``locale -a`` on your terminal on Unix systems to find your locale language code. Returns ------- Series or Index Series or Index of day names. See Also -------- DatetimeIndex.month_name : Return the month names with specified locale. Examples -------- >>> s = pd.Series(pd.date_range(start="2018-01-01", freq="D", periods=3)) >>> s 0 2018-01-01 1 2018-01-02 2 2018-01-03 dtype: datetime64[us] >>> s.dt.day_name() 0 Monday 1 Tuesday 2 Wednesday dtype: str >>> idx = pd.date_range(start="2018-01-01", freq="D", periods=3) >>> idx DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03'], dtype='datetime64[us]', freq='D') >>> idx.day_name() Index(['Monday', 'Tuesday', 'Wednesday'], dtype='str') Using the ``locale`` parameter you can set a different locale language, for example: ``idx.day_name(locale='pt_BR.utf8')`` will return day names in Brazilian Portuguese language. >>> idx = pd.date_range(start="2018-01-01", freq="D", periods=3) >>> idx DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03'], dtype='datetime64[us]', freq='D') >>> idx.day_name(locale="pt_BR.utf8") # doctest: +SKIP Index(['Segunda', 'Terça', 'Quarta'], dtype='str') Nrrkrmrrnrpr) r(r _day_name_arrowrhrrsrmrnrtrorr[rurvs rTrzDatetimeArray.day_name]sr >k.@.B'') )'')++ JvDKK ))&T)B    F+rvv*FG G rVcddl}ddlm}|jt|j }|j }|j||j|}|j|Sry) rzr{r|rr$r}r~rrr)rorrpa_daysrrqs rTrzDatetimeArray._day_name_arrows[$"((9?2??+<=++-".."78''//rVcddl}|j}|j}|j|||j|j S)z:Convert to a pyarrow TimestampArray with local timestamps.rN)maskr2)rzrh_isnanrr*rS)rorrprs rTr~z$DatetimeArray._to_local_pa_timestamps@''){{rxxT  TYY0GHHrVcpddlm}|tj}|j }|||S)zCWrap a pyarrow StringArray in an ArrowStringArray with StringDtype.r)rorpr)pandas.core.arrays.string_ror[ruconstruct_array_type)pa_arrror\rs rTrz!DatetimeArray._wrap_pa_str_results0 ;RVV,((*6''rVcR|j}t|d|jS)a[ Returns numpy array of :class:`datetime.time` objects. The time part of the Timestamps. See Also -------- DatetimeIndex.timetz : Returns numpy array of :class:`datetime.time` objects with timezones. The time part of the Timestamps. DatetimeIndex.date : Returns numpy array of python :class:`datetime.date` objects. Namely, the date part of Timestamps without time and timezone information. Examples -------- For Series: >>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"]) >>> s = pd.to_datetime(s) >>> s 0 2020-01-01 10:00:00+00:00 1 2020-02-01 11:00:00+00:00 dtype: datetime64[us, UTC] >>> s.dt.time 0 10:00:00 1 11:00:00 dtype: object For DatetimeIndex: >>> idx = pd.DatetimeIndex( ... ["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"] ... ) >>> idx.time array([datetime.time(10, 0), datetime.time(11, 0)], dtype=object) rr+rdrhrrmro timestampss rTrzDatetimeArray.times&R++- !*&t{{KKrVc\t|j|jd|jS)a Returns numpy array of :class:`datetime.time` objects with timezones. The time part of the Timestamps. See Also -------- DatetimeIndex.time : Returns numpy array of :class:`datetime.time` objects. The time part of the Timestamps. DatetimeIndex.tz : Return the timezone. Examples -------- For Series: >>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"]) >>> s = pd.to_datetime(s) >>> s 0 2020-01-01 10:00:00+00:00 1 2020-02-01 11:00:00+00:00 dtype: datetime64[us, UTC] >>> s.dt.timetz 0 10:00:00+00:00 1 11:00:00+00:00 dtype: object For DatetimeIndex: >>> idx = pd.DatetimeIndex( ... ["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"] ... ) >>> idx.timetz array([datetime.time(10, 0, tzinfo=datetime.timezone.utc), datetime.time(11, 0, tzinfo=datetime.timezone.utc)], dtype=object) rrr]rs rTrzDatetimeArray.timetzs"J"$))TWW&t{{SSrVcR|j}t|d|jS)a Returns numpy array of python :class:`datetime.date` objects. Namely, the date part of Timestamps without time and timezone information. See Also -------- DatetimeIndex.time : Returns numpy array of :class:`datetime.time` objects. The time part of the Timestamps. DatetimeIndex.year : The year of the datetime. DatetimeIndex.month : The month as January=1, December=12. DatetimeIndex.day : The day of the datetime. Examples -------- For Series: >>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"]) >>> s = pd.to_datetime(s) >>> s 0 2020-01-01 10:00:00+00:00 1 2020-02-01 11:00:00+00:00 dtype: datetime64[us, UTC] >>> s.dt.date 0 2020-01-01 1 2020-02-01 dtype: object For DatetimeIndex: >>> idx = pd.DatetimeIndex( ... ["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"] ... ) >>> idx.date array([datetime.date(2020, 1, 1), datetime.date(2020, 2, 1)], dtype=object) rrrrs rTrzDatetimeArray.dates&T++- !*&t{{KKrVcddlm}|j}tj||j }||gdj dddd}|jrd|j|j<|S) a Calculate year, week, and day according to the ISO 8601 standard. The ISO 8601 standard defines the first week of the year as the week containing the first Thursday. This method returns a DataFrame with columns for the ISO year, ISO week number, and ISO day of week. 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 rrGrc)rweekr)columnsInt32UInt32N) rtrHrhrbuild_isocalendar_sarrayrmr_hasnailocr)rorHrpsarrayiso_calendar_dfs rT isocalendarzDatetimeArray.isocalendarDsqH %'')00dkkJ#F4KLSShx @  ;;04O  -rVrYa The year of the datetime. This attribute returns the year component of each datetime value in the Series/Index. The returned values are integers representing the calendar year. See Also -------- DatetimeIndex.month: The month as January=1, December=12. DatetimeIndex.day: The day of the datetime. Examples -------- >>> datetime_series = pd.Series( ... pd.date_range("2000-01-01", periods=3, freq="YE") ... ) >>> datetime_series 0 2000-12-31 1 2001-12-31 2 2002-12-31 dtype: datetime64[us] >>> datetime_series.dt.year 0 2000 1 2001 2 2002 dtype: int32 rra The month as January=1, December=12. This attribute returns the month component of each datetime value in the Series/Index. Months are numbered from 1 (January) through 12 (December). See Also -------- DatetimeIndex.year: The year of the datetime. DatetimeIndex.day: The day of the datetime. Examples -------- >>> datetime_series = pd.Series( ... pd.date_range("2000-01-01", periods=3, freq="ME") ... ) >>> datetime_series 0 2000-01-31 1 2000-02-29 2 2000-03-31 dtype: datetime64[us] >>> datetime_series.dt.month 0 1 1 2 2 3 dtype: int32 rDa) The day of the datetime. This attribute returns the day of the month component of each datetime value in the Series/Index. Values range from 1 to 31, depending on the month. See Also -------- DatetimeIndex.year: The year of the datetime. DatetimeIndex.month: The month as January=1, December=12. DatetimeIndex.hour: The hours of the datetime. Examples -------- >>> datetime_series = pd.Series( ... pd.date_range("2000-01-01", periods=3, freq="D") ... ) >>> datetime_series 0 2000-01-01 1 2000-01-02 2 2000-01-03 dtype: datetime64[us] >>> datetime_series.dt.day 0 1 1 2 2 3 dtype: int32 rhaR The hours of the datetime. This attribute returns the hour component of each datetime value in the Series/Index. Values range from 0 to 23, representing the hour of the day in 24-hour format. See Also -------- DatetimeIndex.day: The day of the datetime. DatetimeIndex.minute: The minutes of the datetime. DatetimeIndex.second: The seconds of the datetime. Examples -------- >>> datetime_series = pd.Series( ... pd.date_range("2000-01-01", periods=3, freq="h") ... ) >>> datetime_series 0 2000-01-01 00:00:00 1 2000-01-01 01:00:00 2 2000-01-01 02:00:00 dtype: datetime64[us] >>> datetime_series.dt.hour 0 0 1 1 2 2 dtype: int32 rma The minutes of the datetime. This attribute returns the minute component of each datetime value in the Series/Index. Values range from 0 to 59. See Also -------- DatetimeIndex.hour: The hours of the datetime. DatetimeIndex.second: The seconds of the datetime. Examples -------- >>> datetime_series = pd.Series( ... pd.date_range("2000-01-01", periods=3, freq="min") ... ) >>> datetime_series 0 2000-01-01 00:00:00 1 2000-01-01 00:01:00 2 2000-01-01 00:02:00 dtype: datetime64[us] >>> datetime_series.dt.minute 0 0 1 1 2 2 dtype: int32 rra5 The seconds of the datetime. This attribute returns the second component of each datetime value in the Series/Index. Values range from 0 to 59. See Also -------- DatetimeIndex.minute: The minutes of the datetime. DatetimeIndex.microsecond: The microseconds of the datetime. DatetimeIndex.nanosecond: The nanoseconds of the datetime. Examples -------- >>> datetime_series = pd.Series( ... pd.date_range("2000-01-01", periods=3, freq="s") ... ) >>> datetime_series 0 2000-01-01 00:00:00 1 2000-01-01 00:00:01 2 2000-01-01 00:00:02 dtype: datetime64[us] >>> datetime_series.dt.second 0 0 1 1 2 2 dtype: int32 rraY The microseconds of the datetime. This attribute returns the microsecond component of each datetime value in the Series/Index. Values range from 0 to 999999 (one microsecond is one millionth of a second). See Also -------- DatetimeIndex.second: The seconds of the datetime. DatetimeIndex.nanosecond: The nanoseconds of the datetime. Examples -------- >>> datetime_series = pd.Series( ... pd.date_range("2000-01-01", periods=3, freq="us") ... ) >>> datetime_series 0 2000-01-01 00:00:00.000000 1 2000-01-01 00:00:00.000001 2 2000-01-01 00:00:00.000002 dtype: datetime64[us] >>> datetime_series.dt.microsecond 0 0 1 1 2 2 dtype: int32 ra] The nanoseconds of the datetime. This attribute returns the nanosecond component of each datetime value in the Series/Index. Values range from 0 to 999 (one nanosecond is one billionth of a second). See Also -------- DatetimeIndex.second: The seconds of the datetime. DatetimeIndex.microsecond: The microseconds of the datetime. Examples -------- >>> datetime_series = pd.Series( ... pd.date_range("2000-01-01", periods=3, freq="ns") ... ) >>> datetime_series 0 2000-01-01 00:00:00.000000000 1 2000-01-01 00:00:00.000000001 2 2000-01-01 00:00:00.000000002 dtype: datetime64[ns] >>> datetime_series.dt.nanosecond 0 0 1 1 2 2 dtype: int32 ac The day of the week with Monday=0, Sunday=6. Return the day of the week. It is assumed the week starts on Monday, which is denoted by 0 and ends on Sunday which is denoted by 6. This method is available on both Series with datetime values (using the `dt` accessor) or DatetimeIndex. Returns ------- Series or Index Containing integers indicating the day number. See Also -------- Series.dt.weekday : Alias. Series.dt.day_name : Returns the name of the day of the week. Examples -------- >>> s = pd.date_range('2016-12-31', '2017-01-08', freq='D').to_series() >>> s.dt.day_of_week 2016-12-31 5 2017-01-01 6 2017-01-02 0 2017-01-03 1 2017-01-04 2 2017-01-05 3 2017-01-06 4 2017-01-07 5 2017-01-08 6 Freq: D, dtype: int32 rdowcbtjdtt|jS) The day of the week with Monday=0, Sunday=6. .. deprecated:: 3.1.0 Use :attr:`DatetimeArray.day_of_week` instead. zDatetimeArray.weekday is deprecated and will be removed in a future version. Use DatetimeArray.day_of_week or Series.dt.day_of_week instead.rErNrOr)r,rrs rTweekdayzDatetimeArray.weekdays.   - ')  rVcbtjdtt|jS)rzuDatetimeArray.dayofweek is deprecated and will be removed in a future version. Use DatetimeArray.day_of_week instead.rErrs rT dayofweekzDatetimeArray.dayofweek-   E ')  rV dayofyeardoya The ordinal day of the year. This attribute returns the day of the year for each datetime value in the Series/Index. Values range from 1 to 365 (or 366 for leap years). See Also -------- DatetimeIndex.dayofweek : The day of the week with Monday=0, Sunday=6. DatetimeIndex.day : The day of the datetime. Examples -------- For Series: >>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"]) >>> s = pd.to_datetime(s) >>> s 0 2020-01-01 10:00:00+00:00 1 2020-02-01 11:00:00+00:00 dtype: datetime64[us, UTC] >>> s.dt.day_of_year 0 1 1 32 dtype: int32 For DatetimeIndex: >>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00", ... "2/1/2020 11:00:00+00:00"]) >>> idx.day_of_year Index([1, 32], dtype='int32') cbtjdtt|jS)z The ordinal day of the year. .. deprecated:: 3.1.0 Use :attr:`DatetimeArray.day_of_year` instead. zuDatetimeArray.dayofyear is deprecated and will be removed in a future version. Use DatetimeArray.day_of_year instead.rE)rNrOr)r,rrs rTrzDatetimeArray.dayofyearrrVrqa The quarter of the date. This attribute returns the quarter of the year for each datetime value in the Series/Index. Quarter 1 includes January through March, quarter 2 includes April through June, quarter 3 includes July through September, and quarter 4 includes October through December. See Also -------- DatetimeIndex.snap : Snap time stamps to nearest occurring frequency. DatetimeIndex.time : Returns numpy array of datetime.time objects. The time part of the Timestamps. Examples -------- For Series: >>> s = pd.Series(["1/1/2020 10:00:00+00:00", "4/1/2020 11:00:00+00:00"]) >>> s = pd.to_datetime(s) >>> s 0 2020-01-01 10:00:00+00:00 1 2020-04-01 11:00:00+00:00 dtype: datetime64[us, UTC] >>> s.dt.quarter 0 1 1 2 dtype: int32 For DatetimeIndex: >>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00", ... "2/1/2020 11:00:00+00:00"]) >>> idx.quarter Index([1, 1], dtype='int32') rdima The number of days in the month. This attribute returns the total number of days in the month for each datetime value in the Series/Index. The value depends on the month and whether the year is a leap year (e.g., February has 29 days in a leap year). See Also -------- Series.dt.day : Return the day of the month. Series.dt.is_month_end : Return a boolean indicating if the date is the last day of the month. Series.dt.is_month_start : Return a boolean indicating if the date is the first day of the month. Series.dt.month : Return the month as January=1 through December=12. Examples -------- >>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"]) >>> s = pd.to_datetime(s) >>> s 0 2020-01-01 10:00:00+00:00 1 2020-02-01 11:00:00+00:00 dtype: datetime64[us, UTC] >>> s.dt.days_in_month 0 31 1 29 dtype: int32 cbtjdtt|jS)z The number of days in the month. .. deprecated:: 3.1.0 Use :attr:`DatetimeArray.days_in_month` instead. zyDatetimeArray.daysinmonth is deprecated and will be removed in a future version. Use DatetimeArray.days_in_month instead.rE)rNrOr)r,rrs rT daysinmonthzDatetimeArray.daysinmonth9s-   G ')  !!!rVcd}|r.|j}|jd|jd|}| |j}nd}|j}t j |||||j S)z Return boolean array for is_month_start, is_quarter_end, etc. Parameters ---------- field : str freq : BaseOffset or None startingMonthrNrc)kwdsget rule_coderhrget_start_end_fieldrm)rorrrbmonth_kwr freq_namerps rTrkz"DatetimeArray._get_start_end_fieldIst 99Dxx'81LMH  II''))) E9hT[[  rVa Indicates whether the date is the {first_or_last} day of the month. This boolean attribute evaluates to True if the date falls on the {first_or_last} day of a calendar month, and False otherwise. Returns ------- Series or array For Series, returns a Series with boolean values. For DatetimeIndex, returns a boolean array. See Also -------- is_month_start : Return a boolean indicating whether the date is the first day of the month. is_month_end : Return a boolean indicating whether the date is the last day of the month. Examples -------- This method is available on Series with datetime values under the ``.dt`` accessor, and directly on DatetimeIndex. >>> s = pd.Series(pd.date_range("2018-02-27", periods=3)) >>> s 0 2018-02-27 1 2018-02-28 2 2018-03-01 dtype: datetime64[us] >>> s.dt.is_month_start 0 False 1 False 2 True dtype: bool >>> s.dt.is_month_end 0 False 1 True 2 False dtype: bool >>> idx = pd.date_range("2018-02-27", periods=3) >>> idx.is_month_start array([False, False, True]) >>> idx.is_month_end array([False, True, False]) rfirst) first_or_lastrlastraI Indicator for whether the date is the first day of a quarter. This boolean attribute evaluates to True if the date falls on the first day of a calendar quarter (January 1, April 1, July 1, or October 1), and False otherwise. Returns ------- is_quarter_start : Series or DatetimeIndex The same type as the original data with boolean values. Series will have the same name and index. DatetimeIndex will have the same name. See Also -------- quarter : Return the quarter of the date. is_quarter_end : Similar property for indicating the quarter end. Examples -------- This method is available on Series with datetime values under the ``.dt`` accessor, and directly on DatetimeIndex. >>> df = pd.DataFrame({'dates': pd.date_range("2017-03-30", ... periods=4)}) >>> df.assign(quarter=df.dates.dt.quarter, ... is_quarter_start=df.dates.dt.is_quarter_start) dates quarter is_quarter_start 0 2017-03-30 1 False 1 2017-03-31 1 False 2 2017-04-01 2 True 3 2017-04-02 2 False >>> idx = pd.date_range('2017-03-30', periods=4) >>> idx DatetimeIndex(['2017-03-30', '2017-03-31', '2017-04-01', '2017-04-02'], dtype='datetime64[us]', freq='D') >>> idx.is_quarter_start array([False, False, True, False]) raG Indicator for whether the date is the last day of a quarter. This boolean attribute evaluates to True if the date falls on the last day of a calendar quarter (March 31, June 30, September 30, or December 31), and False otherwise. Returns ------- is_quarter_end : Series or DatetimeIndex The same type as the original data with boolean values. Series will have the same name and index. DatetimeIndex will have the same name. See Also -------- quarter : Return the quarter of the date. is_quarter_start : Similar property indicating the quarter start. Examples -------- This method is available on Series with datetime values under the ``.dt`` accessor, and directly on DatetimeIndex. >>> df = pd.DataFrame({'dates': pd.date_range("2017-03-30", ... periods=4)}) >>> df.assign(quarter=df.dates.dt.quarter, ... is_quarter_end=df.dates.dt.is_quarter_end) dates quarter is_quarter_end 0 2017-03-30 1 False 1 2017-03-31 1 True 2 2017-04-01 2 False 3 2017-04-02 2 False >>> idx = pd.date_range('2017-03-30', periods=4) >>> idx DatetimeIndex(['2017-03-30', '2017-03-31', '2017-04-01', '2017-04-02'], dtype='datetime64[us]', freq='D') >>> idx.is_quarter_end array([False, True, False, False]) ra  Indicate whether the date is the first day of a year. This boolean attribute evaluates to True if the date is January 1st, and False otherwise. Returns ------- Series or DatetimeIndex The same type as the original data with boolean values. Series will have the same name and index. DatetimeIndex will have the same name. See Also -------- is_year_end : Similar property indicating the last day of the year. Examples -------- This method is available on Series with datetime values under the ``.dt`` accessor, and directly on DatetimeIndex. >>> dates = pd.Series(pd.date_range("2017-12-30", periods=3)) >>> dates 0 2017-12-30 1 2017-12-31 2 2018-01-01 dtype: datetime64[us] >>> dates.dt.is_year_start 0 False 1 False 2 True dtype: bool >>> idx = pd.date_range("2017-12-30", periods=3) >>> idx DatetimeIndex(['2017-12-30', '2017-12-31', '2018-01-01'], dtype='datetime64[us]', freq='D') >>> idx.is_year_start array([False, False, True]) This method, when applied to Series with datetime values under the ``.dt`` accessor, will lose information about Business offsets. >>> dates = pd.Series(pd.date_range("2020-10-30", periods=4, freq="BYS")) >>> dates 0 2021-01-01 1 2022-01-03 2 2023-01-02 3 2024-01-01 dtype: datetime64[us] >>> dates.dt.is_year_start 0 True 1 False 2 False 3 True dtype: bool >>> idx = pd.date_range("2020-10-30", periods=4, freq="BYS") >>> idx DatetimeIndex(['2021-01-01', '2022-01-03', '2023-01-02', '2024-01-01'], dtype='datetime64[us]', freq='BYS-JAN') >>> idx.is_year_start array([ True, True, True, True]) ra Indicate whether the date is the last day of the year. This boolean attribute evaluates to True if the date is December 31st, and False otherwise. Returns ------- Series or DatetimeIndex The same type as the original data with boolean values. Series will have the same name and index. DatetimeIndex will have the same name. See Also -------- is_year_start : Similar property indicating the start of the year. Examples -------- This method is available on Series with datetime values under the ``.dt`` accessor, and directly on DatetimeIndex. >>> dates = pd.Series(pd.date_range("2017-12-30", periods=3)) >>> dates 0 2017-12-30 1 2017-12-31 2 2018-01-01 dtype: datetime64[us] >>> dates.dt.is_year_end 0 False 1 True 2 False dtype: bool >>> idx = pd.date_range("2017-12-30", periods=3) >>> idx DatetimeIndex(['2017-12-30', '2017-12-31', '2018-01-01'], dtype='datetime64[us]', freq='D') >>> idx.is_year_end array([False, True, False]) ra Boolean indicator if the date belongs to a leap year. A leap year is a year, which has 366 days (instead of 365) including 29th of February as an intercalary day. Leap years are years which are multiples of four with the exception of years divisible by 100 but not by 400. Returns ------- Series or ndarray Booleans indicating if dates belong to a leap year. See Also -------- DatetimeIndex.is_year_end : Indicate whether the date is the last day of the year. DatetimeIndex.is_year_start : Indicate whether the date is the first day of a year. Examples -------- This method is available on Series with datetime values under the ``.dt`` accessor, and directly on DatetimeIndex. >>> idx = pd.date_range("2012-01-01", "2015-01-01", freq="YE") >>> idx DatetimeIndex(['2012-12-31', '2013-12-31', '2014-12-31'], dtype='datetime64[us]', freq='YE-DEC') >>> idx.is_leap_year array([ True, False, False]) >>> dates_series = pd.Series(idx) >>> dates_series 0 2012-12-31 1 2013-12-31 2 2014-12-31 dtype: datetime64[us] >>> dates_series.dt.is_leap_year 0 True 1 False 2 False dtype: bool c|j.|jdjdjSt j |j }t j |j}t j |j}|dk}||xxdzcc<||xxdz cc<|t jd|zdz dz zd |zzt j|d z zt j|d z z t j|d z zd z|j|jdz z|jdz z|jdz dz z|jdz dz zdz zS)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') NUTCrrriimdigC:A<ii@Biʚ;)rRrrto_julian_dater[asarrayrrrtruncrrrrrr)rorrrtestarrs rTrzDatetimeArray.to_julian_date s|. 77 ??5)55d;JJL Lzz$))$ 4::&jj"!) W   g" hhe c)Q./ 0Dj hhtax  !hhtcz"  # hhtcz"  #    ++"#++$%""T)E12//D(50 1   rVskipnakeepdimsc t||f||d|}|rSt|tjr9|dk(rddlm}|j|S|j||jS|S)NrstdrTimedeltaArrayr) r_reducerr[rrerrr\)rorwrrr<rqrrs rTrzDatetimeArray._reduce siRfxR6R  62::6u}=%44V<<**6*DD rVcddlm}|jjjj dd}t j|}|j|jj||} | j|||||S)aC Return sample standard deviation over requested axis. Normalized by `N-1` by default. This can be changed using ``ddof``. Parameters ---------- axis : int, optional Axis for the function to be applied on. For :class:`pandas.Series` this parameter is unused and defaults to ``None``. dtype : dtype, optional, default None Type to use in computing the standard deviation. For arrays of integer type the default is float64, for arrays of float types it is the same as the array type. out : ndarray, optional, default None Alternative output array in which to place the result. It must have the same shape as the expected output but the type (of the calculated values) will be cast if necessary. ddof : int, default 1 Degrees of Freedom. The divisor used in calculations is `N - ddof`, where `N` represents the number of elements. keepdims : bool, optional If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the input array. If the default value is passed, then keepdims will not be passed through to the std method of sub-classes of ndarray, however any non-default value will be. If the sub-class method does not implement keepdims any exceptions will be raised. skipna : bool, default True Exclude NA/null values. If an entire row/column is ``NA``, the result will be ``NA``. Returns ------- Timedelta Standard deviation over requested axis. See Also -------- numpy.ndarray.std : Returns the standard deviation of the array elements along given axis. Series.std : Return sample standard deviation over requested axis. Examples -------- For :class:`pandas.DatetimeIndex`: >>> idx = pd.date_range("2001-01-01 00:00", periods=3) >>> idx DatetimeIndex(['2001-01-01', '2001-01-02', '2001-01-03'], dtype='datetime64[us]', freq='D') >>> idx.std() Timedelta('1 days 00:00:00') rrr timedelta64r)axisoutddofrr) rerr1r\rwreplacer[rrr) rorr\rrrrr dtype_strtdas rTrzDatetimeArray.std sxF 6MM'',,44\=Q #((););E)B%(PwwDcxPVwWWrV)return np.datetime64)rztype[Timestamp])rpznpt.NDArray[np.datetime64]r\rrr)rboolrr) rrrrrrrrCrr)NFrrboth)r int | NonerrrrCrrDrrBrSrErr)rTimestamp | NaTType)rNone)rrrr)rr)r tzinfo | None)rr)NN)r np.ndarray)rrrr)T)rr)r6z str | floatrnpt.NDArray[np.object_])rrrr)rznpt.NDArray[np.int64])rr)rr)rrCrrDrr)rrrO)rrJ)rrK)rpa.Array)rrrrK)rrH)rrr0rbzBaseOffset | Nonerr)rznpt.NDArray[np.float64])rwr0rrrr)NNNrFT)rrrrrrrr)`rt __module__ __qualname__ru_typrr[r_recognized_scalarsr__annotations__rvrrrirrrr__array_priority__ classmethodrr.rrrrrrrrrrr\rRsetterrr%r(r,rr=rrSrhrr ravel_compatrr^rr`rrrrrrr~ staticmethodrrrrrryrrrrrrrr_dayofweek_docrrrrrrrrrk _is_month_docr9rrrrrrrrrr __classcell__)rs@rTr{r{sO2h D#R]]384//Iy J 7J 6#- #9J#F&RV#WyW (9 $ 65  >#*?  ???!? ??B #*'.(.]9]9 ]9]9!]9%]9&]9]9 ]9]9DA,/  **/*/XYY   NN9 ADN(-$  $    08z IT  F@"  K@!  J@ NB"-GK   "    "  $KL     # 'GP$   MD " " 0.M^%*M,@,@w,@,WN# (<(<6(<(RL') -\%) -N\$D HMR"* .K^#+ /Lb2 p,0%  $( ;?  KX  KX  KXKX KXrVr{Frrc *t|||\}}t|dd}t}|tjd|d}|t k(s t |rtd|}d}tj|dd k(r |jtj}n|G|d k(rBtj|t } tj| |||t| } | |fSt!|||| \} } d}|r| r| } | |fS| r| }| } | |fSt#| |||\} } | |fS|j}t%|t&r/td|}t)||j*}|j,} ntj.|dr;t%|t0r |j,}td|}t#||||\} }nS|jt2k7r#|jtjd}d}td|}|j5|} |r| j7} t%| tj8sJt;| | jj<dk(sJ| jdk7sJt?| jsJ| |fS)aQ Parameters ---------- data : np.ndarray or ExtensionArray dtl.ensure_arraylike_for_datetimelike has already been called. copy : bool, default False tz : tzinfo or None, default None dayfirst : bool, default False yearfirst : bool, default False ambiguous : str, bool, or arraylike, default 'raise' See pandas._libs.tslibs.tzconversion.tz_localize_to_utc. out_unit : str or None, default None Desired output resolution. Returns ------- result : numpy.ndarray The sequence converted to a numpy array with dtype ``datetime64[unit]``. Where `unit` is "ns" unless specified otherwise by `out_unit`. tz : tzinfo or None Either the user-provided tzinfo or one inferred from the data. Raises ------ TypeError : PeriodDType data is passed rr\NrYrZrF)rintegerrr)rRrrr)rrr)rRrrr{rr.M8) maybe_convert_dtyperr.r[r\r'r2r r infer_dtyperrrrarray_to_datetime_with_tzr&objects_to_datetime64_construct_from_dt64_naiverr4_maybe_infer_tzrRr1rr{r/rrrr2rr)rrrRrrrrr out_dtypeobj_datarq converted inferred_tz_s rTrr3 sL%T4B7JD$w-JIHHs8*A./ Vz:L$' ??4 .) ;;;rxx(D ^ W 4zz$f5H44!#(2 F2: %:!#! & "I{ Dk#2:  " 2: 7"49 2: ZZ *o.OT* R ) S ) dM *==DL$'1 Rdi  :: $;;rxxe;4DDL$'9%  fbjj )74<7 ) <<   ## # <<4   fll ++ + 2:rVcX|j}t|st|}t||d}d}|jjdk(r8|j |jj d}|j}d}||j}|jdkDr|j}t|}tj|jd|||}|j|}|j|}|j|k(sJ|j|}||fS)zP Convert datetime64 data to a supported dtype, localizing if necessary. Fr>?1%988  5$ % *E2E#ZZI$<$cooeS9~i&:&:2s&C A I/    sB'' B32B3c tj||}tj|}tj|}|%|#tj ||s td|S||}|S#t$r}td|d}~wwxYw)a If a timezone is not explicitly given via `tz`, see if one can be inferred from the `start` and `end` endpoints. If more than one of these inputs provides a timezone, require that they all agree. Parameters ---------- start : Timestamp end : Timestamp tz : tzinfo or None Returns ------- tz : tzinfo or None Raises ------ TypeError : if start and end timezones do not agree z>Start and end cannot both be tz-aware with different timezonesNz0Inferred time zone not equal to passed time zone)r infer_tzinfoAssertionErrorr/rr)r_r`rRrerrs rTrr s,,,UC8 ((5K    #B ~+1##K4 !ST T I   I!  L  sA// B 8 BB cV|r$||j}||j}||fSrO)r)r_r`rs rTrr s3  OO%E ?--/C #:rVc|D|j8|dk7r|nd}||dd}t|ts|||d<|jdi|}|S)a Localize a start or end Timestamp to the timezone of the corresponding start or end Timestamp Parameters ---------- ts : start or end Timestamp to potentially localize freq : Tick, DateOffset, or None tz : str, timezone object or None ambiguous: str, localization behavior for ambiguous times nonexistent: str, localization behavior for nonexistent times Returns ------- ts : Timestamp NinferF)rrrRrRrP)rrr<r)rrbrRrr localize_argss rTrr s_, ~"))+"+g!5I5 &/ SWX dD !T\"$M$  R^^ ,m , IrVc#Kt|}t|}|tur|j|}nd}t|}|tur|j|}nd}|E|C|j |s2|j dk\r|j |}n|j|}|rC|j |s2|j dk\r|j|}n|j |}|||kr|j dk\rd}d}||dk(r|}n ||dz |zz}||dk(r|}n ||dz |zz }td|}td|}|}|j dk\rO||krI|||k(ry|j|}|j|}||krtd|d|}||krHyy||k\rI|||k(ry|j|}|j|}||k\rtd|d|}||k\rHyyw)a Generates a sequence of dates corresponding to the specified time offset. Similar to dateutil.rrule except uses pandas DateOffset objects to represent time increments. Parameters ---------- start : Timestamp or None end : Timestamp or None periods : int or None offset : DateOffset unit : str Notes ----- * This method is faster for generating weekdays than dateutil.rrule * At least two of (start, end, periods) must be specified. * If both start and end are specified, the returned dates will satisfy start <= date <= end. Returns ------- dates : generator object NrrrzOffset z did not increment datez did not decrement date) r!rrr is_on_offsetrrollback rollforwardr _add_datetimer)r_r`rrrScur next_dates rTrr3 s=@v F e E C d# C.C #~kk$  7.v7J7J37O 88q=//#&C$$S)C V((/ 88q=&&u-EOOE*E3;688q= { a<C7Q;&00C } a<E7Q;&00E e $E {C C C xx1}SjIcz,,S1I!))$/IC 76(2I!JKKCSjSjIcz,,S1I!))$/IC 76(2I!JKKCSjsFG3"AG31G3).)rRrrSrErr4)rRrrSrErznp.dtype[np.datetime64])r)rRrrSrErrrO)rwr0rrr0rx str | None)rr?rrrRrrrrrrrCrr,r tuple[np.ndarray, tzinfo | None]) rrrRrrrrrCrztuple[np.ndarray, bool])FrN) rrrrrr@rr,rr-)rrrRr)rRrrrrr)F)rRrrrrr)r_rr`rrRrrr)r_rLr`rMrrrz)tuple[_TimestampNoneT1, _TimestampNoneT2])rTimestamp | Nonerr.) r_r.r`r.rrrrrSrErzGenerator[Timestamp])| __future__rrrrtypingrrr r r rNnumpyr[pandas._configr pandas._config.configr rM pandas._libsrrpandas._libs.tslibsrrrrrrrrrrrrrrrrr r!r"r#pandas._libs.tslibs.ccalendarr$r%pandas._libs.tslibs.dtypesr&pandas._libs.tslibs.offsetsr'pandas.compat.pyarrowr( pandas.errorsr)r*pandas.util._decoratorsr+pandas.util._exceptionsr,pandas.util._validatorsr-pandas.core.dtypes.commonr.r/r0r1r2r3pandas.core.dtypes.dtypesr4r5r6rer7rpandas.core.arrays._rangesr8r9pandas.core.commoncorecommonrpandas.tseries.frequenciesr:pandas.tseries.offsetsr;r<collections.abcr=r>rzrpandas._typingr?r@rArBrCrDrErFrtrHrJpandas.core.arrays.string_arrowrKrLrMrUry TimelikeOps DatelikeOpsr{rrrrrrrrrrrrPrVrTrKs" -:,:;-/46 3! 7     !.@19dC19dC I I O O)-11%1.1*& OF&XCOOS__F&XF&X`L&z z z  z  z  zzz&zz) )*)26)CP))`#* 9 9   9 ! 9  9 &9 x1p:5r8=220422j( ($(*7((V   "2 ?C . B~ ~ ~~  ~  ~~rV