+ Ŝi&Rt^RIHt^RIt^RIt^RIHtHtHtH t H t ^RI t ^RI t ^RIHtHtHtHt^RIHt^RIHtHtHtHtHtHtHt^RIHt^RI H!t!^R I"H#t#H$t$^R I%H&t&H't'H(t(H)t)H*t*H+t+H,t,H-t-H.t.H/t/H0t0H1t1H2t2H3t3H4t4H5t5^R I6H7t7^R I8H9t9H:t:H;t;Ht>H?t?H@t@HAtAHBtBHCtCHDtD^RIEHFtFHGtG^RIHHItI^RIJHKtLHMtMHNtN^RIOHPtP]'d5^RIHQtQHRtRHStS^RITHUtUHVtVHWtW^RIXHYtYHZtZ]!R]V]U,]Z,R7t[RRlt\RRlt]RRlt^R]PR]PR]PR ]PR!]PR"]PR#]PR$]PR%]PR&]PR']PR(]PR)]PR*]P/tmR+R,ltnR-R.lto] R/R0l4tp] R1R2l4tp]!R34R44tpR5R6ltqR[R7R8lltr]ptsR9ttR:R;ltuR\R<R=lltv]!R34R]R>R?ll4twR^R@RAlltxR[RBRClltyR_RDRElltzR`RFRGllt{RaRHRIllt|]!RJ4RbRKRLll4t}RcRMRNllt~0RdmtReRORPlltRfRQRRlltRSRTltRURVltRWRXltR[RYRZlltR#)gzl Generic data algorithms. This module is experimental at the moment and not intended for public consumption ) annotationsN) TYPE_CHECKINGLiteralTypeVarcastoverload)algos hashtableiNaTlibNA) AnyArrayLike ArrayLike ArrayLikeTAxisIntDtypeObj TakeIndexernpt) set_module)find_stack_level)'construct_1d_object_array_from_listlikenp_find_common_type)ensure_float64 ensure_objectensure_platform_int is_bool_dtypeis_complex_dtype is_dict_likeis_dtype_equalis_extension_array_dtypeis_floatis_float_dtype is_integeris_integer_dtype is_list_likeis_object_dtypeis_signed_integer_dtypeneeds_i8_conversion) concat_compat)BaseMaskedDtypeCategoricalDtypeExtensionDtype NumpyEADtype)ABCDatetimeArrayABCExtensionArrayABCIndex ABCMultiIndexABCNumpyExtensionArray ABCSeriesABCTimedeltaArray)isnana_value_for_dtype)take_nd)arrayensure_wrapped_if_datetimelike extract_array)validate_indices)ListLike NumpySorterNumpyValueArrayLike) CategoricalIndexSeries)BaseMaskedArrayExtensionArrayT)boundc V^8dQhRRRR/#)valuesrreturn np.ndarray)formats"_/Users/mibo/.openclaw/workspace/.venv-ak/lib/python3.14/site-packages/pandas/core/algorithms.py __annotate__rNrsK!K!K!zK!cd\V\4'g\VRR7p\VP4'd \ \ P!V44#\VP\4'dJ\RV4pVP'g\VP4#\ P!V4#\VP\4'd\RV4pVP#\VP4'dm\V\ P 4'd&\ P!V4P#R4#\ P!V4P%RRR7#\'VP4'd\ P!V4#\)VP4'd=VPP*R 9d \-V4#\ P!V4#\/VP4'd\\ P V4#\1VP4'd.VP#R4p\\ P V4pV#\ P!V\2R 7p\ V4#) aD routine to ensure that our data is of the correct input dtype for lower-level routines This will coerce: - ints -> int64 - uint -> uint64 - bool -> uint8 - datetimelike -> i8 - datetime64tz -> i8 (in local tz) - categorical -> codes Parameters ---------- values : np.ndarray or ExtensionArray Returns ------- np.ndarray T extract_numpyrBr?uint8Fcopyi8dtype)rG ) isinstancer1r:r&rXrnpasarrayr*r_hasna _ensure_data_datar+codesrndarrayviewastyper$r"itemsizerrr(object)rHnpvaluess& rMr_r_rs, fm , ,vT:v||$$RZZ/00 FLL/ 2 2'0}}}  - -zz&!! FLL"2 3 3mV,|| v|| $ $ fbjj ) )::f%**73 3::f%,,W5,A A &,, ' 'zz&!!  % % << K /!&) )zz&!! &,, ' 'BJJ'' V\\ * *;;t$ H-ZZf -F   rOc(V^8dQhRRRRRRRR/#)rGrHrrXroriginalrrIrK)rLs"rMrNrNs,!,!, !,'!,3?!,!,rOc\V\4'dVPV8XdV#\V\P4'g#VP 4pVP WR7#VP VRR7#)z reverse of _ensure_data Parameters ---------- values : np.ndarray or ExtensionArray dtype : np.dtype or ExtensionDtype original : AnyArrayLike Returns ------- ExtensionArray or np.ndarray rWFrT)r[r/rXr\construct_array_type_from_sequencerd)rHrXriclss&&& rM_reconstruct_datarnsn &+,,1F eRXX & &((* !!&!66 ==U= ++rOc V^8dQhRRRR/#)rG func_namestrrIrrK)rLs"rMrNrNsrOc\V\\\\P \ 34'gVR8wd%\V R\V4P R24h\P!VRR7pVR9d/\V\4'd \V4p\V4pV#\P!V4pV#)z- ensure that we are arraylike if not already isin-targetszQ requires a Series, Index, ExtensionArray, np.ndarray or NumpyExtensionArray got .Fskipna)mixedstring mixed-integer)r[r0r3r/r\rbr2 TypeErrortype__name__r infer_dtypetuplelistrr])rHrpinferreds&& rM_ensure_arraylikers  9/=ST    &+F|,,-Q0  ??6%8 ; ;&%((f>> pd.unique(pd.Series([2, 1, 3, 3])) array([2, 1, 3]) >>> pd.unique(pd.Series([2] + [1] * 5)) array([2, 1]) >>> pd.unique(pd.Series([pd.Timestamp("20160101"), pd.Timestamp("20160101")])) array(['2016-01-01T00:00:00.000000'], dtype='datetime64[us]') >>> pd.unique( ... pd.Series( ... [ ... pd.Timestamp("20160101", tz="US/Eastern"), ... pd.Timestamp("20160101", tz="US/Eastern"), ... ], ... dtype="M8[ns, US/Eastern]", ... ) ... ) ['2016-01-01 00:00:00-05:00'] Length: 1, dtype: datetime64[ns, US/Eastern] >>> pd.unique( ... pd.Index( ... [ ... pd.Timestamp("20160101", tz="US/Eastern"), ... pd.Timestamp("20160101", tz="US/Eastern"), ... ], ... dtype="M8[ns, US/Eastern]", ... ) ... ) DatetimeIndex(['2016-01-01 00:00:00-05:00'], dtype='datetime64[ns, US/Eastern]', freq=None) >>> pd.unique(np.array(list("baabc"), dtype="O")) array(['b', 'a', 'c'], dtype=object) An unordered Categorical will return categories in the order of appearance. >>> pd.unique(pd.Series(pd.Categorical(list("baabc")))) ['b', 'a', 'c'] Categories (3, str): ['a', 'b', 'c'] >>> pd.unique(pd.Series(pd.Categorical(list("baabc"), categories=list("abc")))) ['b', 'a', 'c'] Categories (3, str): ['a', 'b', 'c'] An ordered Categorical preserves the category ordering. >>> pd.unique( ... pd.Series( ... pd.Categorical(list("baabc"), categories=list("abc"), ordered=True) ... ) ... ) ['b', 'a', 'c'] Categories (3, str): ['a' < 'b' < 'c'] An array of tuples >>> pd.unique(pd.Series([("a", "b"), ("b", "a"), ("a", "c"), ("b", "a")]).values) array([('a', 'b'), ('b', 'a'), ('a', 'c')], dtype=object) A NumpyExtensionArray of complex >>> pd.unique(pd.array([1 + 1j, 2, 3])) [(1+1j), (2+0j), (3+0j)] Length: 3, dtype: complex128 )unique_with_maskrs&rMrrGsT F ##rOc V^8dQhRRRR/#)rGrHrrIintrK)rLs"rMrNrNssrOc\V4^8Xd^#\V4p\P!VP 4P R44^8gP 4pV#)a  Return the number of unique values for integer array-likes. Significantly faster than pandas.unique for long enough sequences. No checks are done to ensure input is integral. Parameters ---------- values : 1d array-like Returns ------- int : The number of unique values in ``values`` intp)lenr_r\bincountravelrdsum)rHresults& rM nunique_intsrsO 6{a & !Fkk&,,.//78A= B B DF MrOcV^8dQhRR/#)rGmasknpt.NDArray[np.bool_] | NonerK)rLs"rMrNrNs,,#?,rOc\VRR7p\VP\4'dVP 4#\V\ 4'dVP 4#Tp\ V4wr0V!\V44pVf*VP V4p\WRPV4pV#VP WR7wrQ\WRPV4pVfQhWQPR43#)z?See algorithms.unique for docs. Takes a mask for masked arrays.rrprbool) rr[rXr,rr0rrrnrd)rHrrir tableuniquess&& rMrrs v :F&,,//}}&(##}}H+F3I c&k "E |,,v&#G^^XF V 7 #G^^XF F+++rOi@Bc$V^8dQhRRRRRR/#)rGcompsr<rHrInpt.NDArray[np.bool_]rK)rLs"rMrNrNs'^"^"^"(^"/D^"rOcH\V4'g#\R\V4P R24h\V4'g#\R\V4P R24h\ V\ \ \\P34'gr\V4p\VRR7p\V4^8dIVPPR9d.\V4'g\!W4'g \#V4pM;\ V\$4'd\P&!V4pM\)VRRR7p\VRR7p\)VRR 7p\ V\P4'gVP+V4#\-VP4'd\/V4P+V4#\-VP4'dB\1VP4'g'\P2!VP4\6R 7#\-VP4'd\+W1P9\:44#\ VP\<4'd5\+\P>!V4\P>!V44#\V4\@8d\V4^8:dwVP\:8wdb\B;QJdR V4F 'gK RM R M !R V44'g(\EV4PC4'dR pMZRpMV\GVPVP4pVP9VR R7pVP9VR R7p\HPJpV!W14#)z Compute the isin boolean array. Parameters ---------- comps : list-like values : list-like Returns ------- ndarray[bool] Same length as `comps`. zIonly list-like objects are allowed to be passed to isin(), you passed a ``rsriufcbT)rR extract_rangeisinrQrWc30"TF q\JxK R#5irr ).0vs& rM isin..9s,VGVsFc\P!\P!W4P4\P!V44#r)r\ logical_orrrisnan)crs&&rMfisin..f?s,}}RWWQ]%8%8%:BHHQKHHrOcJ\P!W4P4#r)r\rr)abs&&rMisin..CsRWWQ]002rOrT)&r%rzr{r|r[r0r3r/r\rbrrrrXkindr'rrr1r8r:rr(pd_arrayr&zerosshaperrdrfr,r]_MINIMUM_COMP_ARR_LENanyr5rhtableismember)rrH orig_values comps_arrayrcommons&& rMrrs    ((,U (<(<'=Q @      ((,V (=(='>a A  fx4ErzzR S S6l ";.I K!O !!W,+E22"611=[IF FM * *&!vTN#EVrOc(V^8dQhRRRRRRRR/#)rGsortrrrrrIz%tuple[np.ndarray, np.ndarray | Index]rK)rLs"rMrNrNs8yy yy y + yrOc\V\\34'dVPWR7#\ VRR7pTp\V\ \ 34'd&VPeVPVR7wrVWV3#\V\P4'gVPVR7wrVM\P!V4pV'geVP\8XdP\V4pVP4'd/\VPRR7p\P !WxV4p\#VVVR7wrVV'd#\%V4^8d\'VVVR RR 7wre\)WdPV4pWV3#) a Encode the object as an enumerated type or categorical variable. This method is useful for obtaining a numeric representation of an array when all that matters is identifying distinct values. `factorize` is available as both a top-level function :func:`pandas.factorize`, and as a method :meth:`Series.factorize` and :meth:`Index.factorize`. Parameters ---------- values : sequence A 1-D sequence. Sequences that aren't pandas objects are coerced to ndarrays before factorization. sort : bool, default False Sort `uniques` and shuffle `codes` to maintain the relationship. use_na_sentinel : bool, default True If True, the sentinel -1 will be used for NaN values. If False, NaN values will be encoded as non-negative integers and will not drop the NaN from the uniques of the values. size_hint : int, optional Hint to the hashtable sizer. Returns ------- codes : ndarray An integer ndarray that's an indexer into `uniques`. ``uniques.take(codes)`` will have the same values as `values`. uniques : ndarray, Index, or Categorical The unique valid values. When `values` is Categorical, `uniques` is a Categorical. When `values` is some other pandas object, an `Index` is returned. Otherwise, a 1-D ndarray is returned. .. note:: Even if there's a missing value in `values`, `uniques` will *not* contain an entry for it. See Also -------- cut : Discretize continuous-valued array. unique : Find the unique value in an array. Notes ----- Reference :ref:`the user guide ` for more examples. Examples -------- These examples all show factorize as a top-level method like ``pd.factorize(values)``. The results are identical for methods like :meth:`Series.factorize`. >>> codes, uniques = pd.factorize(np.array(["b", "b", "a", "c", "b"], dtype="O")) >>> codes array([0, 0, 1, 2, 0]) >>> uniques array(['b', 'a', 'c'], dtype=object) With ``sort=True``, the `uniques` will be sorted, and `codes` will be shuffled so that the relationship is the maintained. >>> codes, uniques = pd.factorize( ... np.array(["b", "b", "a", "c", "b"], dtype="O"), sort=True ... ) >>> codes array([1, 1, 0, 2, 1]) >>> uniques array(['a', 'b', 'c'], dtype=object) When ``use_na_sentinel=True`` (the default), missing values are indicated in the `codes` with the sentinel value ``-1`` and missing values are not included in `uniques`. >>> codes, uniques = pd.factorize(np.array(["b", None, "a", "c", "b"], dtype="O")) >>> codes array([ 0, -1, 1, 2, 0]) >>> uniques array(['b', 'a', 'c'], dtype=object) Thus far, we've only factorized lists (which are internally coerced to NumPy arrays). When factorizing pandas objects, the type of `uniques` will differ. For Categoricals, a `Categorical` is returned. >>> cat = pd.Categorical(["a", "a", "c"], categories=["a", "b", "c"]) >>> codes, uniques = pd.factorize(cat) >>> codes array([0, 0, 1]) >>> uniques ['a', 'c'] Categories (3, str): ['a', 'b', 'c'] Notice that ``'b'`` is in ``uniques.categories``, despite not being present in ``cat.values``. For all other pandas objects, an Index of the appropriate type is returned. >>> cat = pd.Series(["a", "a", "c"]) >>> codes, uniques = pd.factorize(cat) >>> codes array([0, 0, 1]) >>> uniques Index(['a', 'c'], dtype='str') If NaN is in the values, and we want to include NaN in the uniques of the values, it can be achieved by setting ``use_na_sentinel=False``. >>> values = np.array([1, 2, 1, np.nan]) >>> codes, uniques = pd.factorize(values) # default: use_na_sentinel=True >>> codes array([ 0, 1, 0, -1]) >>> uniques array([1., 2.]) >>> codes, uniques = pd.factorize(values, use_na_sentinel=False) >>> codes array([0, 1, 0, 2]) >>> uniques array([ 1., 2., nan]) )rrrr)r)rF)compat)rrT)r assume_uniqueverify)r[r0r3rrr.r4freqr\rbr]rXrfr5rr6whererr safe_sortrn) rHrrrrirar null_maskrs &&&& rMrrsQP&8Y/00TKK v =FH 6,.?@AA KK # ))t)4~  + +))/)JwF#6<<6#9 V I}}-fll5I)v>( +   G q "  +   BG >rOc ,V^8dQhRRRRRRRRRR/#)rGrr ascending normalizedropnarIrArK)rLs"rMrNrNIsC[[ [[ [  [ [rOc^RIHpHpHpHp \ VRR4p V'dRMRp Ve^RIHp \W4'd VPpV !WRR7p T PTR 7pYn YPP4,pTPPR 4Tn TP!4pT'd7TP^8HP#4'dTP$R ,p\'T 4pEMRp\)V4'd=V!VR R7PPVR 7pWn WPn EME\V\*4'dc\-\/VP044pV!W R7P3VVR7P54pVP6VPnM\9VRR7p\;W4wpppVP<\>P@8Xd VP\>PB4pV!VVP<V R R7pV'gJ\WV 34'd7VPEV4'd VPFeVPFVn$V!VVV R R7pV'dVPKVRR7pV'd&Ve VV, pV#WPM4, pV# \dp\R 4ThRp?ii;i)) DatetimeIndexr@rATimedeltaIndexrN proportioncount)cutT)include_lowestz+bins argument only works with numeric data.rinterval:rrNFrT)indexr)levelr value_countsr)rXrrU)rrrUstable)rr)'rrr@rArgetattrpandas.core.reshape.tilerr[_valuesrzrrrnotnard sort_indexallilocrr r1rrangenlevelsgroupbysizenamesrvalue_counts_arraylikerXr\float16requals inferred_freqr sort_valuesr)rHrrrbinsrrr@rAr index_namerriierrrnormalize_denominatorlevelskeyscounts_idxs&&&&&& rMvalue_counts_internalrIs.J$<'D 0 f % %^^F TV$7B /  **,-||**:6 ""$ v~~*//11[[%F!$B!% #F + +F/77DDFDSFK *LL   . .%/0FV/vf5  "(FLL 'vHF4VDOD&!zzRZZ'{{2::.DJJZeLCv~'FGGJJv&&((4"//F#DuEF ##ih#G ,33F Mjjl*F MC TIJPS S Ts K)) L4 LLc(V^8dQhRRRRRRRR/#) rGrHrJrrrrrIz,tuple[ArrayLike, npt.NDArray[np.int64], int]rK)rLs"rMrNrNs,(( ( $(,H(1(rOcTp\V4p\P!WVR7wrEp\VP4'd!V'dV\ 8gpWB,WR,rT\ WCPV4pWuV3#)z Parameters ---------- values : np.ndarray dropna : bool mask : np.ndarray[bool] or None, default None Returns ------- uniques : np.ndarray counts : np.ndarray[np.int64] r)r_r value_countr(rXr rn)rHrrrirr na_counterres_keyss&&& rMr r smH & !F%11&tLD*8>>** 4+rOc"\VRR7pTp\VP4'd*\V4p\ RV4pVP VR7#\ V4p\P!WVR7wrEVf2\P!VP\PR7pMWE3#\V4p\%WCPV4pWu3# \d.p\P !RT 2\#4R 7Rp?LLRp?ii;i) a Returns the mode(s) of an array. Parameters ---------- values : array-like Array over which to check for duplicate values. dropna : bool, default True Don't consider counts of NaN/NaT. Returns ------- Union[Tuple[np.ndarray, npt.NDArray[np.bool_]], ExtensionArray] moderrCr)rrNrWzUnable to sort modes: ) stacklevel)rr(rXr9r_moder_rr'r\rrbool_rrzwarningswarnrrn)rHrrrinpresultres_maskrrs&&& rMr'r's"v 8FH6<<((/7&/||6|** & !FVFH88HNN"((;!! X&x BF     $SE *')   s2 C D!#D  Dc4V^8dQhRRRRRRRRRR R R R R /#) rGrHraxisrmethodrq na_optionrrpctrIznpt.NDArray[np.float64]rK)rLs"rMrNrNsN88 8 8 8 8  8  88rOc \VP4p\V4pVP^8Xd\P !VVVVVVR7pV#VP^8Xd \P !VVVVVVVR7pV#\R4h)a Rank the values along a given axis. Parameters ---------- values : np.ndarray or ExtensionArray Array whose values will be ranked. The number of dimensions in this array must not exceed 2. axis : int, default 0 Axis over which to perform rankings. method : {'average', 'min', 'max', 'first', 'dense'}, default 'average' The method by which tiebreaks are broken during the ranking. na_option : {'keep', 'top'}, default 'keep' The method by which NaNs are placed in the ranking. - ``keep``: rank each NaN value with a NaN ranking - ``top``: replace each NaN with either +/- inf so that they there are ranked at the top ascending : bool, default True Whether or not the elements should be ranked in ascending order. pct : bool, default False Whether or not to the display the returned rankings in integer form (e.g. 1, 2, 3) or in percentile form (e.g. 0.333..., 0.666..., 1). )is_datetimelike ties_methodrr2r3)r0r5r6rr2r3z&Array with ndim > 2 are not supported.)r(rXr_ndimrrank_1drank_2drz)rHr0r1r2rr3r5rankss&&&&&& rMrankr;s>*&,,7O & !F {{a +  * L   +  L@AArOzpandas.api.extensionsc$V^8dQhRRRRRR/#)rGindicesrr0r allow_fillrrK)rLs"rMrNrNSs-mm m m mrOcZ\V\P\\\ \ 34'g#\R\V4P R24h\V4pV'd/\WPV,4\VVVRVR7pV#VPWR7pV#)a Take elements from an array. Parameters ---------- arr : numpy.ndarray, ExtensionArray, Index, or Series Input array. indices : sequence of int or one-dimensional np.ndarray of int Indices to be taken. axis : int, default 0 The axis over which to select values. allow_fill : bool, default False How to handle negative values in `indices`. * False: negative values in `indices` indicate positional indices from the right (the default). This is similar to :func:`numpy.take`. * True: negative values in `indices` indicate missing values. These values are set to `fill_value`. Any other negative values raise a ``ValueError``. fill_value : any, optional Fill value to use for NA-indices when `allow_fill` is True. This may be ``None``, in which case the default NA value for the type (``self.dtype.na_value``) is used. For multi-dimensional `arr`, each *element* is filled with `fill_value`. Returns ------- ndarray or ExtensionArray Same type as the input. Raises ------ IndexError When `indices` is out of bounds for the array. ValueError When the indexer contains negative values other than ``-1`` and `allow_fill` is True. Notes ----- When `allow_fill` is False, `indices` may be whatever dimensionality is accepted by NumPy for `arr`. When `allow_fill` is True, `indices` should be 1-D. See Also -------- numpy.take : Take elements from an array along an axis. Examples -------- >>> import pandas as pd With the default ``allow_fill=False``, negative numbers indicate positional indices from the right. >>> pd.api.extensions.take(np.array([10, 20, 30]), [0, 0, -1]) array([10, 10, 30]) Setting ``allow_fill=True`` will place `fill_value` in those positions. >>> pd.api.extensions.take(np.array([10, 20, 30]), [0, 0, -1], allow_fill=True) array([10., 10., nan]) >>> pd.api.extensions.take( ... np.array([10, 20, 30]), [0, 0, -1], allow_fill=True, fill_value=-10 ... ) array([ 10, 10, -10]) zkpd.api.extensions.take requires a numpy.ndarray, ExtensionArray, Index, Series, or NumpyExtensionArray got rtT)r0r> fill_value)r0)r[r\rbr/r0r3r2rzr{r|rr;rr7take)arrr=r0r>r@rs&&&&& rMrArARsb  &)=ST    99=c9K9K8LA O  "'*G))D/2  !   M'- MrOc ,V^8dQhRRRRRRRRR R /#) rGrBrvaluez$NumpyValueArrayLike | ExtensionArraysidezLiteral['left', 'right']sorterzNumpySorter | NonerIznpt.NDArray[np.intp] | np.intprK)rLs"rMrNrNsAQ=Q= Q= /Q= #Q=  Q= $ Q=rOc@Ve \V4p\V\P4'EdRVPP R9Ed6\ V4'g\V4'Ed\P!VPP4p\ V4'd\P!V.4M\P!V4pWTP8P4'd0WTP8*P4'dVPpM VPp\ V4'd!\\VPV44pM'\!\\"V4VR7pM \%V4pVP'WVR7#)ao Find indices where elements should be inserted to maintain order. Find the indices into a sorted array `arr` (a) such that, if the corresponding elements in `value` were inserted before the indices, the order of `arr` would be preserved. Assuming that `arr` is sorted: ====== ================================ `side` returned index `i` satisfies ====== ================================ left ``arr[i-1] < value <= self[i]`` right ``arr[i-1] <= value < self[i]`` ====== ================================ Parameters ---------- arr: np.ndarray, ExtensionArray, Series Input array. If `sorter` is None, then it must be sorted in ascending order, otherwise `sorter` must be an array of indices that sort it. value : array-like or scalar Values to insert into `arr`. side : {'left', 'right'}, optional If 'left', the index of the first suitable location found is given. If 'right', return the last such index. If there is no suitable index, return either 0 or N (where N is the length of `self`). sorter : 1-D array-like, optional Optional array of integer indices that sort array a into ascending order. They are typically the result of argsort. Returns ------- array of ints or int If value is array-like, array of insertion points. If value is scalar, a single integer. See Also -------- numpy.searchsorted : Similar method from NumPy. iurW)rErF)rr[r\rbrXrr#r$iinfor{r8minrmaxrrrrr9 searchsorted)rBrDrErFrI value_arrrXs&&&& rMrLrLs `$V, 3 ## IINNd "   "25"9"9 ()3E):):BHHeW%  " ' ' ) )yII/E.J.J.L.LIIEOOE e  ejj/0ET)U35AE-S1   EV  <\V4'dVP4'g \R4h\ V4p\ P pVPp\V4pV'd\PpM\Pp\V\4'dVP4pVPp\V\ P4'g\!VRVP" R24'dCV^8wd%\R\%V4P" RV 24hV!WP'V44#\)\%V4P" R24hRpVPP*R9d+\ P,pVP/R4p\0pR pMfV'd\ P2pMMVP*R 9d=VPP4R9d\ P6pM\ P8pVP:pV^8XdVP=R^4p\ P!V4p\ P>!VP@VR 7p \CR 4.^,p V^8d \CR V4M \CVR 4W&W9\EV 4&VPP4\F9d$\HPJ!W \ V4W'R 7M\CR 4.^,p V^8d \CVR 4M \CR V4W&\EV 4p \CR 4.^,p V^8d\CR V)4M \CV)R 4W&\EV 4pV!W ,W,4W&V'dV P/R4p V^8Xd V R,p V #)a difference of n between self, analogous to s-s.shift(n) Parameters ---------- arr : ndarray or ExtensionArray n : int number of periods axis : {0, 1} axis to shift on stacklevel : int, default 3 The stacklevel for the lost dtype warning. Returns ------- shifted zperiods must be an integer__z cannot diff z on axis=zK has no 'diff' method. Convert to a suitable dtype prior to calling 'diff'.FrrVTrHrWN) datetimelikeztimedelta64[ns])rrr):NNNr)&r r#r! ValueErrorrr\nanrXroperatorxorsubr[r-to_numpyrbhasattrr|r{shiftrzrrrcr object_rrrr7reshapeemptyrslicer~ _diff_specialrdiff_2d)rBrOr0narXis_boolop is_timedelta orig_ndimout_arr na_indexer _res_indexer res_indexer _lag_indexer lag_indexers&&& rMdiffrl#s, >>!    9: : F B IIEE"G \\ \\%&&lln  c2:: & & 3"R[[M, - -qy <S 0B0B/C9TF!STTc99Q<( (9%%&'GG  L yy~~hhtn    t  99>>. .JJEJJEIA~kk"a  HHUOEhhsyy.G+"J)*auT1~U1d^J!#E*  yy~~&  cCFDLd }q( /0AvU1d^5q> L) d }q( 01AU4!_5!T? L) !#"2C4DE,,01A~$- NrOc 0V^8dQhRRRRRRRRRRR R /#) rGrHzIndex | ArrayLikeraznpt.NDArray[np.intp] | NonerrrrrIz.AnyArrayLike | tuple[AnyArrayLike, np.ndarray]rK)rLs"rMrNrNsLw3w3 w3 &w3w3 w3  w3 4 w3rOc2\V\P\\34'g \ R4hRp\VP \4'g*\P!VRR7R8Xd \V4pM"VP4pVPV4pVfV#\%V4'g \ R4h\'\P(!V44pV'g.\+\-V44\+V48Xg \/R4hVfJ\1V4wrpV!\+V44pVP3V4\'VP5V44pV'dMVP4p V'd'V\+V4)8V\+V48,p R W&\7WR R7p Mg\P8!\+V4\:R 7p V P=V\P>!\+V444V PVR R 7p V\'V 43# \ \P3dMTP'd,\T^,\ 4'd\#T4pEL\T4pELi;i) a Sort ``values`` and reorder corresponding ``codes``. ``values`` should be unique if ``codes`` is not None. Safe for use with mixed types (int, str), orders ints before strs. Parameters ---------- values : list-like Sequence; must be unique if ``codes`` is not None. codes : np.ndarray[intp] or None, default None Indices to ``values``. All out of bound indices are treated as "not found" and will be masked with ``-1``. use_na_sentinel : bool, default True If True, the sentinel -1 will be used for NaN values. If False, NaN values will be encoded as non-negative integers and will not drop the NaN from the uniques of the values. assume_unique : bool, default False When True, ``values`` are assumed to be unique, which can speed up the calculation. Ignored when ``codes`` is None. verify : bool, default True Check if codes are out of bound for the values and put out of bound codes equal to ``-1``. If ``verify=False``, it is assumed there are no out of bound codes. Ignored when ``codes`` is None. Returns ------- ordered : AnyArrayLike Sorted ``values`` new_codes : ndarray Reordered ``codes``; returned when ``codes`` is not None. Raises ------ TypeError * If ``values`` is not list-like or if ``codes`` is neither None nor list-like * If ``values`` cannot be sorted ValueError * If ``codes`` is not None and ``values`` contain duplicates. zbOnly np.ndarray, ExtensionArray, and Index objects are allowed to be passed to safe_sort as valuesNFruryzMOnly list-like objects or None are allowed to be passed to safe_sort as codesz,values should be unique if codes is not Noner@rWwrap)r'r) r[r\rbr/r0rzrXr,r r} _sort_mixedargsortrAdecimalInvalidOperationr r~ _sort_tuplesr%rr]rrrSr map_locationslookupr7r]rputarange) rHrarrrrForderedrtorder2r new_codesreverse_indexers &&&&& rMrrs` frzz+Hh("G**V_-K**V_-K #((5H #((5H  "1%I >>8y9 :D ;;t <1s D?Ec V^8dQhRRRR/#)rGrHrJrIrK)rLs"rMrNrN"s    rOcT^RIHp^RIHpV!VR4wr4V!VRR7pW,#)z Convert array of tuples (1d) to array of arrays (2d). We need to keep the columns separately as they contain different types and nans (can't use `np.sort` as it may fail when str and nan are mixed in a column as types cannot be compared). ) to_arrays)lexsort_indexerNT)orders)"pandas.core.internals.constructionrpandas.core.sortingr)rHrrarraysrindexers& rMruru"s,=3&$'IFfT2G ?rOc$V^8dQhRRRRRR/#)rGlvalszArrayLike | IndexrvalsrIrK)rLs"rMrNrN1s$,+,+ ,+%6,+,+rOc^RIHp\VRR7p\VRR7pVPV^R7wr4\P !VP VP 4pV!WSPRRR7p\V\4'd7\V\4'd!VPV4P4pMf\V\4'd VPp\V\4'd VPp\W.4p\V4p\V4pVP!V4P p\P"!Wh4#)a Extracts the union from lvals and rvals with respect to duplicates and nans in both arrays. Parameters ---------- lvals: np.ndarray or ExtensionArray left values which is ordered in front. rvals: np.ndarray or ExtensionArray right values ordered after lvals. Returns ------- np.ndarray or ExtensionArray Containing the unsorted union of both arrays. Notes ----- Caller is responsible for ensuring lvals.dtype == rvals.dtype. rAFrror)rrXrU)rrAralignr\maximumrHrr[r1appendrr0rr)r9reindexrepeat) rrrAl_countr_count final_count unique_valscombinedrepeatss && rMunion_with_duplicatesr1s.#E%8G#E%8G}}W};G**W^^W^^.s20$Q..288A;; DE rOrrWF) tupleize_cols)rrTr)Nr)rr@rSrr[dictrYrArr\rrHrr3rr get_indexerr7rrUrdrfr map_infermap_infer_maskr5rcrS) rBmapperrr@msgrAr new_valuesrHrs &&& @rM map_arrayr`ss.((;I;kRo F fd # # (F(F!' F &6{abjj9FD))MMO5e+T &)$$  LL..01F,,**3/V^^W5  s88xxzZZUZ +F}}V,,!!&tF|7H7H7RSSrOr)TNNN)FTN)TFFNT)firstN)TN)raverager"TF)rFN)leftN>rrrrrr)r)NTFT)__doc__ __future__rrsrUtypingrrrrrr+numpyr\ pandas._libsrr rr r pandas._libs.missingr pandas._typingrrrrrrrpandas.util._decoratorsrpandas.util._exceptionsrpandas.core.dtypes.castrrpandas.core.dtypes.commonrrrrrrrr r!r"r#r$r%r&r'r(pandas.core.dtypes.concatr)pandas.core.dtypes.dtypesr*r+r,r-pandas.core.dtypes.genericr.r/r0r1r2r3r4pandas.core.dtypes.missingr5r6pandas.core.array_algos.taker7pandas.core.constructionr8rr9r:pandas.core.indexersr;r<r=r>rr?r@rApandas.core.arraysrBrCrDr_rnrComplex128HashTableComplex64HashTableFloat64HashTableFloat32HashTableUInt64HashTableUInt32HashTableUInt16HashTableUInt8HashTableInt64HashTableInt32HashTableInt16HashTable Int8HashTableStringHashTablePyObjectHashTablerrrrrrunique1drrrrrr r$r'r;rArLr_rlrrqrurrrKrOrMrs # $/4$4  1 2   5;.?@A K!\!,H:&,,** v&& v&& f$$ f$$ f$$ V " " V " " V " " V " " F  f$$ f&& $(6   : : Hi$i$X.,8 "^"B;| Hyyx[~(>;:+\8@ #$m%mjQ=pJ llw3t  ,+^PTPTrO