eh4ddlmZddlmZddlZddlmZmZmZm Z m Z m Z m Z ddl Z ddlZddlmZmZddlmZddlmZmZmZmZmZmZmZmZm Z m!Z!m"Z#m$Z$ddl%m&Z&m'Z'm(Z(dd l)m*Z*dd l+m,Z,m-Z-dd l.m/Z/m0Z0m1Z1m2Z2m3Z3dd l4m5Z5m6Z6dd l7m8Z8ddl9m:Z:m;Z;ddlZ>ddl?m@Z@mAZAmBZBmCZCddlDmEZEddlFmGZHddlImJcmKZLer(ddlMmNZNddlOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWddlFmXZXmYZYddlZm[Z[e deZ\ddiZ]d&d'dZ^GddeHje#jZad(dZb d) d*dZce d+dZde d,d Zd d-d!Zd d& d.d"Zd/d0d#Ze d1 d2d$Zfd3d%Zgy)4) annotations) timedeltaN) TYPE_CHECKINGAnyCallableLiteralTypeVarcastoverload)algoslib) NDArrayBacked) BaseOffsetNaTNaTType Timedeltaadd_overflowsafeastype_overflowsafedt64arr_to_periodarrget_unit_from_dtypeiNaTparsingperiod to_offset) FreqGroupPeriodDtypeBasefreq_to_period_freqstr)isleapyear_arr)Tick delta_to_tick)DIFFERENT_FREQIncompatibleFrequencyPeriodget_period_field_arrperiod_asfreq_arr)cache_readonlydoc)find_stack_level) ensure_object pandas_dtype)DatetimeTZDtype PeriodDtype)ABCIndexABCPeriodIndex ABCSeriesABCTimedeltaArray)isna) datetimelike)Sequence) AnyArrayLikeDtype FillnaOptionsNpDtype NumpySorterNumpyValueArrayLikeSelfnpt) DatetimeArrayTimedeltaArray)ExtensionArray BaseOffsetT)boundklass PeriodArrayc@fd}|_||_t|S)Ncb|jj}t|j|}|SN)dtype _dtype_coder$asi8)selfbaseresultnames W/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/pandas/core/arrays/period.pyfz_field_accessor..fms)zz%%%dDIIt< )__name____doc__property)rL docstringrNs` rM_field_accessorrTls" AJAI A;rOceZdZUdZdZdZejeZ e fZ dZ dZ edRdZgZded<d gZded <gd Zded <gd Zded<eezezZded<gdZded<ded< dS dTdZe dUdZeddd dVdZeddd dVdZedWdXdZedZedYdZ dZdZd[dZ d\d Z!e"d]d!Z#ed^d"Z$ed_d#Z% d` dad$Z&dWd%Z'e(d&d'Z)e(d(d)Z*e(d*d+Z+e(d,d-Z,e(d.d/Z-e(d0d1Z.e(d2d3Z/e/Z0e(d4d5Z1e1Z2e2Z3e(d6d7xZ4Z5e(d8d9Z6e(d:Z7e(d;d<Z8e8Z9edbd=Z:dcddd>Z;ded?Z<e=dfie>d@d@dAdgdhdBZ?didjdCZ@dDddE dkdFZAdldmfdH ZB dn dodIZCdddGdJ dpdKZD dq drfdL ZE dsdMZFdtdNZGfdOZH dudPZIdQZJxZKS)vrBa 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. freq : str or DateOffset The `freq` to use for the array. Mostly applicable when `values` is an ndarray of integers, when `freq` is required. When `values` is a PeriodArray (or box around), it's checked that ``values.freq`` matches `freq`. 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|tSrE) isinstancer,)xs rMzPeriodArray.sZ ;&rO)rctSrE)r#rIs rM _scalar_typezPeriodArray._scalar_types rOz list[str] _other_ops is_leap_year _bool_ops) start_timeend_timefreq _object_ops)yearmonthdayhourminutesecond weekofyearweekdayweek dayofweek day_of_week dayofyear day_of_yearquarterqyear days_in_month daysinmonth _field_ops_datetimelike_ops)strftime to_timestampasfreq_datetimelike_methodsr,_dtypeNFc|;tjdttt ||}t |}|*t |}t|t std|dt|tr,|j}t|t|s'tdt|tr |j}t|t|r?|%||jk7rt||j |j"|j}}|st%j&|d}nt%j(|d|}| td t+t |}t-j.|||y) Nz}The 'freq' keyword in the PeriodArray constructor is deprecated and will be removed in a future version. Pass 'dtype' instead) stacklevelzInvalid dtype z for PeriodArrayzIncorrect dtypeint64rFrFcopyz-dtype is not specified and cannot be inferred)warningswarn FutureWarningr(validate_dtype_freqr,r*rX ValueErrorr/_valuestype TypeErrorr.rFraise_on_incompatiblerc_ndarraynpasarrayarrayr r__init__)rIvaluesrFrcrs rMrzPeriodArray.__init__sA   MMP+-   'ud3D%E   'Ee[1 >%8H!IJJ fi (^^Ffd4j1 122  /^^F fd4j ) Ufll%:+FEJJ??"OOV\\EFZZg6FXXfG$?F =LM M[%(tVU3rOczd}t|tjr|jdk(sJ||||S)Nz Should be numpy array of type i8i8r)rXrndarrayrF)clsrrF assertion_msgs rM _simple_newzPeriodArray._simple_new s:; &"**-&,,$2FU UF6''rOrc| t|}|rt|tr |j}nd}t||r*t |j ||r|j }|Stj|t}|xstj|}tj||}t|}|||S)Nr) r*rXr,rcrrFrrrobject libperiod extract_freqextract_ordinals)rscalarsrFrrcperiodsordinalss rM_from_sequencezPeriodArray._from_sequences   'E Z{3::DD gs #  t 4!,,.N**WF36y--g6--gt<D!85))rOc*|j|||S)Nr)r)rstringsrFrs rM_from_sequence_of_stringsz%PeriodArray._from_sequence_of_strings4s!!'T!BBrOct|tr t|j|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)rXrrnrLrr,)rdatarctzrFs rM_from_datetime64zPeriodArray._from_datetime64:sK dJ ')$&&$))t>v> D!vU33rOc|turtj|jSt ||j r0|j |tj|jStd|d)Nz!'value' should be a Period. Got 'z ' instead.) rrr_valuerXr]_check_compatible_withordinalrrIvalues rM _unbox_scalarzPeriodArray._unbox_scalarisd C<88ELL) ) t00 1  ' ' .88EMM* *@zRS SrOc0t||jS)N)rc)r#rcrs rM_scalar_from_stringzPeriodArray._scalar_from_stringvse$)),,rOcL|tury|j|jyrE)r_require_matching_freqrcrIothers rMrz"PeriodArray._check_compatible_with|s C<  ##EJJ/rOc|jSrE)r|r\s rMrFzPeriodArray.dtypes {{rOc.|jjS)zC Return the frequency object for this PeriodArray. rFrcr\s rMrczPeriodArray.freqs zzrOcjt|jj|jjSrE)rrcrrLr\s rMfreqstrzPeriodArray.freqstrs%diikk499>>BBrOc|dk(r |jS|tk(r |jStjt |t S)Nrr)rHbool_isnanrrlistr)rIrFrs rM __array__zPeriodArray.__array__s? D=99  d]KK< xxT &11rOcddl}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_integerrrr1rXrrcrr> from_storage)rIrrr period_type storage_arrays rM__arrow_array__zPeriodArray.__arrow_array__s L  }}''-}}T]]4}PPD/2<<499,###'<<.TYYKqB  ?vVL&dll3  dmm$))+G T %%22; NNrOrez The year of the period. Examples -------- >>> idx = pd.PeriodIndex(["2023", "2024", "2025"], freq="Y") >>> idx.year Index([2023, 2024, 2025], dtype='int64') rfz The month as January=1, December=12. Examples -------- >>> idx = pd.PeriodIndex(["2023-01", "2023-02", "2023-03"], freq="M") >>> idx.month Index([1, 2, 3], dtype='int64') rgz The days of the period. Examples -------- >>> idx = pd.PeriodIndex(['2020-01-31', '2020-02-28'], freq='D') >>> idx.day Index([31, 28], dtype='int64') rhz The hour of the period. Examples -------- >>> idx = pd.PeriodIndex(["2023-01-01 10:00", "2023-01-01 11:00"], freq='h') >>> idx.hour Index([10, 11], dtype='int64') ria  The minute of the period. 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') rja  The second of the period. 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') rma The week ordinal of the year. 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') roz The day of the week with Monday=0, Sunday=6. Examples -------- >>> idx = pd.PeriodIndex(["2023-01-01", "2023-01-02", "2023-01-03"], freq="D") >>> idx.weekday Index([6, 0, 1], dtype='int64') rqa The ordinal day of the year. Examples -------- >>> idx = pd.PeriodIndex(["2023-01-10", "2023-02-01", "2023-03-01"], freq="D") >>> idx.dayofyear Index([10, 32, 60], dtype='int64') >>> idx = pd.PeriodIndex(["2023", "2024", "2025"], freq="Y") >>> idx PeriodIndex(['2023', '2024', '2025'], dtype='period[Y-DEC]') >>> idx.dayofyear Index([365, 366, 365], dtype='int64') rrz The quarter of the date. Examples -------- >>> idx = pd.PeriodIndex(["2023-01", "2023-02", "2023-03"], freq="M") >>> idx.quarter Index([1, 1, 1], dtype='int64') rsrta The number of days in the month. 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') cRttj|jS)z Logical indicating if the date belongs to a leap year. Examples -------- >>> idx = pd.PeriodIndex(["2023", "2024", "2025"], freq="Y") >>> idx.is_leap_year array([False, True, False]) )rrrrer\s rMr_zPeriodArray.is_leap_yearbsbjj344rOcddlm}tj|}|dk(}|rp|dk(s|jdk(r.t ddt ddz }|j d |zSt dd}||jzj d |z S|5|jj}t|d}|j}|}n!tj|}|j}|j|| } tj| j |} |j"| } |jj$dk(rt'j(|j } t+| dk(rQ| d} | |j,j.k(r|j| _| S| dk(r|jj2| _| S| j5d S) a Cast to DatetimeArray/Index. Parameters ---------- freq : str or DateOffset, optional Target frequency. The default is 'D' for week or longer, 's' otherwise. how : {'s', 'e', 'start', 'end'} Whether to use the start or end of the time period being converted. Returns ------- DatetimeArray/Index 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[ns]', freq='MS') r)r<EBDnsr)howinfer)pandas.core.arraysr<rvalidate_end_aliasrcrryr|_get_to_timestamp_baser_freqstrr#r_period_dtype_coderzperiodarr_to_dt64arrrHrrLlibalgos unique_deltaslenrF_n_freqrJ _with_freq)rIrcrr<radjust freq_coderFrJnew_parrnew_datadtadiffsdiffs rMryzPeriodArray.to_timestampos. 5**3/Sj s{dii3."1c*Yq$-??((W(5>>"1d+tyy(6676CfLL < ::>DD--d3D**D;;t;-11(--F*m**84 99>>S **4995E5zQQx4::==( $ CIJQY $ CIJ>>'* *rOcDtj||jS)N)rrc)r# _from_ordinalrc)rIrYs rM _box_funczPeriodArray._box_funcs##ADII>>rO PeriodIndex)r other_namectj|}t|tr!t |drt |j }tj|}|jj}|j}|j}|dk(}|r||jjzdz }n|}t||||}|j rt"||j$<t |} t'||| S)a Convert the {klass} to the specified frequency `freq`. Equivalent to applying :meth:`pandas.Period.asfreq` with the given arguments to each :class:`~pandas.Period` in this {klass}. Parameters ---------- freq : str A frequency. how : str {{'E', 'S'}}, default 'E' Whether the elements should be aligned to the end or start within pa period. * 'E', 'END', or 'FINISH' for end, * 'S', 'START', or 'BEGIN' for start. January 31st ('END') vs. January 1st ('START') for example. Returns ------- {klass} The transformed {klass} with the new frequency. See Also -------- {other}.asfreq: Convert each Period in a {other_name} 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]') rrrr)rrrXrhasattrr,rr#rr|rGrrHrFrr%_hasnarrr) rIrcrbase1base2rHrrrrFs rMrzzPeriodArray.asfreqs\**3/ dJ 'GD:N,Ot$--D))$/ ''''yySj TZZ]]*Q.GG$WeUC@ ;;$(HT[[ !D!tDz(%00rOc*|rtSdjS)Nz'{}')strformat)rIboxeds rM _formatterzPeriodArray._formatters J}}rOr)na_rep date_formatc ntj|j|jj||S)z3 actually format my specific types )rperiod_array_strftimerHrFrG)rIrrkwargss rM_format_native_typesz PeriodArray._format_native_typess. .. IItzz--v{  rOTct|}||jk(r|s|S|jSt|tr|j |j Stj|dst|trPt|dd}tj|}|jj|j|St |E||S)NMrr)r*r|rrXr,rzrcr is_np_dtyper+getattrr dtype_to_unitry tz_localizeas_unitsuperastype)rIrFrrunit __class__s rMrzPeriodArray.astypesU# DKK  yy{" e[ );;uzz* * ??5# &*UO*Ld+B$$U+D$$&2226>>tD Dw~e$~//rOc|j|jd}|jjd}|j|||S)NM8[ns])sidesorter)_validate_setitem_valueviewr searchsorted)rIrrrnpvaluem8arrs rMrzPeriodArray.searchsorted$sM ..u5::8D ""8,!!'V!DDrO)limit limit_arearc|jd}|j||||}|r%td|j|jS|S)Nr)methodr r!rr:)r_pad_or_backfillr rF)rIr#r r!rrrKs rMr$zPeriodArray._pad_or_backfill1sTii!%%:D&   DJJ 78 8KrOc|A|jd}|j||||}|j|jSt|||||S)Nr)rr#r r)rfillnarFr)rIrr#r rrrKrs rMr&zPeriodArray.fillnaDs]  ))H%CZZeF%dZSF;;tzz* *w~E&D~QQrOc|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) operatoraddsubrrHrrrrF)rIrop res_valuess rM_addsub_int_array_or_scalarz'PeriodArray._addsub_int_array_or_scalarTsdhllHLL1111  FE%diiE1NO tDz*DJJ77rOct|trJ|j|d|j|jt j S)NT)rJ)rXrrr-rr(r)rs rM _add_offsetzPeriodArray._add_offsetis@eT*** ##E#5//FFrOct|jts t||t |rt ||Stjt|j}|j|S)z Parameters ---------- other : timedelta, Tick, np.timedelta64 Returns ------- PeriodArray ) rXrcrrr1r_add_timedeltalike_scalarrrrasm8_add_timedelta_arraylike)rIrtdrs rMr1z%PeriodArray._add_timedeltalike_scalarpsa$))T*'e4 4 ;74U; ; ZZ %(-- .,,R00rOc|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[]FrFrround_okznCannot add/subtract timedelta-like from PeriodArray that is not an integer multiple of the PeriodArray's freq.Nrr) rF _is_tick_likerr _td64_unitrrrr"rrHrr)rIrrFdeltaerrr,s rMr3z$PeriodArray._add_timedelta_arraylikeszz'')DTZZLQ 3tzz445Q78 ' 5!UUE&diiEJJt ?Ie,112BE"B >'%eeTE 4 $$U++  >'e4# = >s.C## C>, C99C>)returnz type[Period])NNF)rF Dtype | NonerrrBNone)rznpt.NDArray[np.int64]rFr,rBr:)rFrCrrrBr:rE)rBr:)rdictrBr:)rPeriod | NaTTyperBznp.int64)rrrBr#)rzPeriod | NaTType | PeriodArrayrBrD)rBr,)rBr)rBr)NN)rFzNpDtype | Nonerz bool | NonerBz np.ndarray)rBznpt.NDArray[np.bool_])Nr)rrrBr<)rBrFr)Nr)rrrBr:)F)rr)rz str | floatrBznpt.NDArray[np.object_])T)rr)leftN)rz$NumpyValueArrayLike | ExtensionArrayrzLiteral['left', 'right']rzNumpySorter | NonerBznpt.NDArray[np.intp] | np.intp) r#r6r  int | Noner!z#Literal['inside', 'outside'] | NonerrrBr:)NNNT)r rHrrrBr:)rznp.ndarray | intr+zCallable[[Any, Any], Any]rBr:)rr)rz,TimedeltaArray | npt.NDArray[np.timedelta64]rBr:)LrP __module__ __qualname__rQ__array_priority___typrrr_internal_fill_valuer#_recognized_scalars_is_recognized_dtype_infer_matchesrRr]r^__annotations__r`rdrvrwr{r classmethodrrrrrrrrrr&rFrcrrrrTrerfrgrhrirjrkrmrornrlrprqrrrsrtrur_ryrr'_shared_doc_kwargsrzrr rrr$r&r-r/r1r3rA __classcell__)rs@rMrBrBys:z D#288D>!)!N J *+Iy+?K?J &$. #;i#GyG'M9M  KP'4)'4CG'4 '4T(%((  (( # * *  *  **6/3%C ,C;?C CC &&(  44 T T  T- 0 CCAE 2# 22= 2  2O<   D   E    C   D  F  F!  J D!  KIG- I $  G G $E# M: K  5 5@+H? M M]}MC1NC1P (-$ $  0.*0%) E3 E' E# E ( E"!:>   8    (OS R.8 RGK R  R 8%8+D8 8*G1*#8A#8 #8J#,rOct|tjtfs|d}nwt|tr!t |j |j}nFt|tttfr |j}ntt|j}t |jj |jj}tj t#|j$||}t'|S)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. N)rown_freq other_freq)rXrrr0rrrrLr.rBr#rr rrcr!rrrPr")rGrightrWrVmsgs rMrrs %"**&789U] E: &+EGGUZZ@ ENK@ A]] "9U#34<< %diikk499>>BH    J  (z C ! %%rOcNt|dd}tj|drtj ||St |t r1t|}|"||jk(r|S|j|S|St |tjtttfs t|}tj|}|r t |}nd}|jj dk(rt#|dkDr t%d|jj dvrD|j'tj(d }t+j,||}t|| St/|}|t+j0|}t |}tj3|| 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``. freq : str, Tick, or Offset The frequency of every element of the array. This can be specified to avoid inferring the `freq` from `data`. copy : bool, default False Whether to ensure a copy of the data is made. 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] Integers that look like years are handled >>> period_array([2000, 2001, 2002], freq='D') ['2000-01-01', '2001-01-01', '2002-01-01'] Length: 3, dtype: period[D] Datetime-like strings may also be passed >>> period_array(['2000-Q1', '2000-Q2', '2000-Q3', '2000-Q4'], freq='Q') ['2000Q1', '2000Q2', '2000Q3', '2000Q4'] Length: 4, dtype: period[Q-DEC] rFNr rNrz9PeriodIndex does not allow floating point in constructioniuFr r)rr rrBrrXr,rcrzrrrtupler/rrFkindrrrrr from_ordinalsr)rr) rrcr data_dtypeoutarrdatarFarrrs rM period_arrayrcshtw-J z3'++D$77*k*$  z& ::d# #  dRZZui@ ADzjjG D!}}S S\A%5STT}}T!nnRXXEn2**358511  !D |%%d+  E  % %d% % 88rOcyrErrs rMrrWrOcyrErrs rMrr\rerOc| t|d}|Pt|}t|ts t d||j }|S||j k7r t d|S)at If both a dtype and a freq are available, ensure they match. If only dtype is available, extract the implied freq. Parameters ---------- dtype : dtype freq : DateOffset or None Returns ------- freq : DateOffset Raises ------ ValueError : non-period dtype IncompatibleFrequency : mismatch between dtype and freq T is_periodzdtype must be PeriodDtypez&specified freq and dtype are different)rr*rXr,rrcr"rs rMrrasr* . U#%-89 9 <::D K UZZ '(PQ Q KrOcXt|jtjr|jjdk7rt d|j|\t|t r|j |j}}nUt|trE|j |jj}}n"t|t tfr |j }t|j}tj|}|j}t|jd||||fS)a Convert an 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. r z Wrong dtype: r)reso)rXrFrr]rr-rrcr/dtrr#rrc_dt64arr_to_periodarrr)rrcrrkrJs rMrrs, djj"(( +tzz#/E= 566 | dH %tyy$D i (tww||$D D8Y/ 0|| tzz *D  % %d +D  " "D !$))D/4$ G MMrOctj|||dk7r td|t|d}|j}| t ||}| t ||}t |t }t |t }|r&|r$|j|jk7r td|tus|tur td|5|r |j}n|r |j}n td|j}|||z}|Htj|j|z |z|jdz|tj }||fStj|j|j|z|tj }||fStj|j|jdz|tj }||fS) NzOOf the three parameters: start, end, and periods, exactly two must be specifiedTrhz!start and end must have same freqzstart and end must not be NaTz#Could not infer freq from start/endrr) comcount_not_nonerrrr#rXrcrrarangerr)rrrrcmult is_start_per is_end_perrs rMrrs %g.!3 ,   .vv ud# S$eV,LC(J uzzSXX'=<== |scz899 | ::D 88DBC CvvD. =99 g%,ckkAot288D : 99 u}}w6BHHD :yy aRXXN :rOc4|d}|d}|d}|d}g}||(tdd}tjj} nJt|d}t j |} | tjjk7r t d|j} t||\}}t||D]M\} } tj| | | \} }t j| |dddddd| }|j|Onrt|d}t j |} t||||||}t|D]5\} }}}}}|jt j| |||||dd| 7tj|tj |fS)NrrQTrhzbase must equal FR_QTRr)rrFR_QTRrrfreq_to_dtype_codeAssertionErrorr_make_field_arraysziprquarter_to_myearperiod_ordinalappendrrr)rerfrrrgrhrirjrcrrJryq calendar_yearcalendar_monthvalarraysmthdhmnss rMrrs | ~ ~ {H <SD1D##))DTT2D//5Dy''---$%=>>,,*49 gg& !DAq,3,D,DQ7,S )M>**~q!Q1aC OOC  !.++D1#D%dFFK#&< W AsAq"a OOI44QQ2q!QPTU V W 88HBHH -t 33rOc xd}|D]Q}t|ttjtfs)|t ||k7r t d|Gt |}S|Dcgc]R}t|tjttfrtj|ntj||Tc}Scc}w)NzMismatched Period array lengths) rXrrrr/rrrrepeat)rlengthrYs rMr{r{s F   a$ I6 7!c!f&6 !BCC~Q      a"**dI6 7 1 YYq& ! "  sAB7rE)rLrrSz str | None)rBr")NF)rz,Sequence[Period | str | None] | AnyArrayLikerczstr | Tick | BaseOffset | NonerrrBrB)rcr?rBr?)rcztimedelta | str | NonerBr)rcz1BaseOffsetT | BaseOffset | timedelta | str | NonerBr?)rBz(tuple[npt.NDArray[np.int64], BaseOffset])r)rsint)NNNNNNNN)rBztuple[np.ndarray, BaseOffset])rBzlist[np.ndarray])h __future__rdatetimerr(typingrrrrr r r rnumpyr pandas._libsr rr pandas._libs.arraysrpandas._libs.tslibsrrrrrrrrmrrrrrrpandas._libs.tslibs.dtypesrrrpandas._libs.tslibs.fieldsrpandas._libs.tslibs.offsetsrr pandas._libs.tslibs.periodr!r"r#r$r%pandas.util._decoratorsr&r'pandas.util._exceptionsr(pandas.core.dtypes.commonr)r*pandas.core.dtypes.dtypesr+r,pandas.core.dtypes.genericr-r.r/r0pandas.core.dtypes.missingr1rr2rpandas.core.commoncorecommonrpcollections.abcr3pandas._typingr4r5r6r7r8r9r:r;r<r=pandas.core.arrays.baser>r?rSrT DatelikeOps PeriodMixinrBrrcrrrr{rrOrMrs".     65 ,2 (   7m:6  ] T ,#//9#8#8T ,n&L,0`9 6`9 (`9 `9 `9F    "B""L%N-%NP.d      .4#.4brO