ujdZddlmZddlZddlZddlmZmZmZm Z m Z ddl Z ddl Z ddlmZmZmZmZddlmZddlmZddlmZdd lmZmZdd lmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-dd l.m/Z/dd l0m1Z1m2Z2m3Z3m4Z4dd l5m6Z6m7Z7m8Z8m9Z9m:Z:ddl;mm?Z?ddl@mAZBmCZCmDZDddlEmFZFer>ddlGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSddlTmUZUmVZVmWZWddlXmYZYmZZZedeVeUzeZzZ[ddZ^ejejejejejejejejejejejejejejdZm d?dZnd@dZoe dAdZpe dBdZpedd ZpdCd!ZqdDdEd"ZrepZsd#Ztd$ZudFd%ZvdGd&Zw dH dId'Zx dJd(Zyed dK dLd)Zz dM dNd*Z{ dD dOd+Z| dP dQd,Z} dR dSd-Z~ dT dUd.ZdVd/ZdWd0Zed1 dX dYd2Z dZ d[d3Zhd4Zd\d]d5Zd6Z d^ d_d7Zd`d8Zdad9Z dbd:Z dD dcd;Zy)dzl Generic data algorithms. This module is experimental at the moment and not intended for public consumption ) annotationsN) TYPE_CHECKINGLiteralTypeVarcastoverload)algos hashtableiNaTlibNA) 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)ABCExtensionArrayABCIndex ABCMultiIndexABCNumpyExtensionArray ABCSeries)isnana_value_for_dtype)take_nd)arrayensure_wrapped_if_datetimelike extract_array)validate_indices) AnyArrayLike ArrayLike ArrayLikeTAxisIntDtypeObjListLike NumpySorterNumpyValueArrayLike RankMethod RankNaOption TakeIndexernpt) CategoricalIndexSeries)BaseMaskedArrayExtensionArrayT)boundct|ts t|d}t|jrt t j|St|jtrBtd|}|jst|jSt j|St|jtrtd|}|jSt|jrdt|t j r$t j|j#dSt j|j%ddSt'|jrt j|St)|jr:t j|}|jj*dvr t-|S|St/|jrt j|St1|jr|j#d }td |}|St j|t2 }t |S) a 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) i8 np.ndarraydtype) isinstancer*r2r rSrnpasarrayr$r_hasna _ensure_data_datar%codesrndarrayviewastyperritemsizerrr"object)values float_valuesnpvaluess a/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/pandas/core/algorithms.pyrXrXps, fm ,vT:v||$RZZ/00 FLL/ 2'0}}  - -zz&!! FLL"2 3mV,|| v|| $ fbjj )::f%**73 3::f%,,W5,A A &,, 'zz&!!  %zz&)    & &+ 5!,/ / &,, 'zz&!! V\\ *;;t$ h/ZZf -F   ct|tr|j|k(r|St|tjs#|j }|j ||S|j |dS)z reverse of _ensure_data Parameters ---------- values : np.ndarray or ExtensionArray dtype : np.dtype or ExtensionDtype original : AnyArrayLike Returns ------- ExtensionArray or np.ndarray rRFrK)rTr(rSrUconstruct_array_type_from_sequencer])r`rSoriginalclss rc_reconstruct_datarjsj &+,1F eRXX &((* !!&!66 ==U= ++rdcft|ttttj t fs|dk7r$t|dt|jdtj|d}|dvr(t|tr t|}t|}|St j|}|S)z5 ensure that we are arraylike if not already isin-targetszQ requires a Series, Index, ExtensionArray, np.ndarray or NumpyExtensionArray got .Fskipna)mixedstring mixed-integer)rTr)r,r(rUr[r+ TypeErrortype__name__r infer_dtypetuplelistrrV)r` func_nameinferreds rc_ensure_arrayliker{s  9/=ST   &+F|,,-Q0  ??6%8 ; ;&%(f>> pd.unique(np.array([True, 1, False, 0], dtype=object)) array([True, False], dtype=object) Examples -------- >>> 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 rcrrHsn F ##rdct|dk(ryt|}tj|j j ddk7j }|S)aH 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)lenrXrUbincountravelr]sum)r`results rc nunique_intsrsO 6{a & !Fkk&,,.//78A= B B DF Mrdct|d}t|jtr|j St|t r|j S|}t |\}}|t|}|*|j |}t||j|}|S|j ||\}}t||j|}|J||jdfS)z?See algorithms.unique for docs. Takes a mask for masked arrays.rrymaskbool) r{rTrSr&rr)rrrjr])r`rrhr tableuniquess rcrrs v :F&,,/}}&(#}}H+F3Iv c&k "E |,,v&#GX^^XF V$ 7 #GX^^XF F+++rdi@Blc |jjdvs(|jjdks|jdk(ryt |j t kxs t |jt kDS)z Whether casting ``arr`` to float64 could change an integer's identity. Only 64-bit integers can carry a magnitude that float64 cannot represent exactly; narrower widths always round-trip. iurF)rSkindr^sizeintmin_FLOAT64_INT_EXACT_MAXmax)arrs rc_may_lose_precision_as_float64rse yy~~T!SYY%7%7!%;sxx1} CGGI000 3 swwy>2 2rdc t|s"tdt|jdts"tdtjdt t t fr3tdkDr$t |ttfr |j}n|}t |tjr|jdk(r|jjdvr|j tkr|jj"dksP|j dk(sAt$ t'|j)kr]t'|j+t$kr=tj,fd|j/Dt0|j St ttt2tjfs8t5}t7|d tdkDrEjjd vr,t9|s t;|st=|d d }t?dj}t |tjsd}ntA||}|jd vrd}nt|jdvrd}nc|jdvr|j"dk(rd}nC|jdvr'|j"dk(rt?d}tC|}n|jdv}|r@tE|n4t tFrtjHntKddt7|d } tK| d} t | tjs| jMStO| jrtQ| jMStOjr:tS| js%tjT| jVt0StOjrtM| jYtZSt jt\r2tMtj^| tj^S| jtj`k(rCjtjbk(r&dk\jYtj`n| jtjbk(rmjtj`k(rPtjdtjbj*kjYtjbtAj| j}|jdvxrtCxs tC| } t| tfkDrVtdkrH| jtZk7r5| s3tidDs!tkjird} nUd} nQ| rtjtZ}jY|d| jY|d} tljn} | | S)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 ``riubrc3&K|]}|v ywrr).0itemr`s rc zisin..Ls?D?s)rScountrlriufcbrSNznp.dtypeTfcFrrQ)rI extract_rangeisinrHrRc3,K|] }|tuywrr )rvs rcrzisin..s,AG,sctjtj||jtj|Sr)rU logical_orrrisnan)crs rcfzisin..fs.}}RWWQ]%8%8%:BHHQKHHrdcJtj||jSr)rUrr)abs rczisin..sRWWQ]002rdrK)8rrsrtrurTset frozensetrr,r)_valuesrUr[ndimrSrrr^rrrrfromitertolistrr(rxr{r!rgetattrrrrrr*r0r2rr"pd_arrayr zerosshaper]r_r&rVrriinfo_MINIMUM_COMP_ARR_LENanyr-htableismember) compsr` comps_arr orig_values comps_dtype values_dtype needs_objectcommon values_arr comps_array lossy_commonrs ` rcrrs   ((,U (<(<'=Q @     ((,V (=(='>a A  &3 *+F a ei2 3 II y"** -!#$$- V,((1,>>Q&++c)--/.BBIMMO,/EE;;?I,<,<,>?nn  fx4ErzzR S6l ";.I K!O !!W,+E2"651"%$7K FLL9Lk2884# ,\;G;;g-#'L[[,$)L %%-+2F2F!2K$(L!&&$.<3H3HA3M"&lF!;J#A*#ML$0#4#4#rdct|}tj|t}d|d<|dd|ddk7|ddtj|}t|}tj ||}tj tj|tj|}|r|st|dz |z }|ddd}||fS)a Factorize an array known to be monotonic and of length >= 2. Uses adjacent-element comparison instead of hash table construction. The caller is responsible for having verified monotonicity; monotonic arrays contain no NA values (NAs break monotonicity checks), so NA handling is not needed. Parameters ---------- arr : ndarray ascending : bool Whether `arr` is monotonic increasing (otherwise decreasing). sort : bool Whether the uniques should be in sorted order. Returns ------- codes : ndarray[np.intp] uniques_indexer : ndarray[np.intp] Positions in `arr` of the unique values, ordered to match `codes`. rRTrrNr)append) rrUemptyr flatnonzerodiffrepeatarangerr) r ascendingsortn transitions group_startsngroups run_lengthsrZs rcfactorize_monotonic_codesrs6 CA((1D)KKN!"gSb)KO>>+.L,G'',q1K IIbiirww7 EE I#GaK%$78#DbD) , rdcVt|ttfr|j||St |d}|}t|t j s|j|\}}nt j|}|s\|jtk(rIt|}|jr.t|jd}t j|||}t|||\}}|r!t|dkDrt!|||d d \}}t#||j|}||fS) ax 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. When working with object-dtype arrays, boolean and integer values may not be distinguished since ``True == 1`` and ``False == 0`` in Python. >>> codes, uniques = pd.factorize(np.array([True, 1, False, 0], dtype=object)) >>> codes array([0, 0, 1, 1]) >>> uniques array([True, False], dtype=object) 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)rF)compat)rrrT)r assume_uniqueverify)rTr)r,rr{rUr[rVrSr_r-rr.whererr safe_sortrj) r`rrrrhrZr null_maskrs rcrrEsb&8Y/0T?KK v =FH fbjj )))/)JwF#6<<6#9 V I}}-fll5I)Xv>( + w  G q "  +   BG '>rdclddlm}m}m}m} t |dd} |rdnd} |ddlm} t||r |j} | ||d} | j| }| |_ ||jj}|jjd |_ |j!}|r,|jdk(j#r|j$dd}t'| }nwd}t)|r>||d jj| }| |_ | |j_ n,t|t*rct-t/|j0}||| j3||j5}|j6|j_nt9|d}t;||\}}}|j<t>j@k(r|jt>jB}|||j<| d }|s>* 4r?rr@rAz%Array with ndim > 2 is not supported.)r"rSrXrr rank_1drank_2drs) r`rBmethodr@rrArr>rankss rcrankrGsD*&,,7O & !F {{a + . L  || +  L?@@rdct|j}t|}tj||\}}}t |t |t |fS)a Determine whether values are monotonic increasing/decreasing. Parameters ---------- values : np.ndarray or ExtensionArray Returns ------- tuple[bool, bool, bool] (is_monotonic_increasing, is_monotonic_decreasing, is_strict_monotonic) Raises ------ TypeError If the dtype is not orderable by the underlying routine (e.g. complex). )timelike)r"rSrXr is_monotonicr)r`rIincdecstricts rcrJrJ sN$#6<<0H & !F))&8DCf 9d3if --rdctj|d}||}t|}tj|t}d|dd|dd|ddk7|ddtj j tj|tj|d}tj|tj}tj||z ||<|S) a! For each element, the number of earlier elements with the same code. Parameters ---------- codes : np.ndarray[intp] Returns ------- np.ndarray[intp] Examples -------- >>> occurrence_rank(np.array([0, 1, 0, 0, 1])) array([0, 0, 1, 2, 1]) r)rrRTNrrr) rUargsortrrrmaximum accumulaterrr)rZorder sorted_codesris_start group_startrGs rcoccurrence_rankrV*s" JJu8 ,Et|tjttt t fs"tdt|jdt|}|r+t||j|t|||d|}|S|j||}|S)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 rmT)rB allow_fill fill_value)rB)rTrUr[r(r)r,r+rsrtrurr3rr/take)rindicesrBrXrYrs rcrZrZGsb  &)=ST   99=c9K9K8LA O  "'*G#))D/2  !   M'- Mrdc| t|}t|tjr |jj dvrt |s t|rtj|jj}t |rtj|gntj|}||jk\jr*||jkjr |j}n |j}t |rtd|j|}n#ttd||}n t!|}|j#|||S)a 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. rrr5rR)sidesorter)rrTrUr[rSrrrrrtr0rrrrrr1 searchsorted)rvaluer]r^r value_arrrSs rcr_r_s`$V, 3 # IINNd "  "25"9 ()3E):BHHeW%  " ' ' )yEII/E.J.J.LIIEOOE e  5 12ET+u5UCE-S1   EV  <rrrrrr~ctj|s1t|r|js tdt |}t j }|j}t|}|rtj}ntj}t|tr|j}|j}t|t jst!|d|j"drK||j$k\r$tdt'|j"d||||j)|St+t'|j"dd}|jj,dvr*t j.}|j1d}t2}d }nZ|rt j4}nG|j,d vr9|jj6d vrt j8}nt j:}|j$}|d k(r|j=d d }t j|}t j>|j@|} tCdgdz} |dk\r tCd|n tC|d| |<|| tE| <|jj6tFvr$tIjJ|| t |||ntCdgdz} |dk\r tC|dn tCd|| |<tE| } tCdgdz} |dkDr tCd| n tC| d| |<tE| }||| ||| | <|r| j1d} |d k(r | dddf} | S)z 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 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'.FrrPTr)rrrrrRNrMr) datetimelikeztimedelta64[ns])&r rr ValueErrorrrUnanrSroperatorxorsubrTr'to_numpyr[hasattrrurrtshiftrsrrr\r object_rrr~reshaperrslicerw _diff_specialr diff_2d)rrrBnarSis_boolop is_timedelta orig_ndimout_arr na_indexer _res_indexer res_indexer _lag_indexer lag_indexers rcrrs( >>!   9: : F B IIEE"G \\ \\%&lln  c2:: & 3"R[[M, -sxx <S 0B0B/C9TF!STTc399Q<( (9%%&'GG  L yy~~hhtn    t  99>>. .JJEJJEIA~kk"a  HHUOEhhsyy.G+"J)*auT1~U1d^Jt!#GE*  yy~~&  c7CFD|Ld }q( /0AvU1d^5q> TL) d }q( 01AU4!_5!T? TL) !#k"2C 4DE ,,01A~!Q$- Nrdict|tjttfs t dd}d}dx}}|t|tjrs|j jdvr[t|tk\rIt|j}t|j|z dz}|dt|zk}|r tjtd|} nt|j ts&t!j"|d d k(r t%|} nl |Ht|tjr.|j jd vrtj|} n!|j'}|j)|} || St5|s t d t7tj8|}|rtd|} | j jd k(r%| j;tj<d|z } n| |z } tj>|t@} d| | <| jCtjD} |s| dt|k7r tGd| | }|dz}n|s+ttI|t|k(s tGd|`tjJt|tjD}tjLt|tjD||<nJtO|\}}|t|}|jQ| t7|jS|}|r4|r#|t| k|t|k\z}d||<tU||d}n|j)|d}| t7|fS#t t*j,f$r:|j.rt|dt0r t3|} n t%|} YswxYw)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 valuesNFrrrrQrnrriufbzMOnly list-like objects or None are allowed to be passed to safe_sort as codesirKrRTrz,values should be unique if codes is not NonerYwrap)r5)+rTrUr[r(r)rsrSrr_MIN_COUNTING_SORT_LENrrrrrr&r rv _sort_mixedrOrZdecimalInvalidOperationrrw _sort_tuplesrrrVr]rrrcumsumrrerrrr map_locationslookupr/)r`rZrrrr^ use_countingvminrng_sizeorderedrshiftedpresentr)rFrtr new_codess rcrrsu` frzz+>S jjj6=GDjG((840bgg.s6{!:KL Lw  S%8CK%GKL L  HHS[8EIIc&kAE&M "5V!< J3v;'A OOG $'(89E S[L(Uc&k-ABDE$KE5R8 JJu6J2 ' 2 22Y7334 .{{z&)U;'v.%f- .s+A+N77AP  P c Vtj|Dcgc]}t|tc}t}tj|Dcgc] }t |c}t}||z}tj ||}tj ||}|jdj|}|jdj|}|jd} tj||| g} |j| Scc}wcc}w)z3order ints before strings before nulls in 1d arraysrRr) rUr0rTstrrr-rOnonzerorZ concatenate) r`xstr_posnull_posnum_pos str_argsort num_argsortstr_locsnum_locs null_locslocss rcrr<shhF;q 1c*;4HGxx&1Qa1>Hh("G**VG_-K**VG_-K #((5H #((5H  "1%I >>8Xy9 :D ;;t <1s D! D&cPddlm}ddlm}||d\}}||d}||S)a 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.constructionrpandas.core.sortingr)r`rrarraysr*indexers rcrrKs0=3&$'IFAfT2G '?rdcddlm}t|d}t|d}|j|d\}}t j |j |j }|||jdd}t|tr0t|tr |j|j}n[t|tr |j}t|tr |j}t||g}t|}t|}|j!|j }t j"||S)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. rrBFr rr)rrSrL)rrBr,alignrUrPr`rrTr*rrr)rr#r1reindexr) lvalsrvalsrBl_countr_count final_count unique_valscombinedrepeatss rcunion_with_duplicatesrZs.#E%8G#E%8G}}W};GW**W^^W^^.s10$Q.288A; DE rdrrRF) tupleize_cols)rrrKr)rrArerrTdictrkrBrrUr~r`r(r,rr get_indexerr/rrLr]r_r map_infermap_infer_maskr-r\rJ) rmapper na_actionrAmsgrBr new_valuesr`rs @rc map_arrayrsh.((;I;kRo F fd # (F!' F &6{abjj9FD)MMO5e+T &)$  FLL..01F,,**3/V^^W5  s8xxzZZUZ +F}}VV,,!!&&tF|7H7H7RSSrd)r`r5returnrQ)r`r6rSr8rhr4rr6)ryrrr5)r`rQrz)tuple[type[htable.HashTable], np.ndarray])r`rQrr)r`rErrE)r`znp.ndarray | SeriesrrQ)r`r5rrr)rnpt.NDArray[np.bool_] | None)rrQrr)rr9r`r9rnpt.NDArray[np.bool_])TNNN) r`rQrrr int | Nonerr_rrrz'tuple[npt.NDArray[np.intp], np.ndarray])rrQrrrrrz1tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]])FTN)rrrrrrrz%tuple[np.ndarray, np.ndarray | Index])TFFNT) rrrrr!rr rrrB)r`rQr rrrrz,tuple[ArrayLike, npt.NDArray[np.int64], int])firstN)r`r5r2zLiteral['first', 'last', False]rrrr)TN)r`r5r rrrrz9tuple[np.ndarray, npt.NDArray[np.bool_]] | ExtensionArray)raverager2TFN)r`r5rBr7rEr<r@r=rrrArrrrznpt.NDArray[np.float64])r`r5rztuple[bool, bool, bool])rZnpt.NDArray[np.intp]rr)rFN)r[r>rBr7rXr)leftN) rr5r`z$NumpyValueArrayLike | ExtensionArrayr]zLiteral['left', 'right']r^zNumpySorter | Nonerznpt.NDArray[np.intp] | np.intp)r)rz&int | float | np.integer | np.floatingrBr7)NTFT) r`zIndex | ArrayLikerZznpt.NDArray[np.intp] | Nonerrrrrrrz.AnyArrayLike | tuple[AnyArrayLike, np.ndarray])rr4)r`rQrrQ)rArrayLike | Indexrrrr)rr5rzLiteral['ignore'] | Nonerz#np.ndarray | ExtensionArray | Index)__doc__ __future__rrrgtypingrrrrrr9numpyrU pandas._libsr r rr r pandas._libs.missingrpandas.util._decoratorsrpandas.util._exceptionsrpandas.core.dtypes.castrrpandas.core.dtypes.commonrrrrrrrrrrrrrr r!r"pandas.core.dtypes.concatr#pandas.core.dtypes.dtypesr$r%r&r'pandas.core.dtypes.genericr(r)r*r+r,pandas.core.dtypes.missingr-r.pandas.core.array_algos.taker/pandas.core.constructionr0rr1r2pandas.core.indexersr3pandas._typingr4r5r6r7r8r9r:r;r<r=r>r?rr@rArBpandas.core.arraysrCrDrErXrjr{Complex128HashTableComplex64HashTableFloat64HashTableFloat32HashTableUInt64HashTableUInt32HashTableUInt16HashTableUInt8HashTableInt64HashTableInt32HashTableInt16HashTable Int8HashTableStringHashTablePyObjectHashTablerrrrrrunique1drrrrrrrr,rr3r5rGrJrVrZr_rprrrrrrrrrdrcrs\ # $.4$4  1 2      5;.?@A N!b!, !,'!,3?!,!,H:,,**&&&&$$$$$$  " "  " "  " "  " "  $$&& $ .(6   : : Hv$v$r.,8 " F"V! )- ; ;;; ; ' ; - ;|- -- -7 -` H  { {{ { + {{@  [ [[ [  [ [@LP( ( $(,H(1(B-4)-; ; ); '; ;<RV+ +#+2N+>+`"$)-= = = = =  =  = '==@.:: #$ m m m m%mp&,!% Q= Q= /Q= #Q=  Q= $ Q=pJ jf*.  h3 h3 &h3h3 h3  h3 4 h3V  ,+ ,+%6,+,+d+/PT PT(PT) PTrd