U
|
¬ý°d¶6 ã @ sÈ d dl mZ d dlmZmZ d dlmZ d dlZd dlmZm Z m
|
Z
|
m Z m Z m Z mZmZmZmZmZ d dlZd dlZd dlmZmZ d dlmZ d dlm Z m Z m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+ d d l,m-Z-m.Z. d d
|
l/m0Z0 d d l1m2Z2 d d l3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZA d d lBmCZD d dlEmFZFmGZGmHZH d dlImJZJmKZKmLZL d dlMmNZN d dlOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^ d dl_m`Z`maZa d dlbmcZcmdZd d dlemfZfmgZg d dlhmiZimjZjmkZk d dllmmZmmnZnmoZo d dlpmqZq d dlrmsZs d dltmuZumvZv d dlwmxZx d dlymzZz d d l{m|Z| d dl}m~ mZ d d lmZmZm
Z
d d lmZmZ d d lmZ d d lmZmZ d d!lmZ eràd d"lmZmZmZ ee6e f Zed#d$d%Zd&d&d'd(d)ZG d*d$ d$eseuZG d+d, d,eZd-Zd.Zd/Zd0Zed1d2d%ZG d3d2 d2eZd4d5d6d7d8Zed9d9d:d;d<Z ed=d>d:d?d<Z d@dAd:dBd<Z dCdDdEdFZ¡dGdH Z¢dId5dJdKdLZ£dS )Mé )Ú annotations)ÚdatetimeÚ timedelta)ÚwrapsN) Ú TYPE_CHECKINGÚAnyÚCallableÚIteratorÚLiteralÚSequenceÚTypeVarÚUnionÚcastÚfinalÚoverload)ÚalgosÚlib)Ú NDArrayBacked)Ú
|
BaseOffsetÚIncompatibleFrequencyÚNaTÚNaTTypeÚPeriodÚ
|
ResolutionÚTickÚ TimedeltaÚ TimestampÚastype_overflowsafeÚdelta_to_nanosecondsÚget_unit_from_dtypeÚiNaTÚints_to_pydatetimeÚints_to_pytimedeltaÚ to_offset)ÚRoundToÚ round_nsint64)Ú compare_mismatched_resolutions)Úinteger_op_not_supported)Ú ArrayLikeÚAxisIntÚDatetimeLikeScalarÚDtypeÚDtypeObjÚFÚNpDtypeÚPositionalIndexer2DÚPositionalIndexerTupleÚ ScalarIndexerÚSequenceIndexerÚ TimeAmbiguousÚTimeNonexistentÚnpt)Úfunction)ÚAbstractMethodErrorÚInvalidComparisonÚPerformanceWarning)ÚAppenderÚ SubstitutionÚcache_readonly)Úfind_stack_level)Úis_all_stringsÚis_categorical_dtypeÚis_datetime64_any_dtypeÚis_datetime64_dtypeÚis_datetime64tz_dtypeÚ is_datetime_or_timedelta_dtypeÚis_dtype_equalÚis_float_dtypeÚis_integer_dtypeÚ is_list_likeÚis_object_dtypeÚis_period_dtypeÚis_string_dtypeÚis_timedelta64_dtypeÚ pandas_dtype)ÚDatetimeTZDtypeÚExtensionDtype)ÚABCCategoricalÚ ABCMultiIndex)Úis_valid_na_for_dtypeÚisna)Ú
|
algorithmsÚnanopsÚops)Úchecked_add_with_arrÚisinÚunique1d)Údatetimelike_accumulations)ÚOpsMixin)ÚNDArrayBackedExtensionArrayÚ ravel_compat)ÚArrowExtensionArray)ÚExtensionArray)Ú IntegerArray)ÚarrayÚ ensure_wrapped_if_datetimelikeÚ extract_array)Úcheck_array_indexerÚcheck_setitem_lengths)Úunpack_zerodim_and_defer)Úinvalid_comparisonÚmake_invalid_op)Ú frequencies)Ú DatetimeArrayÚ PeriodArrayÚTimedeltaArrayÚDatetimeLikeArrayTÚDatetimeLikeArrayMixin)Úboundr- )ÚmethÚreturnc s t fdd}tt|S )zâ
|
For PeriodArray methods, dispatch to DatetimeArray and re-wrap the results
|
in PeriodArray. We cannot use ._ndarray directly for the affected
|
methods because the i8 data has different semantics on NaT values.
|
c sj t | js | f||S | d¡} |f||}|tkr@tS t|trV| |j¡S | d¡}| |¡S )NzM8[ns]Úi8) rI ÚdtypeÚviewr Ú
|
isinstancer Ú _box_funcÚ_valueÚ_from_backing_data)ÚselfÚargsÚkwargsÚarrÚresultZres_i8©ro © úVd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/arrays/datetimelike.pyÚnew_meth© s
|
|
|
|
z"_period_dispatch.<locals>.new_meth)r r r- )ro r r~ r} r Ú_period_dispatch¢ s r c sâ e Zd ZU dZded< ded< ded< ded < d
|
ed < ed d ddZdödd ddddZedd ddZ ddd d d Z
|
dd d d d!Z ddd"d#d$Z d%d& Z dd d'd(Zd)d d*d+Zed,d d-d.Zd/dd0d1d2d3d4d5Zd÷d d6d7d8Zdød9dd:d;d<Zed=dd>d?d@ZedAdBdAdCdDd@ZdAdEdFdG fdHd@ Zd
|
d dIdJZdKdLddM fdNdO Zdd dPdQZdùd dS fdTdU ZedAdAdVdWdXZedYdZd:d[dXZed\d]d:d^dXZedúdd`d:dadXZdûdd`d: fdbdX ZedüdddedfdAdg fdhdi Z dýdAddAdk fdldm Z dndo Z ddRdpd d dpdqdrZ dþd ddsdtduZ dÿd dvdwdxZ!dydz Z"e#d{d d|d}Z$e%d~d Z&dd ddZ'dd ddZ(edd d
dZ)ed d ddZ*e+dfdddddZ,edd ddZ-edd ddZ.edd ddZ/edd ddZ0ed d ddZ1ed d ddZ2ed d ddZ3dd Z4e5dZ6e5dZ7e5d Z8e5d¡Z9e5d¢Z:e5d£Z;e5d¤Z<e5d¥Z=e5d¦Z>e5d§Z?e5d¨Z@e5d©ZAe#dªd d«d¬ZBe#d
|
d dd®ZCe#dZd d¯d°ZDe#dZdZd"d±d²ZEe#d³d´dµd¶ZFe#dZd´d·d¸ZGe#d¹d]d"dºd»ZHe#d¼d½d"d¾d¿ZIdÀdÁ ZJdÂdà ZKd]d´dÄdÅZLe#dÆd´dÇdÈZMe#dÉdÊ ZNe#dËdÌ ZOe#dÍd2d"dÎdÏZPe#d2d´dÐdÑZQdRdÒdd dÓdÔdÕZReSdÖd×dØ ZTdÙdÚ ZUeSdÛdÜdÝ ZVdÞdß ZWdAdAdVdàdáZXdAdAdVdâdãZYeZdAdäddAdå fdædç Z[eZddRdèdéd dèdêdëZ\eZddRdèdéd dèdìdíZ]dRdcdîd dédîdïdðZ^eZddRdèdéd dèdñdòZ_d d dódôdõZ` ZaS ( rm zÈ
|
Shared Base/Mixin class for DatetimeArray, TimedeltaArray, PeriodArray
|
|
Assumes that __new__/__init__ defines:
|
_ndarray
|
|
and that inheriting subclass implements:
|
freq
|
ztuple[str, ...]Ú_infer_matcheszCallable[[DtypeObj], bool]Ú_is_recognized_dtypeztuple[type, ...]Ú_recognized_scalarsz
|
np.ndarrayÚ_ndarrayzBaseOffset | NoneÚfreqÚbool©rp c C s dS )NTr~ ©rx r~ r~ r Ú _can_hold_naÍ s z#DatetimeLikeArrayMixin._can_hold_naNFz Dtype | NoneÚNone)rr Úcopyrp c C s t | d S ©N©r7 )rx Údatarr r r r~ r~ r Ú__init__Ñ s z DatetimeLikeArrayMixin.__init__ztype[DatetimeLikeScalar]c C s t | dS )z£
|
The scalar associated with this datelike
|
|
* PeriodArray : Period
|
* DatetimeArray : Timestamp
|
* TimedeltaArray : Timedelta
|
Nr r r~ r~ r Ú _scalar_typeÖ s z#DatetimeLikeArrayMixin._scalar_typeÚstrÚ DTScalarOrNaT)Úvaluerp c C s t | dS )ay
|
Construct a scalar type from a string.
|
|
Parameters
|
----------
|
value : str
|
|
Returns
|
-------
|
Period, Timestamp, or Timedelta, or NaT
|
Whatever the type of ``self._scalar_type`` is.
|
|
Notes
|
-----
|
This should call ``self._check_compatible_with`` before
|
unboxing the result.
|
Nr ©rx r r~ r~ r Ú_scalar_from_stringá s z*DatetimeLikeArrayMixin._scalar_from_stringz)np.int64 | np.datetime64 | np.timedelta64c C s t | dS )ad
|
Unbox the integer value of a scalar `value`.
|
|
Parameters
|
----------
|
value : Period, Timestamp, Timedelta, or NaT
|
Depending on subclass.
|
|
Returns
|
-------
|
int
|
|
Examples
|
--------
|
>>> self._unbox_scalar(Timedelta("10s")) # doctest: +SKIP
|
10000000000
|
Nr r r~ r~ r Ú _unbox_scalarõ s z$DatetimeLikeArrayMixin._unbox_scalar)Úotherrp c C s t | dS )a|
|
Verify that `self` and `other` are compatible.
|
|
* DatetimeArray verifies that the timezones (if any) match
|
* PeriodArray verifies that the freq matches
|
* Timedelta has no verification
|
|
In each case, NaT is considered compatible.
|
|
Parameters
|
----------
|
other
|
|
Raises
|
------
|
Exception
|
Nr ©rx r r~ r~ r Ú_check_compatible_with s z-DatetimeLikeArrayMixin._check_compatible_withc C s t | dS )zI
|
box function to get object from internal representation
|
Nr )rx Úxr~ r~ r ru ! s z DatetimeLikeArrayMixin._box_funcc C s t j|| jddS )z1
|
apply box func to passed values
|
F)Úconvert)r Z map_inferru )rx Úvaluesr~ r~ r Ú _box_values' s z"DatetimeLikeArrayMixin._box_valuesr c s< j dkr$ fddtt D S fdd jD S d S )Né c 3 s | ]} | V qd S r r~ )Ú.0Únr r~ r Ú <genexpr>/ s z2DatetimeLikeArrayMixin.__iter__.<locals>.<genexpr>c 3 s | ]} |¡V qd S r )ru )r Úvr r~ r r¢ 1 s )ÚndimÚrangeÚlenÚasi8r r~ r r Ú__iter__- s
|
z DatetimeLikeArrayMixin.__iter__znpt.NDArray[np.int64]c C s | j d¡S )z
|
Integer representation of the values.
|
|
Returns
|
-------
|
ndarray
|
An ndarray with int64 dtype.
|
rq )r
rs r r~ r~ r r§ 3 s zDatetimeLikeArrayMixin.asi8r )Úna_repÚ date_formatz str | floatúnpt.NDArray[np.object_])r© rp c C s t | dS )z|
|
Helper method for astype when converting to strings.
|
|
Returns
|
-------
|
ndarray[str]
|
Nr )rx r© rª r~ r~ r Ú_format_native_typesC s
|
z+DatetimeLikeArrayMixin._format_native_types)Úboxedc C s dj S )Nz'{}')Úformat)rx r r~ r~ r Ú
|
_formatterO s z!DatetimeLikeArrayMixin._formatterzNpDtype | None©rr rp c C s t |rtjt| tdS | jS )N©rr )rH Únpr` ÚlistÚobjectr
©rx rr r~ r~ r Ú __array__V s z DatetimeLikeArrayMixin.__array__r1 )Úitemrp c C s d S r r~ ©rx r· r~ r~ r Ú __getitem__\ s z"DatetimeLikeArrayMixin.__getitem__rl z(SequenceIndexer | PositionalIndexerTuple)rx r· rp c C s d S r r~ r¸ r~ r~ r r¹ ` s r/ z"DatetimeLikeArrayT | DTScalarOrNaT)rx Úkeyrp c s: t dt |¡}t |¡r |S t t|}| |¡|_|S )z
|
This getitem defers to the underlying array, which by-definition can
|
only handle list-likes, slices, and integer scalars
|
z(Union[DatetimeLikeArrayT, DTScalarOrNaT])r Úsuperr¹ r Ú is_scalarrl Ú_get_getitem_freqÚ_freq)rx rº r| ©Ú __class__r~ r r¹ g s
|
|
ÿ
|
|
c C s¬ t | j}|r| j}n| jdkr&d}nt| |}d}t|trh| jdk r`|jdk r`|j| j }q¨| j}n@|tkrx| j}n0t
|
|¡r¨t | tj¡¡}t|tr¨| |¡S |S )z\
|
Find the `freq` attribute to assign to the result of a __getitem__ lookup.
|
r N)rI rr r r¤ rc rt ÚsliceÚstepÚEllipsisÚcomZis_bool_indexerr Zmaybe_booleans_to_slicers r² Zuint8r½ )rx rº Z is_periodr Znew_keyr~ r~ r r½ | s$
|
|
|
|
|
|
|
z(DatetimeLikeArrayMixin._get_getitem_freqz,int | Sequence[int] | Sequence[bool] | slicez NaTType | Any | Sequence[Any])rº r rp c s. t ||| }t ||¡ |r"d S | ¡ d S r )rd r» Ú __setitem__Ú_maybe_clear_freq)rx rº r Zno_opr¿ r~ r rÅ s
|
z"DatetimeLikeArrayMixin.__setitem__c C s d S r r~ r r~ r~ r rÆ ° s z(DatetimeLikeArrayMixin._maybe_clear_freqT©r c s4 t |}t|rv| jjdkrDtd| } | j}t|| jd| jd}|S | jjdkr^t | j
|
ddS | | j ¡ ¡ | j¡S t|trt j||dS t|r | ¡ S t|rà| j}|tjkrÐtd | j d
|
| d |rÜ| ¡ }|S t| røt| j|rt |r"d t | j d | }t|ntj | |dS d S )NÚMri Ú timestamp)ÚtzÚboxZresoÚmT)rË rÇ zConverting from z to z? is not supported. Do obj.astype('int64').astype(dtype) insteadz Cannot cast z
|
to dtype r± ) rL rH rr Úkindr r§ r! rÊ Ú_cresor" r
r ÚravelÚreshapeÚshapert rN r» ÚastyperJ r¬ rF r² Úint64Ú TypeErrorr rC rD rE ÚtypeÚ__name__Úasarray)rx rr r Zi8dataZ convertedr Úmsgr¿ r~ r rÒ µ sJ
|
ü
|
|
ÿÿ
|
þý
|
z DatetimeLikeArrayMixin.astype)rx rp c C s d S r r~ r r~ r~ r rs ë s zDatetimeLikeArrayMixin.viewzLiteral['M8[ns]']ri c C s d S r r~ rµ r~ r~ r rs ï s zLiteral['m8[ns]']rk c C s d S r r~ rµ r~ r~ r rs ó s .r( c C s d S r r~ rµ r~ r~ r rs ÷ s c s t |¡S r )r» rs rµ r¿ r~ r rs ü s r útype[DatetimeLikeArrayT]z Sequence[DatetimeLikeArrayT]r) )ÚclsÚ to_concatÚaxisrp c s¦ t ||¡}|d j}d }t|r0 j}nl|dkrdd |D } jd k rt fdd|D rt|d d
|dd
}t fdd|D r j}||_|S ) Nr c S s g | ]}t |r|qS r~ )r¦ ©r r r~ r~ r Ú
|
<listcomp> s z<DatetimeLikeArrayMixin._concat_same_type.<locals>.<listcomp>c 3 s | ]}|j j kV qd S r ©r rÝ ©Úobjr~ r r¢ s z;DatetimeLikeArrayMixin._concat_same_type.<locals>.<genexpr>éÿÿÿÿr c 3 s, | ]$}|d d j |d d kV qdS )r râ r Nrß )r Úpairrà r~ r r¢ s )r» Ú_concat_same_typerr rI r ÚallÚzipr¾ )rÚ rÛ rÜ Únew_objrr Únew_freqÚpairsr¿ rà r rä s z(DatetimeLikeArrayMixin._concat_same_typeÚC)rx Úorderrp c s t j|d}| j|_|S )N)rë )r» r r r¾ )rx rë rç r¿ r~ r r s zDatetimeLikeArrayMixin.copyc
|
C s. t |tr:z| |¡}W n ttfk
|
r8 t|Y nX t || jsN|tkr| |¡}z| |¡ W n0 t
|
tfk
|
r } zt||W 5 d }~X Y nX nt |s¬t|n~t |t | krÆtdndz | j |dd}| |¡ W nF t
|
tfk
|
r( } z"tt|dd rn
|
t||W 5 d }~X Y nX |S )NzLengths must matchT©Ú allow_objectrr )rt r r Ú
|
ValueErrorr r8 r r r r rÔ rG r¦ Ú_validate_listlikerH Úgetattr)rx r Úerrr~ r~ r Ú_validate_comparison_value) s.
|
|
|
|
z1DatetimeLikeArrayMixin._validate_comparison_value)Úallow_listlikeÚunboxc
|
C sÐ t || jrn°t |trbz| |¡}W q¾ tk
|
r^ } z| ||¡}t||W 5 d}~X Y q¾X n\t|| jrtt }nJt
|
|r| ||¡}t|n,t || j rª| |¡}n| ||¡}t||sÆ|S | |¡S )a
|
Validate that the input value can be cast to our scalar_type.
|
|
Parameters
|
----------
|
value : object
|
allow_listlike: bool, default False
|
When raising an exception, whether the message should say
|
listlike inputs are allowed.
|
unbox : bool, default True
|
Whether to unbox the result before returning. Note: unbox=False
|
skips the setitem compatibility check.
|
|
Returns
|
-------
|
self._scalar_type or NaT
|
N) rt r r r rî Ú_validation_error_messagerÔ rQ rr r rR r r )rx r ró rô rñ rØ r~ r~ r Ú_validate_scalarM s(
|
|
z'DatetimeLikeArrayMixin._validate_scalar)ró rp c C sB |r"d| j j dt|j d}n d| j j dt|j d}|S )a+
|
Construct an exception message on validation error.
|
|
Some methods allow only scalar inputs, while others allow either scalar
|
or listlike.
|
|
Parameters
|
----------
|
allow_listlike: bool, default False
|
|
Returns
|
-------
|
str
|
zvalue should be a 'z"', 'NaT', or array of those. Got 'z
|
' instead.z' or 'NaT'. Got ')r rÖ rÕ )rx r ró rØ r~ r~ r rõ s ÿÿz0DatetimeLikeArrayMixin._validation_error_messagerì c C sv t |t| r|S t |tr<t|dkr<t| jg | jdS t|dr¬|jtkr¬t |¡| j
|
kr¬zt| |¡}W n8 t t fk
|
rª |r| Y S | |d¡}t |Y nX t|dd}t|}t|dd}t|rzt| j|| jd}W n t k
|
r Y nX t|jr8t|jj| jr8| ¡ }t|dd}|rLt|jrLn&t| |j¡sr| |d¡}t ||S )Nr r± rr T©Z extract_numpy)rt rÕ r³ r¦ Ú_from_sequencerr Úhasattrr´ r Ú infer_dtyper rî rÔ rõ rb Úpd_arrayr> r? rD Ú
|
categoriesZ_internal_get_valuesrH r )rx r rí rØ r~ r~ r rï £ s>
|
z)DatetimeLikeArrayMixin._validate_listlikec C s, t |r| |¡}n| j|ddS | |¡S )NT)ró )rG rï rö Ú_unboxr r~ r~ r Ú_validate_setitem_valueÖ s z.DatetimeLikeArrayMixin._validate_setitem_valuez6np.int64 | np.datetime64 | np.timedelta64 | np.ndarrayc C s* t |¡r| |¡}n| |¡ |j}|S )zZ
|
Unbox either a scalar with _unbox_scalar or an instance of our own type.
|
)r r¼ r r r
r r~ r~ r rý Þ s
|
|
|
z DatetimeLikeArrayMixin._unboxc C s ddl m} || |¡jS )Nr )ÚIndex)Zpandasrÿ Úmapr` )rx Zmapperrÿ r~ r~ r r ð s zDatetimeLikeArrayMixin.mapznpt.NDArray[np.bool_]c C sD t |dst |¡}|jjdkr0tj| jtdS t|t | sØdddddd g}|jt
|
kr t j |d
|
d }||kr |d krxn(d |krt | t
|
¡|S tj| jtdS zt | |¡}W n$ tk
|
rÖ t | t
|
¡| Y S X | jjdk rütd| } | | j¡}z| |¡ W n* ttfk
|
r4 tj| jtd Y S X t | j|jS )zô
|
Compute boolean array of whether each value is found in the
|
passed set of values.
|
|
Parameters
|
----------
|
values : set or sequence of values
|
|
Returns
|
-------
|
ndarray[bool]
|
rr )ÚfÚiÚuÚcr± r Ú timedelta64r Ú
|
datetime64ÚdateZperiodF©ÚskipnaÚstringÚmixed©rÌ rÈ ú DatetimeArray | TimedeltaArray)rù r² r× rr rÍ ÚzerosrÑ r rt rÕ r´ r rú rW rÒ rø rî r Úas_unitÚunitr rÔ r§ )rx r Z inferableÚinferredr~ r~ r rW û s@
|
|
ú
|
|
zDatetimeLikeArrayMixin.isinc C s | j S r )Ú_isnanr r~ r~ r rR 7 s zDatetimeLikeArrayMixin.isnac C s
|
| j tkS )z-
|
return if each value is nan
|
)r§ r r r~ r~ r r : s z DatetimeLikeArrayMixin._isnanc C s t | j ¡ S )zJ
|
return if I have any nans; enables various perf speedups
|
)r r Úanyr r~ r~ r Ú_hasnaA s z DatetimeLikeArrayMixin._hasna)r| rp c C s6 | j r2|r| |¡}|dkr"tj}t || j|¡ |S )az
|
Parameters
|
----------
|
result : np.ndarray
|
fill_value : object, default iNaT
|
convert : str, dtype or None
|
|
Returns
|
-------
|
result : ndarray with values replace by the fill_value
|
|
mask the result if needed, convert to the provided dtype if its not
|
None
|
|
This is an internal routine.
|
N)r rÒ r² ÚnanÚputmaskr )rx r| Ú
|
fill_valuer r~ r~ r Ú_maybe_mask_resultsH s
|
z*DatetimeLikeArrayMixin._maybe_mask_resultsz
|
str | Nonec C s | j dkrdS | j jS )zU
|
Return the frequency object as a string if its set, otherwise None.
|
N)r Úfreqstrr r~ r~ r r f s
|
z DatetimeLikeArrayMixin.freqstrc C s6 | j dkrdS z t | ¡W S tk
|
r0 Y dS X dS )z
|
Tries to return a string representing a frequency generated by infer_freq.
|
|
Returns None if it can't autodetect the frequency.
|
r N)r¤ rh Z
|
infer_freqrî r r~ r~ r Ú inferred_freqo s
|
z$DatetimeLikeArrayMixin.inferred_freqzResolution | Nonec C s: | j }|d krd S z t |¡W S tk
|
r4 Y d S X d S r )r r Zget_reso_from_freqstrÚKeyError)rx r r~ r~ r Ú_resolution_obj} s z&DatetimeLikeArrayMixin._resolution_objc C s | j jS )zO
|
Returns day, hour, minute, second, millisecond or microsecond
|
)r Úattrnamer r~ r~ r Ú
|
resolution s z!DatetimeLikeArrayMixin.resolutionc C s t j| jddd S )NT©Ztimeliker ©r Z is_monotonicr§ r r~ r~ r Ú_is_monotonic_increasing s z/DatetimeLikeArrayMixin._is_monotonic_increasingc C s t j| jddd S )NTr r r r r~ r~ r Ú_is_monotonic_decreasing s z/DatetimeLikeArrayMixin._is_monotonic_decreasingc C s t t| j d¡| jkS )NÚK)r¦ rX r§ rÏ Úsizer r~ r~ r Ú
|
_is_unique s z!DatetimeLikeArrayMixin._is_uniquec
|
C sÒ | j dkr6t|dd | jkr6|| ¡ | ¡ | j¡S z| |¡}W n tk
|
rd t| || Y S X t|dd }t|r°t j
|
dd t |t | t¡¡|¡}W 5 Q R X |S |tkrè|tjkrÔt j| jtd}nt j| jtd}|S t| jsxtt| } | j|jkrxt|t | sdz|j | j dd}W n0 t k
|
r` t |j!¡}t"| j#|| Y S X n|j#}t"| j#||S | $|¡}|| j# %d ¡| %d ¡}t&|}| j'|B }| (¡ rÎ|tjk} t )||| ¡ |S )
|
Nr rÑ rr Úignore)rå r± F©Zround_okrq )*r¤ rð rÑ rÏ rÐ rò r8 rf rH r² ZerrstaterU Zcomp_method_OBJECT_ARRAYr× rÒ r´ r ÚoperatorÚneZonesr r rI rr r Ú TimelikeOpsrÎ rt rÕ r r rî r` Zasm8r& r
rý rs rR r r r )
|
rx r Úoprr r| Z other_arrZ
|
other_valsÚo_maskÚmaskZ
|
nat_resultr~ r~ r Ú _cmp_method¡ sV ÿ
|
|
ÿ
|
|
|
|
z"DatetimeLikeArrayMixin._cmp_methodÚ__pow__Ú__rpow__Ú__mul__Ú__rmul__Ú __truediv__Ú __rtruediv__Ú __floordiv__Ú __rfloordiv__Ú__mod__Ú__rmod__Ú
|
__divmod__Ú __rdivmod__z@tuple[int | npt.NDArray[np.int64], None | npt.NDArray[np.bool_]]c C sD t |tr|j}d}n&t |ttfr0|j}d}n |j}|j}||fS )zR
|
Get the int64 values and b_mask to pass to checked_add_with_arr.
|
N)rt r Úordinalr r rv r r§ )rx r Zi8valuesr- r~ r~ r Ú_get_i8_values_and_maskê s
|
z.DatetimeLikeArrayMixin._get_i8_values_and_maskc C s4 t | jr| jS t |¡s dS t| jtr0| jS dS )zP
|
Check if we can preserve self.freq in addition or subtraction.
|
N)rI rr r r r¼ rt r r r~ r~ r Ú_get_arithmetic_result_freqý s
|
|
z2DatetimeLikeArrayMixin._get_arithmetic_result_freqc
|
C s" t | js*tdt| j dt|j td| } ddlm} ddlm } |t
|
k sXt t |r| j t
|
¡ d| j d¡ }|j||jd S t|}| |¡\} }td| } | |¡\}}t| j|| j|d
|
}| d| j d¡}||j| jd }| d| j d¡}| |¡} |j||| d S ) Nú cannot add ú and rk r ©ri )Ú tz_to_dtypezM8[ú]r± ©Zarr_maskZb_mask©rÊ r ©rr r )rK rr rÔ rÕ rÖ r Úpandas.core.arraysri Z pandas.core.arrays.datetimesrA r ÚAssertionErrorrR r
Z to_datetime64rÒ r Ú _simple_newr Ú_ensure_matching_resosr< rV r§ r rs rÊ r= )
|
rx r ri rA r| Úother_i8r, Ú
|
res_valuesrr rè r~ r~ r Ú_add_datetimelike_scalar s4
|
ÿ
|
|
ÿ
|
z/DatetimeLikeArrayMixin._add_datetimelike_scalarc C s2 t | js*tdt| j dt|j || S )Nr> r? )rK rr rÔ rÕ rÖ r r~ r~ r Ú_add_datetime_arraylike1 s
|
|
ÿz.DatetimeLikeArrayMixin._add_datetime_arraylikezdatetime | np.datetime64)r c C sZ | j jdkr tdt| j td| } t|r:| t S t|}| |¡\} }|
|
|¡S )NrÈ ú"cannot subtract a datelike from a ri ) rr rÍ rÔ rÕ rÖ r rR r r rI Ú_sub_datetimelike)rx r Útsr~ r~ r Ú_sub_datetimelike_scalar; s
|
z/DatetimeLikeArrayMixin._sub_datetimelike_scalarc C sZ | j jdkr tdt| j t| t|kr8tdtd| } | |¡\} }| |¡S )NrÈ rN ú$cannot add indices of unequal lengthri )
|
rr rÍ rÔ rÕ rÖ r¦ rî r rI rO r r~ r~ r Ú_sub_datetime_arraylikeL s
|
z.DatetimeLikeArrayMixin._sub_datetime_arraylikezTimestamp | DatetimeArrayc
|
|
C sº t d| } ddlm} z| |¡ W n@ tk
|
rd } z"t| dd¡}t|||W 5 d }~X Y nX | |¡\}}t | j
|
| | j |d}| d| j d¡}| |¡} |j||j| d S )
|
Nri r ©rk ÚcompareÚsubtractrC ú timedelta64[rB rE )r rF rk Z_assert_tzawareness_compatrÔ r ÚreplacerÕ r< rV r§ r rs r r= rH rr )
|
rx r rk rñ Z new_messagerJ r, rK Zres_m8rè r~ r~ r rO Y s"
|
ÿ
|
z(DatetimeLikeArrayMixin._sub_datetimeliker rj c C sP t | js tdt| j ddlm} t |j | j
|
¡}|||j d}|| S )Nzcannot add Period to a r )rj rß ) rK rr rÔ rÕ rÖ Zpandas.core.arrays.periodrj r² Z broadcast_tor; rÑ r )rx r rj Zi8valsZparrr~ r~ r Ú _add_periodn s
|
z"DatetimeLikeArrayMixin._add_periodc C s t | d S r r )rx Úoffsetr~ r~ r Ú _add_offsetz s z"DatetimeLikeArrayMixin._add_offsetc C sj t |r@tj| jdd | jj¡}| t¡ t | j
|
|| jdS t d| } t |}| |¡\} }| |¡S )zk
|
Add a delta of a timedeltalike
|
|
Returns
|
-------
|
Same type as self
|
rq r± r )rR r² ÚemptyrÑ rs r
rr Úfillr rÕ rH r r rI Ú_add_timedeltalike)rx r Ú
|
new_valuesr~ r~ r Ú_add_timedeltalike_scalar} s
|
|
z0DatetimeLikeArrayMixin._add_timedeltalike_scalarc C s: t | t |krtdtd| } | |¡\} }| |¡S )zl
|
Add a delta of a TimedeltaIndex
|
|
Returns
|
-------
|
Same type as self
|
rR r )r¦ rî r rI r^ r r~ r~ r Ú_add_timedelta_arraylike s
|
|
|
z/DatetimeLikeArrayMixin._add_timedelta_arraylikezTimedelta | TimedeltaArrayc C sZ t d| } | |¡\}}t| j|| j|d}| | jj¡}| |¡}t | j
|
|| j|dS )Nr rC rE ) r r< rV r§ r rs r
rr r= rÕ rH )rx r rJ r, r_ rK rè r~ r~ r r^ £ s
|
ÿ
|
z)DatetimeLikeArrayMixin._add_timedeltalikec C st t | jr*tdt| j dttj td| } tj| j tj
|
d}| t ¡ | | jj¡}t| j|| jddS )z$
|
Add pd.NaT to self
|
z Cannot add r? z TimedeltaArray | DatetimeArrayr± NrE )rI rr rÔ rÕ rÖ r r r² r\ rÑ rÓ r] r rs r
rH ©rx r| r~ r~ r Ú_add_nat± s
|
ÿ
|
|
z DatetimeLikeArrayMixin._add_natc C sT t j| jt jd}| t¡ | jjdkrFtd| } | d| j
|
d¡S | d¡S dS )z+
|
Subtract pd.NaT from self
|
r± r z DatetimeArray| TimedeltaArrayrW rB ztimedelta64[ns]N) r² r\ rÑ rÓ r] r rr rÍ r rs r rb r~ r~ r Ú_sub_natà s
|
|
z DatetimeLikeArrayMixin._sub_natzPeriod | PeriodArrayc s t js*tdt|j dt j td |¡ |¡\}}t j | j
|
|d}t fdd|D ¡}|d kr j
|
}n
|
j
|
|B }t ||< |S )Núcannot subtract ú from rj rC c s g | ]} j j| qS r~ )r ÚbaserÝ r r~ r rÞ ç s z:DatetimeLikeArrayMixin._sub_periodlike.<locals>.<listcomp>)rI rr rÔ rÕ rÖ r r r< rV r§ r r² r` r )rx r rJ r, Z new_i8_dataZnew_datar- r~ r r Ú_sub_periodlike× s&
|
ÿ
|
|
ÿ
|
z&DatetimeLikeArrayMixin._sub_periodlikec C s |t jt jfkstt|dkr8| jdkr8|| |d S tjdt| j dt
|
t d | j |j kstt| j |j f|| d¡t |¡}|S )aZ
|
Add or subtract array-like of DateOffset objects
|
|
Parameters
|
----------
|
other : np.ndarray[object]
|
op : {operator.add, operator.sub}
|
|
Returns
|
-------
|
np.ndarray[object]
|
Except in fastpath case with length 1 where we operate on the
|
contained scalar.
|
r r z)Adding/subtracting object-dtype array to z not vectorized.)Ú
|
stacklevelÚO)r( ÚaddÚsubrG r¦ r¤ ÚwarningsÚwarnrÕ rÖ r9 r= rÑ rÒ r² r× )rx r r+ rK r~ r~ r Ú_addsub_object_arrayò s ü z+DatetimeLikeArrayMixin._addsub_object_arrayr )Únamer c K sX |dkr t d| dt| tt|}|| ¡ fd|i|}t| j|d | jdS )N> ÚcummaxÚcumminz Accumulation z not supported for r )r rr )rÔ rÕ rð rY r rH rr )rx rp r rz r+ r| r~ r~ r Ú _accumulate s
|
ÿz"DatetimeLikeArrayMixin._accumulateÚ__add__c C s t |dd }t|}|tkr(| ¡ }nBt|tttjfrH| |¡}n"t|t
|
r`| |¡}n
|
t|t tj fr|| |¡}nît|trt| jr| |¡}nÎt |¡rÚt| js¸t| td| }| ||jj tj ¡}nt|rî| |¡}n|t |r| |tj ¡}nbt |s t!|r&| "|¡S t#|rft| jsDt| td| }| ||jj tj ¡}nt$S t|tj%rt|jrddl&m'} ||S |S ©Nrr rj r rT )(rð ra r rc rt r r r² r r` r r[ r r rL r rK rr rY r Ú
|
is_integerrI r' r Ú_addsub_int_array_or_scalarr r¡ r( rk ra rH ro rA rB rM rF ÚNotImplementedÚndarrayrF rk ©rx r Ú other_dtyper| rá rk r~ r~ r rt ! sB
|
|
|
|
|
|
|
|
z DatetimeLikeArrayMixin.__add__c C s
|
| |¡S r )rt r r~ r~ r Ú__radd__W s z DatetimeLikeArrayMixin.__radd__Ú__sub__c C s° t |dd }t|}|tkr(| ¡ }nVt|tttjfrJ| | ¡}n4t|t
|
rd| | ¡}nt|t tj fr| |¡}nþt |¡r¾t| jst| td| }| ||jj tj¡}nÀt|trÔ| |¡}nªt |rê| | ¡}nt |r| |tj¡}nzt |st!|r$| "|¡}nZt|r:| |¡}nDt#|rzt| jsXt| td| }| ||jj tj¡}nt$S t|tj%r¬t |jr¬ddl&m'} ||S |S ru )(rð ra r rd rt r r r² r r` r r[ r r rQ r rv rI rr r' r rw r r¡ r( rl r rh rK ra rH ro rA rB rS rF rx ry rF rk rz r~ r~ r r} [ sF
|
|
|
|
|
|
|
|
|
z DatetimeLikeArrayMixin.__sub__c C sò t |dd }t|rZt| jrZt |¡r4t|| S t|tsRddl m
|
} ||}|| S t| jrt |drt|jst dt | j dt |j nNt| jrÊt|rÊt dt | j d|j n t| jrètd| } | | S | | S )Nrr r r@ re rf rk )rð r@ rK rr r r¼ r rt rm rF ri rù rÔ rÕ rÖ rI r )rx r r{ ri r~ r~ r Ú__rsub__ s.
|
|
ÿþýÿ
|
|
|
z DatetimeLikeArrayMixin.__rsub__c C s2 | | }|d d
| d d
< t | js.|j| _| S r ©rI rr r r¾ ©rx r r| r~ r~ r Ú__iadd__´ s
|
|
z DatetimeLikeArrayMixin.__iadd__c C s2 | | }|d d
| d d
< t | js.|j| _| S r r r r~ r~ r Ú__isub__½ s
|
|
z DatetimeLikeArrayMixin.__isub__znpt.NDArray[np.float64])rx ÚqsÚ interpolationrp c s t j||dS )N)r r )r» Ú _quantile)rx r r r¿ r~ r r
É s z DatetimeLikeArrayMixin._quantile©rÜ r úAxisInt | Nonec K s8 t d|¡ t || j¡ tj| j||d}| ||¡S )a
|
Return the minimum value of the Array or minimum along
|
an axis.
|
|
See Also
|
--------
|
numpy.ndarray.min
|
Index.min : Return the minimum value in an Index.
|
Series.min : Return the minimum value in a Series.
|
r~ r )ÚnvZ validate_minÚvalidate_minmax_axisr¤ rT Znanminr
Ú_wrap_reduction_result©rx rÜ r rz r| r~ r~ r ÚminÑ s zDatetimeLikeArrayMixin.minc K s8 t d|¡ t || j¡ tj| j||d}| ||¡S )a
|
Return the maximum value of the Array or maximum along
|
an axis.
|
|
See Also
|
--------
|
numpy.ndarray.max
|
Index.max : Return the maximum value in an Index.
|
Series.max : Return the maximum value in a Series.
|
r~ r )r Z validate_maxr r¤ rT Znanmaxr
r r r~ r~ r Úmaxã s zDatetimeLikeArrayMixin.max)r rÜ c C sD t | jr tdt| j dtj| j||| ¡ d}| ||¡S )aL
|
Return the mean value of the Array.
|
|
Parameters
|
----------
|
skipna : bool, default True
|
Whether to ignore any NaT elements.
|
axis : int, optional, default 0
|
|
Returns
|
-------
|
scalar
|
Timestamp or Timedelta.
|
|
See Also
|
--------
|
numpy.ndarray.mean : Returns the average of array elements along a given axis.
|
Series.mean : Return the mean value in a Series.
|
|
Notes
|
-----
|
mean is only defined for Datetime and Timedelta dtypes, not for Period.
|
z mean is not implemented for zX since the meaning is ambiguous. An alternative is obj.to_timestamp(how='start').mean()©rÜ r r- )
|
rI rr rÔ rÕ rÖ rT Znanmeanr
rR r )rx r rÜ r| r~ r~ r Úmeanõ s
|
ÿ ÿzDatetimeLikeArrayMixin.meanc K sH t d|¡ |d k r*t|| jkr*tdtj| j||d}| ||¡S )Nr~ z abs(axis) must be less than ndimr ) r Zvalidate_medianÚabsr¤ rî rT Z nanmedianr
r r r~ r~ r Úmedian s
|
z DatetimeLikeArrayMixin.median)Údropnac C sH d }|r| ¡ }tj| d¡|d}| | jj¡}ttj|}| |¡S )Nrq )r- )
|
rR rS Úmoders r
rr r r² ry rw )rx r r- Zi8modesZnpmodesr~ r~ r Ú_mode$ s z DatetimeLikeArrayMixin._mode)NNF)F)N)T).)N)r )rê )F)F)T)brÖ Ú
|
__module__Ú __qualname__Ú__doc__Ú__annotations__r< r r Úpropertyr r r r ru r r¨ r§ r¬ r¯ r¶ r r¹ r½ rÅ rÆ rÒ rs Ú classmethodrä r rò rö rõ rï rþ r rý r\ r rW rR r r r r r r r r r! r" r% r. rg r/ r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r: r< r= rL rM rQ rS rO rY r[ r` ra r^ rc rd rh ro rs re rt r| r} r~ r r r r
r r r r r Ú __classcell__r~ r~ r¿ r rm » s
|
ÿ
|
ÿ 6 ý
|
(û;3
|
|
< ÿ
|
<#
|
|
#
|
5
|
5# % c @ s* e Zd ZdZedddddddZd S )
|
Ú DatelikeOpszK
|
Common ops for DatetimeIndex/PeriodIndex, but not TimedeltaIndex.
|
zNhttps://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior)ÚURLr r« )rª rp c C s | j |tjd}|jtddS )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 <%(URL)s>`__.
|
|
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='object')
|
)rª r© FrÇ )r¬ r² r rÒ r´ )rx rª r| r~ r~ r Ústrftime4 s 1zDatelikeOps.strftimeN)rÖ r r r r; r r~ r~ r~ r r / s
|
ÿr aM
|
Perform {op} operation on the data to the specified `freq`.
|
|
Parameters
|
----------
|
freq : str or Offset
|
The frequency level to {op} the index to. Must be a fixed
|
frequency like 'S' (second) not 'ME' (month end). See
|
:ref:`frequency aliases <timeseries.offset_aliases>` for
|
a list of possible `freq` values.
|
ambiguous : 'infer', bool-ndarray, 'NaT', default 'raise'
|
Only relevant for DatetimeIndex:
|
|
- 'infer' will attempt to infer fall dst-transition hours based on
|
order
|
- bool-ndarray where True signifies a DST time, False designates
|
a non-DST time (note that this flag is only applicable for
|
ambiguous times)
|
- 'NaT' will return NaT where there are ambiguous times
|
- 'raise' will raise an AmbiguousTimeError if there are ambiguous
|
times.
|
|
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 an NonExistentTimeError if there are
|
nonexistent times.
|
|
Returns
|
-------
|
DatetimeIndex, TimedeltaIndex, or Series
|
Index of the same type for a DatetimeIndex or TimedeltaIndex,
|
or a Series with the same index for a Series.
|
|
Raises
|
------
|
ValueError if the `freq` cannot be converted.
|
|
Notes
|
-----
|
If the timestamps have a timezone, {op}ing will take place relative to the
|
local ("wall") time and re-localized to the same timezone. When {op}ing
|
near daylight savings time, use ``nonexistent`` and ``ambiguous`` to
|
control the re-localization behavior.
|
|
Examples
|
--------
|
**DatetimeIndex**
|
|
>>> rng = pd.date_range('1/1/2018 11:59:00', periods=3, freq='min')
|
>>> rng
|
DatetimeIndex(['2018-01-01 11:59:00', '2018-01-01 12:00:00',
|
'2018-01-01 12:01:00'],
|
dtype='datetime64[ns]', freq='T')
|
a >>> rng.round('H')
|
DatetimeIndex(['2018-01-01 12:00:00', '2018-01-01 12:00:00',
|
'2018-01-01 12:00:00'],
|
dtype='datetime64[ns]', freq=None)
|
|
**Series**
|
|
>>> pd.Series(rng).dt.round("H")
|
0 2018-01-01 12:00:00
|
1 2018-01-01 12:00:00
|
2 2018-01-01 12:00:00
|
dtype: datetime64[ns]
|
|
When rounding near a daylight savings time transition, use ``ambiguous`` or
|
``nonexistent`` to control how the timestamp should be re-localized.
|
|
>>> rng_tz = pd.DatetimeIndex(["2021-10-31 03:30:00"], tz="Europe/Amsterdam")
|
|
>>> rng_tz.floor("2H", ambiguous=False)
|
DatetimeIndex(['2021-10-31 02:00:00+01:00'],
|
dtype='datetime64[ns, Europe/Amsterdam]', freq=None)
|
|
>>> rng_tz.floor("2H", ambiguous=True)
|
DatetimeIndex(['2021-10-31 02:00:00+02:00'],
|
dtype='datetime64[ns, Europe/Amsterdam]', freq=None)
|
a >>> rng.floor('H')
|
DatetimeIndex(['2018-01-01 11:00:00', '2018-01-01 12:00:00',
|
'2018-01-01 12:00:00'],
|
dtype='datetime64[ns]', freq=None)
|
|
**Series**
|
|
>>> pd.Series(rng).dt.floor("H")
|
0 2018-01-01 11:00:00
|
1 2018-01-01 12:00:00
|
2 2018-01-01 12:00:00
|
dtype: datetime64[ns]
|
|
When rounding near a daylight savings time transition, use ``ambiguous`` or
|
``nonexistent`` to control how the timestamp should be re-localized.
|
|
>>> rng_tz = pd.DatetimeIndex(["2021-10-31 03:30:00"], tz="Europe/Amsterdam")
|
|
>>> rng_tz.floor("2H", ambiguous=False)
|
DatetimeIndex(['2021-10-31 02:00:00+01:00'],
|
dtype='datetime64[ns, Europe/Amsterdam]', freq=None)
|
|
>>> rng_tz.floor("2H", ambiguous=True)
|
DatetimeIndex(['2021-10-31 02:00:00+02:00'],
|
dtype='datetime64[ns, Europe/Amsterdam]', freq=None)
|
a >>> rng.ceil('H')
|
DatetimeIndex(['2018-01-01 12:00:00', '2018-01-01 12:00:00',
|
'2018-01-01 13:00:00'],
|
dtype='datetime64[ns]', freq=None)
|
|
**Series**
|
|
>>> pd.Series(rng).dt.ceil("H")
|
0 2018-01-01 12:00:00
|
1 2018-01-01 12:00:00
|
2 2018-01-01 13:00:00
|
dtype: datetime64[ns]
|
|
When rounding near a daylight savings time transition, use ``ambiguous`` or
|
``nonexistent`` to control how the timestamp should be re-localized.
|
|
>>> rng_tz = pd.DatetimeIndex(["2021-10-31 01:30:00"], tz="Europe/Amsterdam")
|
|
>>> rng_tz.ceil("H", ambiguous=False)
|
DatetimeIndex(['2021-10-31 02:00:00+01:00'],
|
dtype='datetime64[ns, Europe/Amsterdam]', freq=None)
|
|
>>> rng_tz.ceil("H", ambiguous=True)
|
DatetimeIndex(['2021-10-31 02:00:00+02:00'],
|
dtype='datetime64[ns, Europe/Amsterdam]', freq=None)
|
Ú TimelikeOpsTr* c s° e Zd ZU dZded< dejdfdddd d
|
Zed d Z e
|
d d Z e j ddddZ edd Z edddddZeddddZeddd d Zd dd d d d!Zd"d# Zd$dd% fd&d' Zd(d) Zeee jd*d+dGd-d.d/d0d1Zeee jd2d+dHd-d.d/d3d4Z eee jd5d+dId-d.d/d6d7Z dd8d9d:ddd;d<d=Z dd8d9d:ddd;d>d?Z ddd@dAZ!dBdC Z"dJdddD fdEdF Z# Z$S )Kr* zK
|
Common ops for TimedeltaIndex/DatetimeIndex, but not PeriodIndex.
|
znp.dtypeÚ_default_dtypeNFr r )r rp c C sä t |dd}t|tr$|jdtd}t|dd }|d k}|tjk rF|nd }t|t| rÒ|r^n4|d krn|j }n$|r|j rt
|
|}t ||j d\}}|d k rÄt |}t ||jsÄtd| d|j |j}|j}n0|d krt|tjrü|jjd krü|j}n| j}t|tjs2td
|
t|j d t| j d |jd krFtd|jdkr^| | j¡}| ||¡}|dkrtdt| j d|r| ¡ }|r¦t
|
|}tj | ||d || _ |d krà|d k ràt| | |¡ d S )NTr÷ rÓ ©Zna_valuer¾ Fzdtype=z does not match data dtype ZMmzUnexpected type 'z'. 'values' must be a z6, ndarray, or Series or Index containing one of those.)r é z.Only 1-dimensional input arrays are supported.rq Úinferz#Frequency inference not allowed in z$.__init__. Use 'pd.array()' instead.)r rr ) rb rt r_ Úto_numpyr rð r Ú
|
no_defaultrÕ r r# Úvalidate_inferred_freqrL rD rr rÔ r
r² ry rÍ r rî rÖ r¤ rs Ú_validate_dtyper r r r¾ Ú_validate_frequency)rx r rr r r r Z explicit_noneÚ_r~ r~ r r s^
|
|
ÿ
|
ÿ
|
ÿzTimelikeOps.__init__c C s t | d S r r )rÚ r rr r~ r~ r r§ L s zTimelikeOps._validate_dtypec C s | j S )zK
|
Return the frequency object if it is set, otherwise None.
|
©r¾ r r~ r~ r r P s zTimelikeOps.freqr c C s8 |d k r.t |}| | |¡ | jdkr.td|| _d S )Nr z Cannot set freq with ndim > 1)r# r¨ r¤ rî r¾ r r~ r~ r r W s
|
c
|
K s¬ |j }|jdks||jkr dS z>| jf |d dt|||jd|}t |j|j¡sZt W nJ t k
|
r¦ } z,dt
|
|kr~|t d| d|j |W 5 d}~X Y nX dS )am
|
Validate that a frequency is compatible with the values of a given
|
Datetime Array/Index or Timedelta Array/Index
|
|
Parameters
|
----------
|
index : DatetimeIndex or TimedeltaIndex
|
The index on which to determine if the given frequency is valid
|
freq : DateOffset
|
The frequency to validate
|
r N)ÚstartÚendÚperiodsr r z non-fixedúInferred frequency ú9 from passed values does not conform to passed frequency ) r r$ r Ú_generate_ranger¦ r r² Z array_equalr§ rî r )rÚ Úindexr rz r Zon_freqrñ r~ r~ r r¨ b s. ûú ÿýz TimelikeOps._validate_frequencyrÙ rl )rÚ rp c O s t | d S r r )rÚ r« r¬ r r ry rz r~ r~ r r° s zTimelikeOps._generate_rangeÚintc C s t | jjS r )r r
rr r r~ r~ r rÎ s zTimelikeOps._cresor c C s
|
t | jS r )Ú dtype_to_unitrr r r~ r~ r r s zTimelikeOps.unitr )rx r rp c C s~ |dkrt dt | jj d| d¡}t| j|dd}t| jtjrP|j}ntd| j}t ||d}t
|
| j ||| j d S )
|
N)ÚsÚmsÚusÚnsz)Supported units are 's', 'ms', 'us', 'ns'z8[rB Tr' ri rD rE ) rî r² rr rÍ r r
rt r rÊ rM rÕ rH r )rx r rr r_ Z new_dtyperÊ r~ r~ r r s ÿzTimelikeOps.as_unitc C s: | j |j kr2| j |j k r&| |j¡} n | | j¡}| |fS r )rÎ r r r r~ r~ r rI µ s
|
z"TimelikeOps._ensure_matching_resosznp.ufunc)ÚufuncÚmethodc sV |t jt jt jfkr@t|dkr@|d | kr@t||| jf|S t j||f||S )Nr r ) r² ÚisnanÚisinfÚisfiniter¦ rð r
r» Ú__array_ufunc__)rx r¸ r¹ Úinputsrz r¿ r~ r r½ À s ÿ
|
þ
|
ýzTimelikeOps.__array_ufunc__c C s´ t | jr@td| } | d ¡}| ||||¡}|j| j||dS | d¡}ttj|}t |}|j
|
t || j } | dkr|| S t ||| }
|
| j|
|
td}| | jj¡}| j|| jdS )Nri ©Ú ambiguousÚ nonexistentrq r ©r r± )rB rr r Z tz_localizeÚ_roundrÊ rs r² ry r# Únanosr rÎ r% r r r
rH ) rx r r rÀ rÁ Znaiver| r rZ rÄ Z result_i8r~ r~ r rÃ Ë s(
|
|
|
ÿ
|
zTimelikeOps._roundÚround)r+ Úraiser3 r4 r¿ c C s | |tj||¡S r )rà r$ ZNEAREST_HALF_EVEN©rx r rÀ rÁ r~ r~ r rÅ ã s zTimelikeOps.roundÚfloorc C s | |tj||¡S r )rà r$ Z MINUS_INFTYrÇ r~ r~ r rÈ ì s zTimelikeOps.floorÚceilc C s | |tj||¡S r )rà r$ Z
|
PLUS_INFTYrÇ r~ r~ r rÉ õ s zTimelikeOps.ceilTr r )rÜ r rp c C s t j| j||| ¡ dS ©Nr )rT Znananyr
rR ©rx rÜ r r~ r~ r r s zTimelikeOps.anyc C s t j| j||| ¡ dS rÊ )rT Znanallr
rR rË r~ r~ r rå s zTimelikeOps.allc C s
|
d | _ d S r rª r r~ r~ r rÆ s z TimelikeOps._maybe_clear_freqc C sJ |dkr
|
n.t | dkr"t|tr"n|dks.tt| j}| ¡ }||_|S )z×
|
Helper to get a view on the same data, with a new freq.
|
|
Parameters
|
----------
|
freq : DateOffset, None, or "infer"
|
|
Returns
|
-------
|
Same type as self
|
Nr r£ )r¦ rt r rG r# r rs r¾ )rx r r{ r~ r~ r Ú
|
_with_freq s
|
zTimelikeOps._with_freq)Úuse_na_sentinelÚsortc sh | j d k rZtjt| tjd}| ¡ }|rR| j jdk rR|d d d
}|d d d
}||fS t j|dS )Nr± r râ )rÍ ) r r² Zaranger¦ Zintpr r¡ r» Ú factorize)rx rÍ rÎ ÚcodesZuniquesr¿ r~ r rÏ / s
|
zTimelikeOps.factorize)rÆ rÆ )rÆ rÆ )rÆ rÆ )TF)%rÖ r r r r r r¥ r r r§ r r Úsetterr¨ r° r< rÎ r r rI r½ rà r: Ú
|
_round_docÚ_round_exampler® rÅ Ú_floor_examplerÈ Ú _ceil_examplerÉ r rå rÆ rÌ rÏ r r~ r~ r¿ r r* ý sV
|
ÿH
|
|
|
|
* ü ü ü ! ýr r )r Úcls_namec C sê t | ds>t| ttfs.t | ¡dkr.t| } t | ¡} d}n(t| trZtd| dn t | dd} t| t
|
st| t r| j j dkr| jd td
|
} d}nHt| tjtfr´t| t rÀt | ¡} n"t| trâ| jj| jtd j} d}| |fS ) Nrr r FzCannot create a z from a MultiIndex.Tr÷ ÚiurÓ r¡ r )rù rt r³ Útupler² r¤ r× rP rÔ rb r_ r] rr rÍ r¤ r ry r^ rO rü ZtakerÐ r Z_values)r r rÖ r~ r~ r Ú!ensure_arraylike_for_datetimelikeD s0
|
|
|
|
ÿ
|
ÿ ÿ
|
rÙ r )r rp c C s d S r r~ ©r r~ r~ r Úvalidate_periodsf s rÛ z int | floatr² c C s d S r r~ rÚ r~ r~ r rÛ k s zint | float | Nonez
|
int | Nonec C sB | dk r>t | ¡r t| } nt | ¡s4td| tt| } | S )a9
|
If a `periods` argument is passed to the Datetime/Timedelta Array/Index
|
constructor, cast it to an integer.
|
|
Parameters
|
----------
|
periods : None, float, int
|
|
Returns
|
-------
|
periods : None or int
|
|
Raises
|
------
|
TypeError
|
if periods is None, float, or int
|
Nz periods must be a number, got )r Zis_floatr² rv rÔ r rÚ r~ r~ r rÛ p s
|
|
|
|
z tuple[BaseOffset | None, bool]r c C sF |dk r>| dk r.| |kr.t d| d| j | dkr:|} d}| |fS )aÅ
|
If the user passes a freq and another freq is inferred from passed data,
|
require that they match.
|
|
Parameters
|
----------
|
freq : DateOffset or None
|
inferred_freq : DateOffset or None
|
freq_infer : bool
|
|
Returns
|
-------
|
freq : DateOffset or None
|
freq_infer : bool
|
|
Notes
|
-----
|
We assume at this point that `maybe_infer_freq` has been called, so
|
`freq` is either a DateOffset object or None.
|
Nr® r¯ F)rî r )r r Ú
|
freq_inferr~ r~ r r¦ s ÿr¦ c C s0 d}t | ts(| dkr t| } nd}d} | |fS )aÓ
|
Comparing a DateOffset to the string "infer" raises, so we need to
|
be careful about comparisons. Make a dummy variable `freq_infer` to
|
signify the case where the given freq is "infer" and set freq to None
|
to avoid comparison trouble later on.
|
|
Parameters
|
----------
|
freq : {DateOffset, None, str}
|
|
Returns
|
-------
|
freq : {DateOffset, None}
|
freq_infer : bool
|
Whether we should inherit the freq of passed data.
|
Fr£ TN)rt r r# )r rÜ r~ r~ r Úmaybe_infer_freq° s
|
|
rÝ zDatetimeTZDtype | np.dtyper° c C s t | tr| jS t | ¡d S )zç
|
Return the unit str corresponding to the dtype's resolution.
|
|
Parameters
|
----------
|
dtype : DatetimeTZDtype or np.dtype
|
If np.dtype, we assume it is a datetime64 dtype.
|
|
Returns
|
-------
|
str
|
r )rt rM r r² Z datetime_datar± r~ r~ r r³ Ì s
|
r³ )¤Ú
|
__future__r r r Ú functoolsr r( Útypingr r r r r
|
r r r r r r rm Únumpyr² Z pandas._libsr r Zpandas._libs.arraysr Zpandas._libs.tslibsr r r r r r r r r r r r r r! r" r# Zpandas._libs.tslibs.fieldsr$ r% Z pandas._libs.tslibs.np_datetimer& Z pandas._libs.tslibs.timestampsr' Zpandas._typingr( r) r* r+ r, r- r. r/ r0 r1 r2 r3 r4 r5 Zpandas.compat.numpyr6 r Z pandas.errorsr7 r8 r9 Zpandas.util._decoratorsr: r; r< Zpandas.util._exceptionsr= Zpandas.core.dtypes.commonr> r? r@ rA rB rC rD rE rF rG rH rI rJ rK rL Zpandas.core.dtypes.dtypesrM rN Zpandas.core.dtypes.genericrO rP Zpandas.core.dtypes.missingrQ rR Z pandas.corerS rT rU Zpandas.core.algorithmsrV rW rX Zpandas.core.array_algosrY Zpandas.core.arraylikerZ Zpandas.core.arrays._mixinsr[ r\ Z pandas.core.arrays.arrow.arrayr] Zpandas.core.arrays.baser^ Zpandas.core.arrays.integerr_ Zpandas.core.commonÚcoreÚcommonrÄ Zpandas.core.constructionr` rû ra rb Zpandas.core.indexersrc rd Zpandas.core.ops.commonre Zpandas.core.ops.invalidrf rg Zpandas.tseriesrh rF ri rj rk r rl r rm r rÒ rÓ rÔ rÕ r r* rÙ rÛ r¦ rÝ r³ r~ r~ r~ r Ú<module> s 4 H @ D ~:? I"%
|
