ujWddlmZddlmZddlZddlmZmZmZm Z m Z m Z ddl Z ddl ZddlmZmZddlmZddlmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z$m%Z%ddl&m'Z'dd l(m)Z)m*Z*dd l+m,Z,m-Z-dd l.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4dd l5m6Z6dd l7m8Z8m9Z9ddl:m;Z;ddlZ>ddl?m@Z@mAZAddlBmCZCmDZDmEZEmFZFddlGmHZHddlImJZJmKZLddlMmNcmOZPddlQmRZRer*ddlSmTZTmUZUddlVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^ddl?m_Z_ddlIm`Z`maZae deZbd'd(dZce9dGddeLje$jZfd)dZg d' d*d Zh d+d!Zi d' d,d"Zd-d.d#Zj d/ d0d$Zkd1d%Zld2d&Zmy)3) annotations) timedeltaN) TYPE_CHECKINGAnyLiteralSelfTypeVarcast)algoslib) NDArrayBacked) BaseOffsetDayNaTNaTType Resolution Timedeltaadd_overflowsafeastype_overflowsafedt64arr_to_periodarrget_unit_from_dtypeiNaTparsingperiod to_offset) MONTH_NUMBERS) FreqGroupPeriodDtypeBase)Tick delta_to_tick)DIFFERENT_FREQINT_TO_PERIOD_DEPR_MSGIncompatibleFrequencyPeriodget_period_field_arrperiod_asfreq_arr)Pandas4Warning)cache_readonly set_module)find_stack_level) ensure_object pandas_dtype)DatetimeTZDtype PeriodDtype)ABCIndexABCPeriodIndex ABCSeriesABCTimedeltaArray)isna)ExtensionArray datetimelike) extract_array)CallableSequence) AnyArrayLikeDtypeDtypeObj FillnaOptionsNpDtype NumpySorterNumpyValueArrayLikenpt)ExtensionDtype) DatetimeArrayTimedeltaArray BaseOffsetT)boundc@fd}|_||_t|S)Ncb|jj}t|j|}|SN)dtype _dtype_coder%asi8)selfbaseresultnames d/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/pandas/core/arrays/period.pyfz_field_accessor..frs)zz%%%dDIIt< )__name____doc__property)rO docstringrQs` rP_field_accessorrWqs" AJAI A;rRz pandas.arraysc>eZdZUdZdZdZejeZ e fZ dZ de d<edZdZgZde d <d gZde d <gd Zde d <gdZde d<eezezZde d<gdZde d<de d<d[d\dZe d]dZeddd d^dZedd d_dZed`dadZedZedbdZ dcd Zddd!Z ded"Z e!dfd#Z"edgd$Z#edhd%Z$edid&Z% dj dkd'Z&d`d(Z'e(d)d*Z)e(d+d,Z*e(d-d.Z+e(d/d0Z,e(d1d2Z-e(d3d4Z.e(d5d6Z/e/Z0e(d7d8Z1ed9Z2ed:Z3e(d;d<Z4ed=Z5e(d>d?Z6e(d@dAZ7e(dBdCZ8edDZ9edldEZ:dmdndFZ; dodGZdsdtdJZ?dKddL dudMZ@dvdwfdO ZA dx dydPZBdddNdQ dzdRZC d{dSZDd|dTZEfdUZF d}dVZGdWZHdNddX d~fdYZIxZJS) PeriodArraya^ Pandas ExtensionArray for storing Period data. Users should use :func:`~pandas.array` to create new instances. Parameters ---------- values : Union[PeriodArray, Series[period], ndarray[int], PeriodIndex] The data to store. These should be arrays that can be directly converted to ordinals without inference or copy (PeriodArray, ndarray[int64]), or a box around such an array (Series[period], PeriodIndex). dtype : PeriodDtype, optional A PeriodDtype instance from which to extract a `freq`. If both `freq` and `dtype` are specified, then the frequencies must match. copy : bool, default False Whether to copy the ordinals before storing. Attributes ---------- None Methods ------- None See Also -------- Period: Represents a period of time. PeriodIndex : Immutable Index for period data. period_range: Create a fixed-frequency PeriodArray. array: Construct a pandas array. Notes ----- There are two components to a PeriodArray - ordinals : integer ndarray - freq : pd.tseries.offsets.Offset The values are physically stored as a 1-D ndarray of integers. These are called "ordinals" and represent some kind of offset from a base. The `freq` indicates the span covered by each element of the array. All elements in the PeriodArray have the same `freq`. Examples -------- >>> pd.arrays.PeriodArray(pd.PeriodIndex(["2023-01-01", "2023-01-02"], freq="D")) ['2023-01-01', '2023-01-02'] Length: 2, dtype: period[D] i periodarrayc"t|tSrH) isinstancer.)xs rPzPeriodArray.s ;BrRzCallable[[DtypeObj], bool]_is_recognized_dtypectSrH)r$rLs rP _scalar_typezPeriodArray._scalar_types rRz list[str] _other_ops is_leap_year _bool_ops) start_timeend_timefreq _object_ops) yearmonthdayhourminutesecond weekofyearweek day_of_week day_of_yearquarterqyear days_in_month _field_ops_datetimelike_ops)strftime to_timestampasfreq_datetimelike_methodsr._dtypeNFcx|*t|}t|tstd|dt|tr,|j }t|t |s'tdt|tr |j }t|t |r?|%||jk7rt||j|j|j}}|stj|d}ntj|d|}| tdt!d|}t#j$|||y) NzInvalid dtype z for PeriodArrayzIncorrect dtypeint64rIrIcopyz-dtype is not specified and cannot be inferredr.)r,r\r. ValueErrorr1_valuestype TypeErrorr0rIraise_on_incompatiblerh_ndarraynpasarrayarrayr r __init__)rLvaluesrIrs rPrzPeriodArray.__init__s   'Ee[1 >%8H!IJJ fi (^^Ffd4j1 122  /^^F fd4j ) Ufll%:+FEJJ??"OOV\\EFZZg6FXXfG$?F =LM M]E*tVU3rRczd}t|tjr|jdk(sJ||||S)Nz Should be numpy array of type i8i8r)r\rndarrayrI)clsrrI assertion_msgs rP _simple_newzPeriodArray._simple_news:; &"**-&,,$2FU UF6''rRrc | t|}t|dd}tj|dr"| |jnd}|j ||St |d}t||r)||j||S|r|jS|St|tjttttt fs t|}t|t r3|j"j$dvr|j't(t*}tj,|}|j"j$dk(r_|j.rS|j1tj2tj4j0kDr|jt(}|j"j$d k(rlt7|d kDr^tj8|s t;d tj<|j>t@tj4 }||| S|j"j$dvritCjDtFtHtK |jtj4d}tMjN||}||| StQ|} | tMjR| } tU| }tMjV| |}||| S)NrIMT) extract_numpyriu)rIna_valueurQrz9PeriodArray does not allow floating point in constructionr stacklevelF),r,getattrr is_np_dtype_freq_from_datetime64r6r\astyperrrlisttupler1r/r4rIkindto_numpyobjectrrsizemaxiinforlenall_nansrfullshaperwarningswarnr"r'r* libperiodfrom_calendar_ordinalsr+extract_period_unitr.extract_ordinals) rscalarsrIr data_dtyperharrdataordinalsarrperiods dtype_bases rP_from_sequencezPeriodArray._from_sequencesX   'EWgt4 ??:s +"'"35;;D''6 6t< gs # ~~e$~77||~%N bjj$y(NS 7mG g~ .7==3E3E3M&&Vc&BG**W% MM  # %   2 6 66 nnV,G ==   $W)9<<(Owww}}d"((CHxu- - ]]  4 ' MM&+-  ...6C 77UCHxu- -#G,G}&::7C #J/ 11'5AHxu- -rRrc*|j|||S)Nr)r)rstringsrIrs rP_from_sequence_of_stringsz%PeriodArray._from_sequence_of_stringsSs!!'T!BBrRct|trt|j}t |||\}}t|}|||S)a Construct a PeriodArray from a datetime64 array Parameters ---------- data : ndarray[datetime64[ns], datetime64[ns, tz]] freq : str or Tick tz : tzinfo, optional Returns ------- PeriodArray[freq] r)r\rr._freqstrr)rdatarhtzrIs rPrzPeriodArray._from_datetime64YsG dJ 't$--D)$b9 dD!4u%%rRctj|}|tj|}||t ||||\}}||fSt d)Nz/Not enough parameters to construct Period range)dtlvalidate_periodsr$_maybe_convert_freq_get_ordinal_ranger)rstartendrrhsubarrs rP_generate_rangezPeriodArray._generate_rangens`&&w/  --d3D  -eS'4HLFDt|NO OrRc^tdd|i|\}}t|}|j||S)Nrhr)_range_from_fieldsr.r)rfieldsrhrrIs rP _from_fieldszPeriodArray._from_fields|s5)>t>v> D!vU33rRc|turtj|jSt ||j r0|j |tj|jStd|d)Nz!'value' should be a Period. Got 'z ' instead.) rrr_valuer\rb_check_compatible_withordinalrrLvalues rP _unbox_scalarzPeriodArray._unbox_scalarsd C<88ELL) ) t00 1  ' ' .88EMM* *@zRS SrRc0t||jS)N)rh)r$rhrs rP_scalar_from_stringzPeriodArray._scalar_from_stringse$)),,rRc|turyt|tr&|j|jj y|j|j j yrH)rr\r$_require_matching_unitr}rrIrLothers rPrz"PeriodArray._check_compatible_withsJ C<  v &  ' ' (=(= >  ' ' (<(< =rRc|jSrH)r}ras rPrIzPeriodArray.dtypes {{rRc.|jjS)zC Return the frequency object for this PeriodArray. )rIrhras rPrhzPeriodArray.freqs zzrRc@t|jjSrH)r.rhrras rPfreqstrzPeriodArray.freqstrs499%...rRcd|j} tj|S#t$rYywxYwrH)rrget_reso_from_freqstrKeyError)rLrs rP_resolution_objzPeriodArray._resolution_objs3,, 33G< <  s # //c|dk(rs|sPtj|j|}|jr!|j }d|j _|Stj|j|S|dur td|tk(r |jStjt|tS)NrrFz:Unable to avoid copy while creating an array as requested.) rrrK _readonlyviewflags writeablerrbool_isnanrr)rLrIrrNs rP __array__zPeriodArray.__array__s D=DIIU;>>#[[]F-2FLL* xx 77 5=L  D=KK< xxT &11rRcddl}ddlm}||jj |r,|j |j |j|St||r?|j|jk7r5td|jd|jdtd|d ||j}|j |j |jd }|jj||S) z6 Convert myself into a pyarrow Array. rN)ArrowPeriodType)maskrzENot supported to convert PeriodArray to array with different 'freq' (z vs )z)Not supported to convert PeriodArray to 'z' typer)pyarrow(pandas.core.arrays.arrow.extension_typesrtypes is_integerrrr3r\rrhrr4 from_storage)rLrrr period_type storage_arrays rP__arrow_array__zPeriodArray.__arrow_array__s L  }}''-}}T]]4}PPD/2<<499,###'<<.TYYKqB  ?vVL&dll3  dmm$))+G T %%22; NNrRrja The year of the period. Returns the year component for each period in the index. See Also -------- PeriodIndex.day_of_year : The ordinal day of the year. PeriodIndex.dayofyear : The ordinal day of the year. PeriodIndex.is_leap_year : Logical indicating if the date belongs to a leap year. PeriodIndex.weekofyear : The week ordinal of the year. PeriodIndex.year : The year of the period. Examples -------- >>> idx = pd.PeriodIndex(["2023", "2024", "2025"], freq="Y") >>> idx.year Index([2023, 2024, 2025], dtype='int64') rka The month as January=1, December=12. Returns the month component for each period in the index as an integer, where January is 1 and December is 12. See Also -------- PeriodIndex.days_in_month : The number of days in the month. PeriodIndex.daysinmonth : The number of days in the month. Examples -------- >>> idx = pd.PeriodIndex(["2023-01", "2023-02", "2023-03"], freq="M") >>> idx.month Index([1, 2, 3], dtype='int64') rla( The days of the period. Returns the day-of-month component for each period in the index. See Also -------- PeriodIndex.day_of_week : The day of the week with Monday=0, Sunday=6. PeriodIndex.day_of_year : The ordinal day of the year. PeriodIndex.dayofweek : The day of the week with Monday=0, Sunday=6. PeriodIndex.dayofyear : The ordinal day of the year. PeriodIndex.days_in_month : The number of days in the month. PeriodIndex.daysinmonth : The number of days in the month. PeriodIndex.weekday : The day of the week with Monday=0, Sunday=6. Examples -------- >>> idx = pd.PeriodIndex(['2020-01-31', '2020-02-28'], freq='D') >>> idx.day Index([31, 28], dtype='int64') rma The hour of the period. Returns the hour component for each period in the index. See Also -------- PeriodIndex.minute : The minute of the period. PeriodIndex.second : The second of the period. PeriodIndex.to_timestamp : Cast to DatetimeArray/Index. Examples -------- >>> idx = pd.PeriodIndex(["2023-01-01 10:00", "2023-01-01 11:00"], freq='h') >>> idx.hour Index([10, 11], dtype='int64') rna The minute of the period. Returns the minute component for each period in the index. See Also -------- PeriodIndex.hour : The hour of the period. PeriodIndex.second : The second of the period. PeriodIndex.to_timestamp : Cast to DatetimeArray/Index. Examples -------- >>> idx = pd.PeriodIndex(["2023-01-01 10:30:00", ... "2023-01-01 11:50:00"], freq='min') >>> idx.minute Index([30, 50], dtype='int64') roa The second of the period. Returns the second component for each period in the index. See Also -------- PeriodIndex.hour : The hour of the period. PeriodIndex.minute : The minute of the period. PeriodIndex.to_timestamp : Cast to DatetimeArray/Index. Examples -------- >>> idx = pd.PeriodIndex(["2023-01-01 10:00:30", ... "2023-01-01 10:00:31"], freq='s') >>> idx.second Index([30, 31], dtype='int64') rqa The week ordinal of the year. Returns the week number (1 through 53) for each period in the index. See Also -------- PeriodIndex.day_of_week : The day of the week with Monday=0, Sunday=6. PeriodIndex.dayofweek : The day of the week with Monday=0, Sunday=6. PeriodIndex.week : The week ordinal of the year. PeriodIndex.weekday : The day of the week with Monday=0, Sunday=6. PeriodIndex.year : The year of the period. Examples -------- >>> idx = pd.PeriodIndex(["2023-01", "2023-02", "2023-03"], freq="M") >>> idx.week # It can be written `weekofyear` Index([5, 9, 13], dtype='int64') rra The day of the week with Monday=0, Sunday=6. Returns the day-of-week component for each period, following the Python convention where Monday is 0 and Sunday is 6. See Also -------- PeriodIndex.day : The days of the period. PeriodIndex.day_of_week : The day of the week with Monday=0, Sunday=6. PeriodIndex.day_of_year : The ordinal day of the year. PeriodIndex.dayofweek : The day of the week with Monday=0, Sunday=6. PeriodIndex.dayofyear : The ordinal day of the year. PeriodIndex.week : The week ordinal of the year. PeriodIndex.weekday : The day of the week with Monday=0, Sunday=6. PeriodIndex.weekofyear : The week ordinal of the year. Examples -------- >>> idx = pd.PeriodIndex(["2023-01-01", "2023-01-02", "2023-01-03"], freq="D") >>> idx.day_of_week Index([6, 0, 1], dtype='int64') cbtjdtt|jS) The day of the week with Monday=0, Sunday=6. .. deprecated:: 3.1.0 Use :attr:`PeriodArray.day_of_week` instead. zoPeriodArray.weekday is deprecated and will be removed in a future version. Use PeriodArray.day_of_week instead.rrrr'r*rrras rPweekdayzPeriodArray.weekdays-   H ')  rRcbtjdtt|jS)rzqPeriodArray.dayofweek is deprecated and will be removed in a future version. Use PeriodArray.day_of_week instead.rrras rP dayofweekzPeriodArray.dayofweek-   C ')  rRrsa} The ordinal day of the year. Returns the day-of-year component for each period, ranging from 1 (January 1st) to 365 or 366 for leap years. See Also -------- PeriodIndex.day : The days of the period. PeriodIndex.day_of_week : The day of the week with Monday=0, Sunday=6. PeriodIndex.day_of_year : The ordinal day of the year. PeriodIndex.dayofweek : The day of the week with Monday=0, Sunday=6. PeriodIndex.dayofyear : The ordinal day of the year. PeriodIndex.weekday : The day of the week with Monday=0, Sunday=6. PeriodIndex.weekofyear : The week ordinal of the year. PeriodIndex.year : The year of the period. Examples -------- >>> idx = pd.PeriodIndex(["2023-01-10", "2023-02-01", "2023-03-01"], freq="D") >>> idx.day_of_year Index([10, 32, 60], dtype='int64') >>> idx = pd.PeriodIndex(["2023", "2024", "2025"], freq="Y") >>> idx PeriodIndex(['2023', '2024', '2025'], dtype='period[Y-DEC]') >>> idx.day_of_year Index([365, 366, 365], dtype='int64') cbtjdtt|jS)z The ordinal day of the year. .. deprecated:: 3.1.0 Use :attr:`PeriodArray.day_of_year` instead. zqPeriodArray.dayofyear is deprecated and will be removed in a future version. Use PeriodArray.day_of_year instead.r)rrr'r*rsras rP dayofyearzPeriodArray.dayofyearrrRrta The quarter of the date. Returns the quarter (1 through 4) for each period in the index. See Also -------- PeriodIndex.qyear : Fiscal year the Period lies in according to its starting-quarter. Examples -------- >>> idx = pd.PeriodIndex(["2023-01", "2023-02", "2023-03"], freq="M") >>> idx.quarter Index([1, 1, 1], dtype='int64') rua Fiscal year the Period lies in according to its starting-quarter. The `year` and the `qyear` of the period will be the same if the fiscal and calendar years are the same. When they are not, the fiscal year can be different from the calendar year of the period. Returns ------- int The fiscal year of the period. See Also -------- PeriodIndex.quarter : The quarter of the date. PeriodIndex.year : The year of the period. Examples -------- If the natural and fiscal year are the same, `qyear` and `year` will be the same. >>> per = pd.Period('2018Q1', freq='Q') >>> per.qyear 2018 >>> per.year 2018 If the fiscal year starts in April (`Q-MAR`), the first quarter of 2018 will start in April 2017. `year` will then be 2017, but `qyear` will be the fiscal year, 2018. >>> per = pd.Period('2018Q1', freq='Q-MAR') >>> per.start_time Timestamp('2017-04-01 00:00:00') >>> per.qyear 2018 >>> per.year 2017 rva  The number of days in the month. Returns the total number of days in the month of each period, accounting for leap years. See Also -------- PeriodIndex.day : The days of the period. PeriodIndex.days_in_month : The number of days in the month. PeriodIndex.daysinmonth : The number of days in the month. PeriodIndex.month : The month as January=1, December=12. Examples -------- For Series: >>> period = pd.period_range('2020-1-1 00:00', '2020-3-1 00:00', freq='M') >>> s = pd.Series(period) >>> s 0 2020-01 1 2020-02 2 2020-03 dtype: period[M] >>> s.dt.days_in_month 0 31 1 29 2 31 dtype: int64 For PeriodIndex: >>> idx = pd.PeriodIndex(["2023-01", "2023-02", "2023-03"], freq="M") >>> idx.days_in_month # It can be also entered as `daysinmonth` Index([31, 28, 31], dtype='int64') cbtjdtt|jS)z The number of days in the month. .. deprecated:: 3.1.0 Use :attr:`PeriodArray.days_in_month` instead. zuPeriodArray.daysinmonth is deprecated and will be removed in a future version. Use PeriodArray.days_in_month instead.r)rrr'r*rvras rP daysinmonthzPeriodArray.daysinmonthfs-   E ')  !!!rRcttj|j}|dzdk(|dzdk(|dzdkDzzS)a Logical indicating if the date belongs to a leap year. Returns a boolean array where ``True`` indicates the period's year is a leap year. See Also -------- PeriodIndex.qyear : Fiscal year the Period lies in according to its starting-quarter. PeriodIndex.year : The year of the period. Examples -------- >>> idx = pd.PeriodIndex(["2023", "2024", "2025"], freq="Y") >>> idx.is_leap_year array([False, True, False]) ird)rrrj)rLrjs rPrdzPeriodArray.is_leap_yearvs>*zz$))$s aTAX]tczA~$FGGrRcddlm}tj|}|dk(}|r|t j |}|duxr|j dk(}|dk(s|jdk(rB|jd}|rdn |j}td d td | z }||zS||jzjd}|rdn |j}|td | z S|5|jj} t| d } | j}| } n!t j |}|j} |j!||} tj"| j$| } |j&| | j( }|S) aN Cast to DatetimeArray/Index. If possible, gives microsecond-unit DatetimeArray/Index. Otherwise gives nanosecond unit. On the ``Series.dt`` accessor, this is only available for period-typed Series. Parameters ---------- freq : str or DateOffset, optional Target frequency. The default is 'D' for week or longer, 's' otherwise. how : {'start', 'end', 's', 'e'}, default 'start' Whether to use the start or end of the time period being converted. Case-insensitive. Returns ------- DatetimeArray/Index Timestamp representation of given Period-like object. See Also -------- PeriodIndex.day : The days of the period. PeriodIndex.from_fields : Construct a PeriodIndex from fields (year, month, day, etc.). PeriodIndex.from_ordinals : Construct a PeriodIndex from ordinals. PeriodIndex.hour : The hour of the period. PeriodIndex.minute : The minute of the period. PeriodIndex.month : The month as January=1, December=12. PeriodIndex.second : The second of the period. PeriodIndex.year : The year of the period. Examples -------- >>> idx = pd.PeriodIndex(["2023-01", "2023-02", "2023-03"], freq="M") >>> idx.to_timestamp() DatetimeIndex(['2023-01-01', '2023-02-01', '2023-03-01'], dtype='datetime64[us]', freq='MS') The frequency will not be inferred if the index contains less than three elements, or if the values of index are not strictly monotonic: >>> idx = pd.PeriodIndex(["2023-01", "2023-02"], freq="M") >>> idx.to_timestamp() DatetimeIndex(['2023-01-01', '2023-02-01'], dtype='datetime64[us]', freq=None) >>> idx = pd.PeriodIndex( ... ["2023-01", "2023-02", "2023-02", "2023-03"], freq="2M" ... ) >>> idx.to_timestamp() DatetimeIndex(['2023-01-01', '2023-02-01', '2023-02-01', '2023-03-01'], dtype='datetime64[us]', freq=None) r)rBENnsBr)howD)unitr)pandas.core.arraysrBrvalidate_end_aliasr$rrMrhrzrrr}_get_to_timestamp_baserr_period_dtype_coder{periodarr_to_dt64arrrKrrI)rLrhr rBr ns_targetstampradjust freq_coderIrMnew_parrnew_datadtas rPrzzPeriodArray.to_timestampstn 5**3/Sj 11$7D(>TYY$->Is{dii3.))g)6(tejj"13/)AD2IIv~% )77G7D(tejjy666 < ::>DD--d3D**D;;t;-11(--F+m**88>>J rRc4tj|}|dk(ry|jjdk(rst j |j }t|dk(rE|d}||jjk(r |jS|dk(r|jjSyt|j}|Ytj|}t|t r4t|t s$t#|t#|j$k(r|}|S)z Determine the freq to stamp on the DatetimeArray returned by ``self.to_timestamp(target_freq, how)``. Called by ``PeriodIndex.to_timestamp`` so the array-level ``to_timestamp`` can return a bare DatetimeArray. r Nr r rdays)rrrh rule_codelibalgos unique_deltasrKrrI_nrMr_inferred_freq_strr$rr\rrn)rLr target_freqr diffsdiff result_freqs rP_to_timestamp_freqzPeriodArray._to_timestamp_freqs**3/ #: 99  # %**4995E5zQQx4::==(99$QY99>>) 6 67  " 44[AK;,";4k*i[]].KK) rRcDtj||jS)N)rrI)r$ _from_ordinalrI)rLr]s rP _box_funczPeriodArray._box_funcs##ATZZ@@rRctj|}t|tr!t |drt |j }tj|}|jj}|j}|j}|dk(}|r||jjzdz }n|}t||||}|j rt"||j$<t |} t'||| S)aY Convert the PeriodArray to the specified frequency `freq`. Equivalent to applying :meth:`pandas.Period.asfreq` with the given arguments to each :class:`~pandas.Period` in this PeriodArray. Parameters ---------- freq : str A frequency. how : {'end', 'start', 'e', 's'}, default 'end' Whether the elements should be aligned to the end or start of each period, e.g. January 31st vs. January 1st. Case-insensitive. Returns ------- PeriodArray The transformed PeriodArray with the new frequency. See Also -------- PeriodIndex.asfreq: Convert each Period in a PeriodIndex to the given frequency. Period.asfreq : Convert a :class:`~pandas.Period` object to the given frequency. Examples -------- >>> pidx = pd.period_range("2010-01-01", "2015-01-01", freq="Y") >>> pidx PeriodIndex(['2010', '2011', '2012', '2013', '2014', '2015'], dtype='period[Y-DEC]') >>> pidx.asfreq("M") PeriodIndex(['2010-12', '2011-12', '2012-12', '2013-12', '2014-12', '2015-12'], dtype='period[M]') >>> pidx.asfreq("M", how="S") PeriodIndex(['2010-01', '2011-01', '2012-01', '2013-01', '2014-01', '2015-01'], dtype='period[M]') rr r r)rrr\rhasattrr.rr$rr}rJrrKrIr"r&_hasnarrr) rLrhr base1base2rKrrrrIs rPr{zPeriodArray.asfreqsP**3/ dJ 'GD:N,Ot$--D))$/ ''''yySj TZZ]]*Q.GG$WeUC@ ;;$(HT[[ !D!tDz(%00rRc*|rtSdjS)Nz'{}')strformat)rLboxeds rP _formatterzPeriodArray._formatter]s J}}rRr)na_rep date_formatc ntj|j|jj||S)z3 actually format my specific types )rperiod_array_strftimerKrIrJ)rLr7r8kwargss rP_format_native_typesz PeriodArray._format_native_typesbs. .. IItzz--v{  rRTct|}||jk(r|s|S|jSt|tr|j |j Stj|dst|trPt|dd}tj|}|jj|j|St |E||S)Nrrr)r,r}rr\r.r{rhr rr-rr dtype_to_unitrz tz_localizeas_unitsuperr)rLrIrrr __class__s rPrzPeriodArray.astypensU# DKK  yy{" e[ );;uzz* * ??5# &*UO*Ld+B$$U+D$$&2226>>tD Dw~e$~//rRc|j|jd}|jjd}|j|||S)NM8[ns])sidesorter)_validate_setitem_valuerr searchsorted)rLrrErFnpvaluem8arrs rPrHzPeriodArray.searchsortedsM ..u5::8D ""8,!!'V!DDrR)limit limit_arearc|jd}|j||||}|r%td|j|jS|S)NrD)methodrKrLrr)r_pad_or_backfillr rI)rLrNrKrLrrrNs rPrOzPeriodArray._pad_or_backfillsTii!%%:D&   DJJ 78 8KrRc|tjtjfvsJ|tjur| }t|jt j |d}t|||jS)z Add or subtract array of integers. Parameters ---------- other : np.ndarray[int64] or int op : {operator.add, operator.sub} Returns ------- result : PeriodArray rr) operatoraddsubrrKrrrrI)rLrop res_valuess rP_addsub_int_array_or_scalarz'PeriodArray._addsub_int_array_or_scalarsdhllHLL1111  FE%diiE1NO tDz*DJJ77rRct|trJt|tr#|tj|j dzS|j |jd|j|j tjS)NrT)rM) r\rrr timedelta64r$r _period_unitrVrQrRrs rP _add_offsetzPeriodArray._add_offsetsjeT*** eS !"..#66 6 ##E$6$6T#B//FFrRct|jttfs t ||t |rt ||St|tr4tjt|jj}n(tjt|j}|j|S)z Parameters ---------- other : timedelta, Tick, np.timedelta64 Returns ------- PeriodArray r)r\rhrrrr3rA_add_timedeltalike_scalarrrrr$asm8_add_timedelta_arraylike)rLrtdrBs rPr\z%PeriodArray._add_timedeltalike_scalars$))dC[1'e4 4 ;74U; ; eS !I5773889BIe,112B,,R00rRc|jjstd|jtjd|jjd} t tj ||dd}t|jtj |jd}t|||j S#t$r}td|d}~wwxYw) z Parameters ---------- other : TimedeltaArray or ndarray[timedelta64] Returns ------- PeriodArray z2Cannot add or subtract timedelta64[ns] dtype from m8[]FrIrround_okznCannot add/subtract timedelta-like from PeriodArray that is not an integer multiple of the PeriodArray's freq.Nrr) rI _is_tick_likerr _td64_unitrrrr#rrKrr)rLrrIdeltaerrrUs rPr^z$PeriodArray._add_timedelta_arraylikeszz'')DTZZLQ 3tzz445Q78 ' 5!UUE&diiEJJt ?Ie,112BE"B >'%eeTE 4 $$U++  >'e4# = >s.C## C>, C99C>skipnakeepdimsc t||f||d|}|r7t|tjr|j ||j S|S)Nrlr)rA_reducer\rrrrI)rLrOrmrnr;rNrBs rPrpzPeriodArray._reduce+sNRfxR6R  62::6&&vTZZ&@ @ rR)returnz type[Period])NF)rI Dtype | NonerrrqNone)rznpt.NDArray[np.int64]rIr.rqr)rIrrrrrqr)rIrArrrqrrH)rqr)rzdict[str, Any]rqr)rPeriod | NaTTyperqznp.int64)rr3rqr$)rzPeriod | NaTType | PeriodArrayrqrs)rqr.)rqr)rqr3)rqr)NN)rIzNpDtype | Nonerz bool | Nonerq np.ndarray)rqznpt.NDArray[np.bool_])Nr)r r3rqrB)rrBr r3rqzBaseOffset | None)rqrt)Nr )r r3rqr)F)r5rrqzCallable[[object], str])r7z str | floatrqznpt.NDArray[np.object_])T)rr)leftN)rz$NumpyValueArrayLike | ExtensionArrayrEzLiteral['left', 'right']rFzNumpySorter | Nonerqznpt.NDArray[np.intp] | np.intp) rNr<rKz int | NonerLz#Literal['inside', 'outside'] | Nonerrrqr)rznp.ndarray | intrTzCallable[[Any, Any], Any]rqr)rr)rz,TimedeltaArray | npt.NDArray[np.timedelta64]rqr)rOr3rmrrnr)KrS __module__ __qualname__rT__array_priority___typrrr_internal_fill_valuer$_recognized_scalarsr___annotations__rUrbrcrerirwrxr|r classmethodrrrrrrrrrr(rIrhrrrrrWrjrkrlrmrnrorprqrrrrrsrrtrurvrrdrzr)r,r{r6r<rrHrOrVrZr\r^rkrp __classcell__)rBs@rPrYrY|s4n D#288D>!)84J *+Iy+?K?J $. #;i#GyG'M9M  4:(%((  (( # L. L.  L.  L.L.\=BC .C6:C CC &&(  44 T  T  T-> . > >( //AE2#22=2 24O<   D.   E(    C0   D( F* F*! J, D! K6      " KB     G& ' * EX$# &MP " "HH.\|' '47' 'VA>1F (-$ $  02*0%) E3 E' E# E ( E"!:>   8    ,8%8+D8 8*G10#8A#8 #8J#,R,0%$(;?rRrYcXt|tjtfs|d}nt|trOt j 5t jddtt|j}dddnFt|tttfr |j}ntt!|j}t|j"j}t%j&t)|j*|}t-|S#1swY^xYw)a> Helper function to render a consistent error message when raising IncompatibleFrequency. Parameters ---------- left : PeriodArray right : None, DateOffset, Period, ndarray, or timedelta-like Returns ------- IncompatibleFrequency Exception to be raised by the caller. NignorezPeriodDtype\[B\] is deprecated)category)rown_freq other_freq)r\rrr2rrcatch_warningsfilterwarnings FutureWarningr.rr0rYr$rr rrhr!r4rrSr#)rvrightrrmsgs rPrr4s %"**&789U] E: &  $ $ & 5  # #;m %U+44J  5 5 ENK@ A]] "9U#34<< 499%..H    J  (z C ! %% 5 5s 2D  D)c0tj||S)a Construct a new PeriodArray from a sequence of Period scalars. Parameters ---------- data : Sequence of Period objects A sequence of Period objects. These are required to all have the same ``freq.`` Missing values can be indicated by ``None`` or ``pandas.NaT``. dtype : PeriodDtype or None, default None The dtype for the array. If not specified, is inferred from the data. Returns ------- PeriodArray See Also -------- PeriodArray pandas.PeriodIndex Examples -------- >>> period_array([pd.Period("2017", freq="Y"), pd.Period("2018", freq="Y")]) ['2017', '2018'] Length: 2, dtype: period[Y-DEC] >>> period_array([pd.Period("2017", freq="Y"), pd.Period("2018", freq="Y"), pd.NaT]) ['2017', '2018', 'NaT'] Length: 3, dtype: period[Y-DEC] Datetime-like strings may also be passed >>> period_array( ... ["2000-Q1", "2000-Q2", "2000-Q3", "2000-Q4"], dtype=PeriodDtype("Q") ... ) ['2000Q1', '2000Q2', '2000Q3', '2000Q4'] Length: 4, dtype: period[Q-DEC] r)rYr)rrIs rP period_arrayr\s\  % %d% % 88rRc|/t|ts td|||k7r td|S|t|ts td|}|S)a If a dtype is specified both directly and indirectly via a `freq` (dtype2), ensure they match. If only the latter is available, return the indirect dtype. Parameters ---------- dtype : dtype dtype2 : PeriodDtype or None Dtype derived from a `freq` passed to the caller. Returns ------- PeriodDtype or None Raises ------ ValueError : non-period dtype IncompatibleFrequency : mismatch between dtype and freq zdtype must be PeriodDtypez&specified freq and dtype are different)r\r.rr#)rIdtype2s rPvalidate_dtype_freqrsg, %-89 9  %6/'(PQ Q L  &+.89 9 LrRct|jtjr|jjdk7rt d|j|t|t r|j |j}}n}t|trm|j j}|&tjdtt|}|j }n"t|t tfr |j }t|j}tj |}|j"}t%|j'd||||fS)a Convert a datetime-like array to values Period ordinals. Parameters ---------- data : Union[Series[datetime64[ns]], DatetimeIndex, ndarray[datetime64ns]] freq : Optional[Union[str, Tick]] Must match the `freq` on the `data` if `data` is a DatetimeIndex or Series. tz : Optional[tzinfo] Returns ------- ordinals : ndarray[int64] freq : Tick The frequency extracted from the Series or DatetimeIndex if that's used. rz Wrong dtype: zConstructing PeriodArray from a Series of datetime64 data will stop inferring the frequency in a future version. Pass `freq` explicitly instead.rr)reso)r\rIrrrr/rrhr1r#rrr'r*rr$rrc_dt64arr_to_periodarrr)rrhr inferred_freqrrMs rPrrs, djj"(( +tzz#/E= 566 | dH %tyy$D i (!LL;;M( 6#/1 %<.++D1#D%dFFK88 F1I & F1I & F1I & F1I & F1I & F1I &   T>rRctj|}|jjdk(r.tj|j r t d|jtjdS)NrQz#cannot convert float NaN to integerFr) rrrIrisnanrrrr)rs rPrrWs[ ZZ F ||CBHHV$4$8$8$:>?? === ..rRc d}|D]V}t|tttjt fs.|t ||k7r td|Lt |}X|Dcgc]W}t|tjttt frtj|ntj||Yc}Scc}w)NzMismatched Period array lengths) r\rrrrr1rrrrepeat)rrr]s rPrr`s F   a$rzz9= >!c!f&6 !BCC~Q     !bjj$yAB JJqM1f% &  s"ACrH)rOr3rVz str | None)rqr#)rz,Sequence[Period | str | None] | AnyArrayLikerIPeriodDtype | NonerqrY)rIDtypeObj | Nonerrrqr)rqz(tuple[npt.NDArray[np.int64], BaseOffset])r )rint)NNNNNNNN)rqztuple[np.ndarray, BaseOffset])rqru)rqzlist[np.ndarray])n __future__rdatetimerrQtypingrrrrr r rnumpyr pandas._libsr r r pandas._libs.arraysr pandas._libs.tslibsrrrrrrrrrrrrrrrrpandas._libs.tslibs.ccalendarrpandas._libs.tslibs.dtypesrrpandas._libs.tslibs.offsetsrr pandas._libs.tslibs.periodr!r"r#r$r%r& pandas.errorsr'pandas.util._decoratorsr(r)pandas.util._exceptionsr*pandas.core.dtypes.commonr+r,pandas.core.dtypes.dtypesr-r.pandas.core.dtypes.genericr/r0r1r2pandas.core.dtypes.missingr3rr4r5rpandas.core.commoncorecommonrpandas.core.constructionr6collections.abcr7r8pandas._typingr9r:r;r<r=r>r?r@rArBrCrDrW DatelikeOps PeriodMixinrYrrrrrrrrrRrPrs". 8)5 ,! 2   9 m:6  Ot#//9#8#8ttn%!&T!%.9 6.9 .9.9b! !$3!!J1N-1Nh.d      >#>B/rR