]jMSrSSKJr SSKrSSKrSSKJrJrJrJ r J r SSK r SSK r SSKJrJrJrJr SSKJr SSKJrJrJrJrJrJrJr SSKJr SS K J!r! SS K"J#r#J$r$ SS K%J&r&J'r'J(r(J)r)J*r*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2J3r3J4r4J5r5 SS K6J7r7 SS K8J9r9J:r:J;r;Jr>J?r?J@r@JArAJBrBJCrCJDrD SSKEJFrFJGrG SSKHJIrI SSKJJKrLJMrMJNrN SSKOJPrP \(a)SSKJQrQJRrRJSrS SSKTJUrUJVrVJWrW SSKXJYrYJZrZ \"S\V\U-\Z-S9r[S7Sjr\S8Sjr]S9Sjr^\R\R\R\R\R\R\R\R\R\R\R\R\R\RS.rmS:SjrnS;Sjro\ SS"jrqS?S@S#jjrr\prsS$rtSAS%jruSBSCS&jjrv\"S 5SDSES'jj5rwSFSGS(jjrxS?SHS)jjrySISJS*jjrzSKSLS+jjr{SMSNS,jjr|\"S-5SOSPS.jj5r}SQSRS/jjr~1S0krSSSTS1jjrSUSVS2jjrSWS3jrSXS4jrSYS5jrS?SZS6jjrg)[zl 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:[U[5(d [USS9n[UR5(a[ [ R"U55$[UR[5(aH[SU5nUR(d[UR5$[ R"U5$[UR[5(a[SU5nUR$[UR5(ah[U[ R 5(a%[ R"U5R#S5$[ R"U5R%SSS9$['UR5(a[ R"U5$[)UR5(a;URR*S;a [-U5$[ R"U5$[/UR5(a[[ R U5$[1UR5(a-UR#S 5n[[ R U5nU$[ R"U[2S 9n[ U5$) 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_numpyrCr@uint8Fcopy) i8dtype) isinstancer2r;r'rRrnpasarrayr+r_hasna _ensure_data_datar,codesrndarrayviewastyper%r#itemsizerrr)object)valuesnpvaluess S/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pandas/core/algorithms.pyrWrWrs, 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   c[U[5(aURU:XaU$[U[R5(dUR 5nUR XS9$UR USS9$)z reverse of _ensure_data Parameters ---------- values : np.ndarray or ExtensionArray dtype : np.dtype or ExtensionDtype original : AnyArrayLike Returns ------- ExtensionArray or np.ndarray rQFrK)rSr0rRrTconstruct_array_type_from_sequencer\)r_rRoriginalclss ra_reconstruct_datarhsn &+,,1F eRXX & &((* !!&!66 ==U= ++rbc~[U[[[[R [ 45(dUS:wa$[US[U5RS35e[R"USS9nUS;a-[U[5(a [U5n[U5nU$[R"U5nU$)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)rSr1r4r0rTrZr3 TypeErrortype__name__r infer_dtypetuplelistrrU)r_ func_nameinferreds ra_ensure_arraylikerys  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 rarrGsT F ##rbc[U5S:Xag[U5n[R"UR 5R S55S:gR 5nU$)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`` rintp)lenrWrTbincountravelr\sum)r_results ra nunique_intsrsO 6{a & !Fkk&,,.//78A= B B DF Mrbc[USS9n[UR[5(aUR 5$[U[ 5(aUR 5$Un[ U5up0U"[U55nUc)UR U5n[XRRU5nU$UR XS9upQ[XRRU5nUceXQRS54$)z?See algorithms.unique for docs. Takes a mask for masked arrays.rrwmaskbool) ryrSrRr-rr1rrrhr\)r_rrfr tableuniquess rarrs v :F&,,//}}&(##}}H+F3I c&k "E |,,v&#G^^XF V 7 #G^^XF F+++rbi@Bc[U5(d"[S[U5RS35e[U5(d"[S[U5RS35e[ U[ [ [[R45(dj[U5n[USS9n[U5S:aEURRS;a+[U5(d[!X5(d [#U5nO7[ U[$5(a[R&"U5nO [)USSS9n[US S9n[)USS 9n[ U[R5(dUR+U5$[-UR5(a[/U5R+U5$[-UR5(a=[1UR5(d#[R2"UR4[6S 9$[-UR5(a[+X1R9[:55$[ UR[<5(a4[+[R>"U5[R>"U55$[U5[@:a`[U5S ::aQUR[::wa=[CS U55(d&[EU5RC5(aSnOTSnOP[GURUR5nUR9USS9nUR9USS9n[HRJnU"X15$)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 ``rjrriufcbT)rI extract_rangeisinrHrQc30# UH o[Lv M g7frr ).0vs ra isin..9s,VGVsc[R"[R"X5R5[R"U55$r)rT logical_orrrisnan)crs rafisin..f?s,}}RWWQ]%8%8%:BHHQKHHrbcJ[R"X5R5$r)rTrr)abs raisin..CsRWWQ]002rbFrK)&r&rqrrrsrSr1r4r0rTrZrvryrrRkindr(r rr2r9r;rr)pd_arrayr'zerosshaperr\r^r-rU_MINIMUM_COMP_ARR_LENanyr6rhtableismember)compsr_ orig_values comps_arrayrcommons rarrs    ((,U (<(<'=Q @      ((,V (=(='>a A  fx4ErzzR S S6l ";.I K!O !!W,+E22"611=[IF FM * *&!vTN#EVrbc[U[[45(aURXS9$[ USS9nUn[U[ [ 45(a!URbURUS9upVXV4$[U[R5(dURUS9upVO[R"U5nU(d_UR[:XaK[U5nUR5(a+[URSS9n[R "XxU5n[#UUUS9upVU(a[%U5S :a['UUUS SS 9upe[)XdRU5nXV4$) 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]) )sortrrr)r)rF)compat)rrrT)r assume_uniqueverify)rSr1r4rryr/r5freqrTrZrUrRr^r6rr7whererr safe_sortrh) r_rrrrfrYr null_maskrs rarrsQP&8Y/00TKK v =FH 6,.?@AA KK # ))t)4~  + +))/)JwF#6<<6#9 V I}}-fll5I)v>( +   G q "  +   BG >rbcSSKJnJnJnJn [ USS5n U(aSOSn UbSSKJn [X5(a URnU "XSS9n U RUS 9nXl XRR5nURRS 5Ul UR!5nU(a1URS:HR#5(aUR$SSn['U 5nGOxSn[)U5(a6U"US S 9RRUS 9nXl XRl GO0[U[*5(a\[-[/UR055nU"X S9R3UUS9R55nUR6URlO[9USS9n[;X5unnnUR<[>R@:XaUR[>RB5nU"UUR<U S S9nU(dF[XU 45(a4UREU5(aURFbURFUl$U"UUU S S9nU(aURKUSS9nU(aUbUU- nU$XRM5- nU$![an[S 5UeSnAff=f)Nr) DatetimeIndexrArBTimedeltaIndexr proportioncount)cutT)include_lowestz+bins argument only works with numeric data.dropnaintervalFrK)indexr)levelr value_countsr)rRrrL)rrrLstable) ascendingr)'rrrArBrgetattrpandas.core.reshape.tilerrS_valuesrqrrrnotnar\ sort_indexallilocrr!r2rvrangenlevelsgroupbysizenamesryvalue_counts_arraylikerRrTfloat16r}equals inferred_freqr sort_valuesr)r_rr normalizebinsrrrArBr index_namerriierrrnormalize_denominatorlevelskeyscounts_idxs ravalue_counts_internalrIs.J$<'D 0 f % %^^F TV$7B /  **,-||**:6 ""$ v~~*//11[[1%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 J,, K6 KKcUn[U5n[R"XUS9upEn[UR5(aU(aU[ :gnXBXRpT[ XCRU5nXuU4$)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)rWr value_countr)rRr rh)r_rrrfrr na_counterres_keyss rarrsmH & !F%11&tLD*8>>** 4 2 are not supported.)r)rRrWndimr rank_1drank_2drq) r_rmethodrrrrrrankss rarankr#sD*&,,7O & !F {{a + . L  || +  L@AArbzpandas.api.extensionscB[U[R[[[ [ 45(d"[S[U5RS35e[U5nU(a'[XRU5 [UUUSUS9nU$URXS9nU$)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 rkT)r allow_fill fill_value)r)rSrTrZr0r1r4r3rqrrrsrr<rr8take)arrindicesrr%r&rs rar'r'Wsb  &)=ST    99=c9K9K8LA O  "'*G))D/2  !   M'- Mrbc"Ub [U5n[U[R5(GaGURR S;Ga,[ U5(d[U5(Ga [R"URR5n[ U5(a[R"U/5O[R"U5nXTR:R5(a.XTR:*R5(a URnO URn[ U5(a [[URU55nO$[![["U5US9nO [%U5nUR'XUS9$)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. iurQ)sidesorter)rrSrTrZrRrr$r%iinforrr9minrmaxrintrrr: searchsorted)r(valuer,r-r. value_arrrRs rar2r2s `$V, 3 ## IINNd "   "25"9"9 ()3E):):BHHeW%  " ' ' ) )yII/E.J.J.L.LIIEOOE e  ejj/0ET)U35AE-S1   EV  <rrrrr}r|cB[R"U5(d;[U5(aUR5(d [S5e[ U5n[ R nURn[U5nU(a[RnO[Rn[U[5(aUR5nURn[U[ R5(d[!USUR"S35(aAUS:wa$[S[%U5R"SU35eU"XR'U55$[)[%U5R"S35eSnURR*S;a*[ R,nUR/S 5n[0nS nOcU(a[ R2nOKUR*S ;a;URR4S ;a[ R6nO[ R8nUR:nUS :XaUR=SS 5n[ R"U5n[ R>"UR@US9n [CS5/S-n US:a [CSU5O [CUS5X'X9[EU 5'URR4[F;a [HRJ"X [ U5X'S9 O[CS5/S-n US:a [CUS5O [CSU5X'[EU 5n [CS5/S-n US:a [CSU*5O [CU*S5X'[EU 5nU"X X5X'U(aU R/S5n US :Xa U SS2S4n U $)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__rz cannot diff z on axis=zK has no 'diff' method. Convert to a suitable dtype prior to calling 'diff'.FrrPTr+)rrrrrQNrM) datetimelikeztimedelta64[ns])&r r$r" ValueErrorr1rTnanrRroperatorxorsubrSr.to_numpyrZhasattrrsrrshiftrqrrr[r object_rr}r|rreshapeemptyrsliceru _diff_specialr diff_2d)r(nrnarRis_boolop is_timedelta orig_ndimout_arr na_indexer _res_indexer res_indexer _lag_indexer lag_indexers radiffrR(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~!Q$- Nrbc[U[R[[45(d [ S5eSn[UR [5(d%[R"USS9S:Xa [U5nO"UR5nURU5nUcU$[%U5(d [ S5e['[R("U55nU(d,[+[-U55[+U5:Xd [/S5eUcI[1U5uppU"[+U55nUR3U5 ['UR5U55nU(aDUR5n U(a"U[+U5*:U[+U5:-n S X'[7XS S 9n Oa[R8"[+U5[:S 9n U R=U[R>"[+U555 U RUS S 9n U['U 54$![ [R4aF UR(a&[US[ 5(a[#U5nGN[U5nGNf=f)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 valuesNFrlrprzMOnly list-like objects or None are allowed to be passed to safe_sort as codesz,values should be unique if codes is not Nonerr&rQwrap)r) rSrTrZr0r1rqrRr-r rt _sort_mixedargsortr'decimalInvalidOperationrru _sort_tuplesr&rrUrrr8r map_locationslookupr8rBr1putarange) r_rYrrrr-orderedrtorder2r new_codesreverse_indexers rarrs` frzz+Hh("G**V_-K**V_-K #((5H #((5H  "1%I >>8y9 :D ;;t <1s D# D(cFSSKJn SSKJn U"US5up4U"USS9nX$)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). r) to_arrays)lexsort_indexerNT)orders)"pandas.core.internals.constructionrspandas.core.sortingrt)r_rsrtarraysrindexers rarZrZ's,=3&$'IFfT2G ?rbcSSKJn [USS9n[USS9nURUSS9up4[R "UR UR 5nU"XSRSSS9n[U[5(a5[U[5(a URU5R5nOd[U[5(a URn[U[5(a URn[X/5n[U5n[U5nUR!U5R n[R""Xh5$)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. rrBFrrTr1)rrRrL)rrBralignrTmaximumr_rrSr2appendrr1rr*r:reindexrepeat) lvalsrvalsrBl_countr_count final_count unique_valscombinedrepeatss raunion_with_duplicatesr6s.#E%8G#E%8G}}W};G**W^^W^^T[U[5(a-[R"U5(a[R$U$r)rSfloatrTrr9)rhdict_with_defaults rarmap_array..s20$Q..288A;; DE rbr{rQF) tupleize_cols)rrrKr)rrAr8rrSdictr>rBrrTr|r_rr4rr get_indexerr8rrLr\r^r map_infermap_infer_maskr6r[rJ) r(mapper na_actionrAmsgrBry new_valuesr_rs @ra map_arrayress.((;I;kRo F fd # # (F(F!' F &6{abjj9FD))MMO5e+T &)$$  LL..01F,,**3/V^^W5  s88xxzZZUZ +F}}V,,!!&tF|7H7H7RSSrb)r_rreturn np.ndarray)r_rrRrrfrrr)rwrerr)r_rrz)tuple[type[htable.HashTable], np.ndarray])r_rrre)r_rErrE)r_znp.ndarray | Seriesrr)r_rrr1r)rnpt.NDArray[np.bool_] | None)rr=r_r=rnpt.NDArray[np.bool_])TNNN) r_rrrr int | Nonerr^rrrz'tuple[npt.NDArray[np.intp], np.ndarray])FTN)rrrrrrrz%tuple[np.ndarray, np.ndarray | Index])TFFNT) rrrrrrrrrrB)r_rrrrrrz,tuple[ArrayLike, npt.NDArray[np.int64], int])firstN)r_rr zLiteral['first', 'last', False]rrrr)TN)r_rrrrrrz9tuple[np.ndarray, npt.NDArray[np.bool_]] | ExtensionArray)raverager TFN)r_rrrr!rerrerrrrrrrznpt.NDArray[np.float64])rFN)r)rrrr%r)leftN) r(rr3z$NumpyValueArrayLike | ExtensionArrayr,zLiteral['left', 'right']r-zNumpySorter | Nonerznpt.NDArray[np.intp] | np.intp)r)rFz&int | float | np.integer | np.floatingrr)NTFT) r_zIndex | ArrayLikerYznpt.NDArray[np.intp] | Nonerrrrrrrz.AnyArrayLike | tuple[AnyArrayLike, np.ndarray])rr)r_rrr)rArrayLike | Indexrrrr)r(rrzLiteral['ignore'] | Nonerz#np.ndarray | ExtensionArray | Index)__doc__ __future__rrXr:typingrrrrrrnumpyrT pandas._libsr r rr r pandas._libs.missingrpandas._typingrrrrrrrpandas.util._decoratorsrpandas.util._exceptionsrpandas.core.dtypes.castrrpandas.core.dtypes.commonrrrrrrr r!r"r#r$r%r&r'r(r)pandas.core.dtypes.concatr*pandas.core.dtypes.dtypesr+r,r-r.pandas.core.dtypes.genericr/r0r1r2r3r4r5pandas.core.dtypes.missingr6r7pandas.core.array_algos.taker8pandas.core.constructionr9rr:r;pandas.core.indexersr<r=r>r?rr@rArBpandas.core.arraysrCrDrErWrhryComplex128HashTableComplex64HashTableFloat64HashTableFloat32HashTableUInt64HashTableUInt32HashTableUInt16HashTableUInt8HashTableInt64HashTableInt32HashTableInt16HashTable Int8HashTableStringHashTablePyObjectHashTablerrrrrrunique1drrrrrrr rr#r'r2rDrRrrVrZrrrrbrars # $/4$4  1 2   5;.?@A K!\!, !,'!,3?!,!,H:,,**&&&&$$$$$$  " "  " "  " "  " "  $$&& $ .(6   : : Hi$i$X.,8 "^"F! )- ; ;;; ; ' ; - ;| H  y yy y + yy|  [ [[ [  [ [@LP( ( $(,H(1(B-4)-; ; ); '; ;<RV+ +#+2N+>+`)-= = = = =  =  = '==J #$ m m m m%mp&,!% Q= Q= /Q= #Q=  Q= $ Q=pJ lp*.  w3 w3 &w3w3 w3  w3 4 w3t  ,+ ,+%6,+,+d+/PT PT(PT) PTrb