MhSrSSKJr SSKrSSKrSSKJr SSKJrJ r J r SSK r SSK r SSKJrJrJrJr SSKJrJrJrJrJrJr SSKJr SS KJr SS KJ 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,J-r-J.r.J/r/J0r0J1r1 SS K2J3r3 SS K4J5r5J6r6J7r7J8r8 SSK9J:r:J;r;Jr>J?r? SSK@JArAJBrB SSKCJDrD SSKEJFrGJHrHJIrI SSKJJKrK \(aSSKJLrLJMrMJNrN SSKOJPrPJQrQJRrR SSKSJTrTJUrU S6SjrVS7SjrWS8SjrX\R\R\R\R\R\R\R\R\R\R\R\R\R\RS.rgS9SjrhS:SjriSrjS;SjrkSS jroS?S@S!jjrp\"\"S"5\"S#5\"S$5S%9SASBS&jj5rqSCSDS'jjrrSCSDS(jjrsS<SES)jjrtSFSGS*jjruSHSIS+jjrvSJSKS,jjrwSLSMS-jjrxSNSOS.jjry1S/krzSPSQS0jjr{SRSSS1jjr|STS2jr}SUS3jr~SVS4jrSWSXS5jjrg)Yzl Generic data algorithms. This module is experimental at the moment and not intended for public consumption ) annotationsN)dedent) TYPE_CHECKINGLiteralcast)algos hashtableiNaTlib) AnyArrayLike ArrayLikeAxisIntDtypeObj TakeIndexernpt)doc)find_stack_level)'construct_1d_object_array_from_listlikenp_find_common_type)ensure_float64 ensure_objectensure_platform_int is_array_like is_bool_dtypeis_complex_dtype is_dict_likeis_extension_array_dtypeis_float_dtype is_integeris_integer_dtype is_list_likeis_object_dtypeis_signed_integer_dtypeneeds_i8_conversion) concat_compat)BaseMaskedDtypeCategoricalDtypeExtensionDtype NumpyEADtype)ABCDatetimeArrayABCExtensionArrayABCIndex ABCMultiIndex ABCSeriesABCTimedeltaArray)isnana_value_for_dtype)take_nd)arrayensure_wrapped_if_datetimelike extract_array)validate_indices)ListLike NumpySorterNumpyValueArrayLike) CategoricalIndexSeries)BaseMaskedArrayExtensionArrayc:[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_numpyr=r:uint8Fcopy) i8dtype) isinstancer-r5r"rJrnpasarrayr&r_hasna _ensure_data_datar'codesrndarrayviewastyper ritemsizerrr$object)valuesnpvaluess H/var/www/html/env/lib/python3.13/site-packages/pandas/core/algorithms.pyrOrOjs, 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(d!UR 5nUR XS9nU$UR USS9nU$)z reverse of _ensure_data Parameters ---------- values : np.ndarray or ExtensionArray dtype : np.dtype or ExtensionDtype original : AnyArrayLike Returns ------- ExtensionArray or np.ndarray rIFrC)rKr+rJrLconstruct_array_type_from_sequencerT)rWrJoriginalclss rY_reconstruct_datar`sv &+,,1F eRXX & &((*##F#8 Mu51 MrZcv[U[[[[R 45(dUS:wa%[ R"US3[[5S9 [R"USS9nUS;a-[U[5(a [U5n[U5nU$[R"U5nU$)z- ensure that we are arraylike if not already isin-targetsz with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version. stacklevelFskipna)mixedstring mixed-integer)rKr,r.r+rLrRwarningswarn FutureWarningrr infer_dtypetuplelistrrM)rW func_nameinferreds rY_ensure_arraylikerrs fx4ErzzR S S  & MM+""+-  ??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.000000000'], dtype='datetime64[ns]') >>> pd.unique( ... pd.Series( ... [ ... pd.Timestamp("20160101", tz="US/Eastern"), ... pd.Timestamp("20160101", tz="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"), ... ] ... ) ... ) 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, object): ['a', 'b', 'c'] >>> pd.unique(pd.Series(pd.Categorical(list("baabc"), categories=list("abc")))) ['b', 'a', 'c'] Categories (3, object): ['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, object): ['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) )unique_with_mask)rWs rYuniquer3s| F ##rZc[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)lenrOrLbincountravelrTsum)rWresults rY nunique_intsrsO 6{a & !Fkk&,,.//78A= B B DF MrZc[USS9n[UR[5(aUR 5$Un[ U5up0U"[ U55nUc)UR U5n[XRRU5nU$UR XS9upQ[XRRU5nUceXQRS54$)z?See algorithms.unique for docs. Takes a mask for masked arrays.rrpmaskbool) rrrKrJr(rrrr`rT)rWrr^r tableuniquess rYrrs v :F&,,//}}H+F3I c&k "E |,,v&#G^^XF V 7 #G^^XF F+++rZi@Bcf[U5(d"[S[U5RS35e[U5(d"[S[U5RS35e[ U[ [ [[R45(dZ[U5n[USS9n[U5S:a5URRS;a[U5(d [!U5nO7[ U["5(a[R$"U5nO ['USSS9n[US S9n['USS 9n[ U[R5(dUR)U5$[+UR5(a[-U5R)U5$[+UR5(a=[/UR5(d#[R0"UR2[4S 9$[+UR5(a[)X1R7[855$[ UR[:5(a4[)[R<"U5[R<"U55$[U5[>:aI[U5S ::a:UR[8:wa&[AU5RC5(aS nOTSnOP[EURUR5nUR7USS9nUR7USS9n[FRHnU"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 ``rbrriufcbT)rA extract_rangeisinr@rIc[R"[R"X5R5[R"U55$N)rL logical_orrrisnan)cvs rYfisin..fs,}}RWWQ]%8%8%:BHHQKHHrZcJ[R"X5R5$r)rLrr)abs rYisin..sRWWQ]002rZFrC)%r! TypeErrortype__name__rKr,r.r+rLrRrorrrrJkindr#rr-r3r5rr$pd_arrayr"zerosshaperrTrVr(rM_MINIMUM_COMP_ARR_LENr0anyrhtableismember)compsrW orig_values comps_arrayrcommons rYrrs    ((,U (<(<'=Q @      ((,V (=(='>a A  fx4ErzzR S S6l ";.I K!O !!W,+E22=[IF FM * *&!vTN#EVrZz values : sequence A 1-D sequence. Sequences that aren't pandas objects are coerced to ndarrays before factorization. zt sort : bool, default False Sort `uniques` and shuffle `codes` to maintain the relationship. zG size_hint : int, optional Hint to the hashtable sizer. )rWsortrc[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}{sort} 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. .. versionadded:: 1.5.0 {size_hint} 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, object): ['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='object') 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)rrrT)r assume_uniqueverify)rKr,r.rrrr*r/freqrLrRrMrJrVr0rr1whererr safe_sortr`) rWrrrr^rQr null_maskrs rYrrbsQp&8Y/00TKK v =FH 6,.?@AA KK # ))t)4~  + +))/)JwF#6<<6#9 V I}}-fll5I)v>( +   G q "  +   BG >rZc b[R"S[[5S9 [ UUUUUUS9$)a Compute a histogram of the counts of non-null values. Parameters ---------- values : ndarray (1-d) sort : bool, default True Sort by values ascending : bool, default False Sort in ascending order normalize: bool, default False If True then compute a relative histogram bins : integer, optional Rather than count values, group them into half-open bins, convenience for pd.cut, only works with numeric data dropna : bool, default True Don't include counts of NaN Returns ------- Series zupandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.rc)r ascending normalizebinsdropna)rjrkrlrvalue_counts_internal)rWrrrrrs rY value_countsr/s@< MM E#%  !    rZcSSKJnJn [USS5nU(aSOSn UbSSKJn [ X5(a URnU "XSS9n U RUS 9n Xl XRR5n U RRS 5U l U R5n U(a1U RS:HR5(aU R SSn ["R$"['U 5/5nGO[)U5(awU"US S 9RRUS 9n Xl XRl U Rn[ U["R*5(d["R,"U5nGOt[ U[.5(ag[1[3UR455nU"X S9R7XS9R95n UR:U RlU RnO[=USS9n[?X5unnnUR@["RB:XaUR["RD5nU"U5nUR@[F:Xa*UR@[H:XaUR5nOLUR@UR@:wa2UR@S:wa"[JRL"S[N[Q5S9 UUl U"UUU S S9n U(aU RSUS9n U(aXRU5- n U $![an [S 5U eSn A ff=f)Nr)r;r<r proportioncount)cutT)include_lowestz+bins argument only works with numeric data.rintervalFrC)indexr)levelrrrzstring[pyarrow_numpy]zThe behavior of value_counts with object-dtype is deprecated. In a future version, this will *not* perform dtype inference on the resulting index. To retain the old behavior, use `result.index = result.index.infer_objects()`rc)rrrD)r)+pandasr;r<getattrpandas.core.reshape.tilerrK_valuesrrrrnotnarT sort_indexallilocrLr3rrrRrMr-rorangenlevelsgroupbysizenamesrrvalue_counts_arraylikerJfloat16rvrrVrjrkrlr sort_valuesr)rWrrrrrr;r< index_namerriierrrcountslevelskeys_idxs rYrr^s .J$<'D 0 f % %^^F TV$7B /  **,-||**:6 ""$ v~~*//11[[1%F3r7)$ $F + +F/77DDFDSFK *LL ^^Ffbjj11F+  . .%/0FV/v5  "(FLL ^^F'vHF4VDOD&!zzRZZ'{{2::.+CyyD TZZ6%9jj( TZZ'II!88 D"/1"CHF#DuEF ##i#8**,& MS TIJPS S TsL55 M? M  McUn[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)rOr value_countr$rJr r`)rWrrr^rr na_counterres_keyss rYrrsmH & !F%11&tLD*8>>** 4r)rrNzUnable to sort modes: rc)rrr$rJr4r_moderOrrrLrrrjrkrr`)rWrrr^npresultres_maskrrs rYrrs"v 8FH6<<((/7&/||6|** & !FVFH!! 778$x BF M   $SE *')  s6B$$ C. CCc [UR5n[U5nURS:Xa[R "UUUUUUS9nU$URS:Xa[R "UUUUUUUS9nU$[S5e)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_methodr na_optionpctrE)axisrrrrrz&Array with ndim > 2 are not supported.)r$rJrOndimrrank_1drank_2dr)rWrmethodrrrrrankss rYrankr+s>*&,,7O & !F {{a +  * L   +  L@AArZc[U[R[[[ 45(d"[ R"S[[5S9 [U5(d[R"U5n[U5nU(a&[XRU5 [XUSUS9nU$UR!XS9nU$)a Take elements from an array. Parameters ---------- arr : array-like or scalar value Non array-likes (sequences/scalars without a dtype) are coerced to an ndarray. .. deprecated:: 2.1.0 Passing an argument other than a numpy.ndarray, ExtensionArray, Index, or Series is deprecated. 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]) zpd.api.extensions.take accepting non-standard inputs is deprecated and will raise in a future version. Pass either a numpy.ndarray, ExtensionArray, Index, or Series instead.rcT)r allow_fill fill_value)r)rKrLrRr+r,r.rjrkrlrrrMrr6rr2take)arrindicesrrrrs rYrrksj cBJJ(98YO P P  8 ')     jjo!'*G))D/2 t  M'- MrZc"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. iurI)sidesorter)rrKrLrRrJrrr iinforr3minrmaxrintrr r4 searchsorted)rvaluerrr value_arrrJs rYrrs `$V, 3 ## IINNd "   "25"9"9 ()3E):):BHHeW%  " ' ' ) )yII/E.J.J.L.LIIEOOE e  ejj/0ET)U35AE-S1   EV  <r}r|r{rzrvruc[U5n[RnURn[ U5nU(a[ R nO[ Rn[U[5(aUR5nURn[U[R5(d[USURS35(aAUS:wa$[S[U5RSU35eU"XR!U55$[#[U5RS35eSnURR$S;a*[R&nUR)S5n[*nS nOcU(a[R,nOKUR$S ;a;URR.S ;a[R0nO[R2nUR4nUS :XaUR7S S 5n[R"U5n[R8"UR:US9n [=S5/S-n US:a [=SU5O [=US5X'X9[?U 5'URR.[@;a[BRD"X XUS9 O[=S5/S-n US:a [=US5O [=SU5X'[?U 5n [=S5/S-n US:a [=SU*5O [=U*S5X'[?U 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 __rz cannot diff z on axis=zK has no 'diff' method. Convert to a suitable dtype prior to calling 'diff'.FrrHTr)r}r|rrrINrE) datetimelikeztimedelta64[ns])#rrLnanrJroperatorxorsubrKr)to_numpyrRhasattrr ValueErrorrshiftrrrzrSr object_rrvrur reshapeemptyrslicern _diff_specialrdiff_2d)rnrnarJis_boolop is_timedelta orig_ndimout_arr na_indexer _res_indexer res_indexer _lag_indexer lag_indexers rYdiffr=;s( AA 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~~&  cA,Gd }q( /0AvU1d^5q> L) d }q( 01AU4!_5!T? L) !#"2C4DE,,01A~!Q$- NrZc[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(aGUR5n U(a#U[+U5*:U[+U5:-n SX'OSn [7XS S 9n O[R8"[+U5[:S 9n U R=U[R>"[+U555 U RUS S 9n U(a,US :Hn U(a X[+U5*:-U[+U5:-n U(aW b[R@"XS 5 U['U 54$![ [R4aF UR(a&[US[ 5(a[#U5nGN[U5nGN-f=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 valuesNFrerirzMOnly list-like objects or None are allowed to be passed to safe_sort as codesz,values should be unique if codes is not NonerrrIwrap)r)!rKrLrRr+r,rrJr(r rm _sort_mixedargsortrdecimalInvalidOperationrrn _sort_tuplesr!rrMrrr)r map_locationslookupr2r-rputarangeputmask) rWrQrrrrorderedrtorder2r new_codesreverse_indexers rYrrs[` 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.constructionr_pandas.core.sortingr`)rWr_r`arraysrindexers rYrErE=s,=3&$'IFfT2G ?rZc&SSKJn [R"5 [R"SS[ S9 [ USS9n[ USS9nSSS5 WRWSS 9up4[R"URUR5nU"XSRS SS 9n[U[5(a5[U[5(a URU5R5nOd[U[ 5(a UR"n[U[ 5(a UR"n[%X/5n[U5n['U5nUR)U5Rn[R*"Xh5$!,(df  GN==f) 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. rr<ignorezT[U[5(a-[R"U5(a[R$U$r)rKfloatrLrr#)rTdict_with_defaults rYrmap_array..s20$Q..288A;; DE rZrrgrIrhFrC)convert)rr)r)rrKdictr(rr<rrLrur.rr get_indexerr2rrDrTrVr map_infermap_infer_maskr0rSrB) rmapper na_actionrmsgr<re new_valuesrWr~s @rY map_arrayrsH6((;I;kRo F fd # # (F(F!' F &6{abjj9&)$$  LL..01F,,**3/V^^W5  s88xxzZZUZ +F}}VW==!! f!2!2288!rOr`rrComplex128HashTableComplex64HashTableFloat64HashTableFloat32HashTableUInt64HashTableUInt32HashTableUInt16HashTableUInt8HashTableInt64HashTableInt32HashTableInt16HashTable Int8HashTableStringHashTablePyObjectHashTablerrrrrrunique1drrrrrrrrrrrrr/r=rrArEryrrZrYrs#  (4"4  1 2  K!\ &2>B8,,**&&&&$$$$$$  " "  " "  " "  " "  $$&& $$6^$B.,0 "X"z! )- ; ;;; ; ' ; - ;|       0  t tt t + t-,tr  , ,, ,  , ,b  a aa a  a aLLP( ( $(,H(1(B-4)-; ; ); '; ;<RV) )#)2N))\ 8 8 8 8 8  8  88F m m m mp&,!% Q= Q= /Q= #Q=  Q= $ Q=pJ gf*.  3 3 &33 3  3 4 3D  4+ 4+%64+4+t+/ P P (P  P ) P rZ