o ŀg@szdZddlmZddlZddlZddlmZddlmZm Z m Z ddl Z ddl Z ddlmZmZmZmZddlmZmZmZmZmZmZddlmZdd lmZdd lm Z m!Z!dd l"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/m0Z0m1Z1dd l2m3Z3dd l4m5Z5m6Z6m7Z7m8Z8ddl9m:Z:m;Z;mZ>m?Z?ddl@mAZAmBZBddlCmDZDddlEmFZGmHZHmIZIddlJmKZKerddlmLZLmMZMmNZNddlOmPZPmQZQmRZRddlSmTZTmUZUdddZVdd d!ZWdd$d%ZXejYejZej[ej\ej]ej^ej_ej`ejaejbejcejdejeejfd&Zgdd'd(Zhdd)d*Zid+d,Zjdd.d/Zkddd2d3ZlejZmd4Zndd8d9Zo :   dddBdCZpeedDedEedFdG H : dddKdLZq : H H  :dddQdRZr : H H  :dddSdTZs dddVdWZt X ddd[d\Zu ddd]d^Zv  _ Y : HdddfdgZw  H dddkdlZx m dddvdwZyhdxZzdddzd{Z{  : H :ddddZ|dddZ}dddZ~dddZ  :ddddZdS)zl 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)BaseMaskedArrayExtensionArrayvaluesr return np.ndarraycCs@t|ts t|dd}t|jrtt|St|jtr/t d|}|j s*t |j St|St|jt r=t d|}|jSt|jrZt|tjrPt|dSt|jdddSt|jrdt|St|jrx|jjdvrst|St|St|jrt tj|St|jr|d }t tj|}|Stj|td }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_numpyr<r9uint8Fcopy) i8dtype) isinstancer,r4r!rKrnpasarrayr%r_hasna _ensure_data_datar&codesrndarrayviewastyperritemsizerrr#object)r>npvaluesrYJ/var/www/html/myenv/lib/python3.10/site-packages/pandas/core/algorithms.pyrPjs<                     rPrKroriginalr cCsPt|tr |j|kr |St|tjs|}|j||d}|S|j|dd}|S)z reverse of _ensure_data Parameters ---------- values : np.ndarray or ExtensionArray dtype : np.dtype or ExtensionDtype original : AnyArrayLike Returns ------- ExtensionArray or np.ndarray rJFrD)rLr*rKrMconstruct_array_type_from_sequencerU)r>rKr[clsrYrYrZ_reconstruct_datas r_ func_namestrcCsvt|ttttjfs9|dkrtj|dtt dt j |dd}|dvr4t|t r.t |}t|}|St|}|S)z5 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)rLr+r-r*rMrSwarningswarn FutureWarningrr infer_dtypetuplelistrrN)r>r`inferredrYrYrZ_ensure_arraylikes  rq) complex128 complex64float64float32uint64uint32uint16rCint64int32int16int8rhrWcCs t|}t|}t|}||fS)z Parameters ---------- values : np.ndarray Returns ------- htable : HashTable subclass values : ndarray )rP_check_object_for_strings _hashtables)r>ndtyperrYrYrZ_get_hashtable_algos rcCs&|jj}|dkrtj|ddrd}|S)z Check if we can use string hashtable instead of object hashtable. Parameters ---------- values : ndarray Returns ------- str rWFrerh)rKnamer is_string_array)r>rrYrYrZr}s  r}cCst|S)a3 Return unique values based on a hash table. Uniques are returned in order of appearance. This does NOT sort. Significantly faster than numpy.unique for long enough sequences. Includes NA values. Parameters ---------- values : 1d array-like Returns ------- numpy.ndarray or ExtensionArray The return can be: * Index : when the input is an Index * Categorical : when the input is a Categorical dtype * ndarray : when the input is a Series/ndarray Return numpy.ndarray or ExtensionArray. See Also -------- Index.unique : Return unique values from an Index. Series.unique : Return unique values of Series 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.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)r>rYrYrZunique3s^rintcCs8t|dkrdSt|}t|ddk}|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)lenrPrMbincountravelrUsum)r>resultrYrYrZ nunique_intss rmasknpt.NDArray[np.bool_] | NonecCst|dd}t|jtr|S|}t|\}}|t|}|dur0||}t||j|}|S|j||d\}}t||j|}|dusFJ||dfS)z?See algorithms.unique for docs. Takes a mask for masked arrays.rr`Nrbool) rqrLrKr'rrrr_rU)r>rr[rtableuniquesrYrYrZrs      ri@Bcompsr6npt.NDArray[np.bool_]cCst|stdt|jdt|stdt|jdt|ttttj fsGt |}t |dd}t |dkrF|j jdvrFt|sFt|}nt|trRt|}nt|ddd}t |d d}t|dd }t|tj sp||St|j r|t||St|j rt|j stj|jtd St|j rt||tSt|j trtt|t|St |tkrt |d kr|j tkrt |!rd d}ndd}nt"|j |j }|j|dd}|j|dd}t#j$}|||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 ``rbrriufcbT)rB extract_rangeisinrArJcSstt||t|SN)rM logical_orrrisnan)cvrYrYrZfszisin..fcSst||Sr)rMrr)abrYrYrZszisin..FrD)%r TypeErrortype__name__rLr+r-r*rMrSrorqrrKkindr"rr,r2r4rr#pd_arrayr!zerosshaperrUrWr'rN_MINIMUM_COMP_ARR_LENr/anyrhtableismember)rr> orig_values comps_arrayrcommonrYrYrZrs^                   rTuse_na_sentinelr size_hint int | Nonena_valuerW'tuple[npt.NDArray[np.intp], np.ndarray]c Csf|}|jjdvr t}t|\}}||pt|}|j|d|||d\}} t||j|}t| } | |fS)a( Factorize a numpy array to codes and uniques. This doesn't do any coercion of types or unboxing before factorization. Parameters ---------- values : ndarray 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 Passed through to the hashtable's 'get_labels' method na_value : object, optional A value in `values` to consider missing. Note: only use this parameter when you know that you don't have any values pandas would consider missing in the array (NaN for float data, iNaT for datetimes, etc.). mask : ndarray[bool], optional If not None, the mask is used as indicator for missing values (True = missing, False = valid) instead of `na_value` or condition "val != val". Returns ------- codes : ndarray[np.intp] uniques : ndarray mM) na_sentinelrr ignore_na)rKrr rr factorizer_r) r>rrrrr[ hash_klassrrrRrYrYrZfactorize_array$s$    rz 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. )r>sortrFr%tuple[np.ndarray, np.ndarray | Index]c Cs t|ttfr|j||dSt|dd}|}t|ttfr.|jdur.|j|d\}}||fSt|tj s=|j|d\}}n+t |}|s_|j t kr_t |}|r_t|j dd}t|||}t|||d \}}|r{t|d kr{t|||d dd \}}t||j |}||fS) aN 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]) )rrrrN)r)rF)compat)rrrT)r assume_uniqueverify)rLr+r-rrqr)r.freqrMrSrNrKrWr/rr0whererr safe_sortr_) r>rrrr[rRr null_maskrrYrYrZrbsB       r ascending normalizedropnar;cCs&tjdttdt||||||dS)aK 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)rrrbinsr)rjrkrlrvalue_counts_internal)r>rrrrrrYrYrZ value_counts/src Cs:ddlm}m}t|dd}|rdnd} |duruddlm} t||r&|j}z | ||dd} Wnty@} ztd | d} ~ ww| j |d } | | _ | | j } | j d | _ | } |rl| jdkrl| jdd} tt| g}nt|r||d d jj |d } | | _ || j _ | j}t|tjst|}not|trtt|j}||| dj||d} |j| j _| j}nMt|dd}t||\}}}|j tj!kr| tj"}||}|j t#kr|j t$kr| t$}n|j |j kr|j dkrt%j&dt't(d||_ |||| d d} |r| j)|d} |r| |*} | S)Nr)r:r;r proportioncount)cutT)include_lowestz+bins argument only works with numeric data.rintervalFrD)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)rrrE)r)+pandasr:r;getattrpandas.core.reshape.tilerrL_valuesrrrrnotnarU sort_indexallilocrMr2rrrSrNr,rorangenlevelsgroupbysizenamesrqvalue_counts_arraylikerKfloat16rurrWrjrkrlr sort_valuesr)r>rrrrrr:r; index_namerriierrrcountslevelskeys_idxrYrYrZr^sv                    r,tuple[ArrayLike, npt.NDArray[np.int64], int]cCsb|}t|}tj|||d\}}}t|jr%|r%|tk}||||}}t||j|}|||fS)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)rPr value_countr#rKr r_)r>rrr[rr na_counterres_keysrYrYrZrs  rfirstkeepLiteral['first', 'last', False]cCst|}tj|||dS)ax Return boolean ndarray denoting duplicate values. Parameters ---------- values : np.ndarray or ExtensionArray Array over which to check for duplicate values. keep : {'first', 'last', False}, default 'first' - ``first`` : Mark duplicates as ``True`` except for the first occurrence. - ``last`` : Mark duplicates as ``True`` except for the last occurrence. - False : Mark all duplicates as ``True``. mask : ndarray[bool], optional array indicating which elements to exclude from checking Returns ------- duplicated : ndarray[bool] )rr)rPr duplicated)r>rrrYrYrZrsrc Cst|dd}|}t|jrt|}td|}|j|dSt|}tj|||d\}}|dur2||fSzt |}Wnt yV}zt j d|tdWYd}~nd}~wwt||j|}|S) 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 ------- np.ndarray or ExtensionArray moderr=r)rrNzUnable to sort modes: rc)rqr#rKr3r_moderPrrrMrrrjrkrr_)r>rrr[npresultres_maskrrrYrYrZrs*    raverageaxisr method na_optionpctnpt.NDArray[np.float64]c Csdt|j}t|}|jdkrtj||||||d}|S|jdkr.tj|||||||d}|Std)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_methodrrrrF)rrrrrrz&Array with ndim > 2 are not supported.)r#rKrPndimrrank_1drank_2dr)r>rrrrrrranksrYrYrZrank+s0    rindicesr allow_fillcCs|t|tjtttfstjdtt dt |st |}t |}|r5t ||j|t|||d|d}|S|j||d}|S)ak 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)rr fill_value)r)rLrMrSr*r+r-rjrkrlrrrNrr5rr1take)arrrrrr rrYrYrZr ks"U  r leftr value$NumpyValueArrayLike | ExtensionArraysideLiteral['left', 'right']sorterNumpySorter | Nonenpt.NDArray[np.intp] | np.intpcCs|durt|}t|tjr^|jjdvr^t|st|r^t|jj }t|r-t |gnt |}||j k rD||j k rD|j}n|j}t|rTtt| |}nttt||d}nt|}|j|||dS)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. NiurJ)rr)rrLrMrSrKrrriinforr2minrmaxrrrr r3 searchsorted)r r rrr value_arrrKrYrYrZrs&0  r>r|r{rzryrurtncCsJt|}tj}|j}t|}|rtj}ntj}t|t r#| }|j}t|tj sVt |d|j drL|dkrDtdt|j d|||||Stt|j dd}|jjdvrktj}|d}t}d }n|rqtj}n|jd vr|jjd vrtj}ntj}|j}|d kr|d d }t|}tj|j|d} tdgd} |dkrtd|nt|d| |<|| t| <|jjt vrt!j"|| |||dnCtdgd} |dkrt|dntd|| |<t| } tdgd} |dkrtd| nt| d| |<t| }||| ||| | <|r| d} |d kr#| dddf} | S)aQ 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'.FrrITr)r|r{rrrJNrF) datetimelikeztimedelta64[ns])#rrMnanrKroperatorxorsubrLr(to_numpyrShasattrr ValueErrorrshiftrrryrTr object_rrurtrreshapeemptyrslicern _diff_specialrdiff_2d)r rrnarKis_boolop is_timedelta orig_ndimout_arr na_indexer _res_indexer res_indexer _lag_indexer lag_indexerrYrYrZdiff;sh            $  r6Index | ArrayLikerRnpt.NDArray[np.intp] | Nonerr.AnyArrayLike | tuple[AnyArrayLike, np.ndarray]c Cst|tjttfs tdd}t|jts#tj |dddkr#t |}n+z | }| |}Wntt jfyM|jrGt|dtrGt|}nt |}Ynw|durT|St|s\tdtt|}|sstt|t|ksstd|durt|\}}|t|}||t||}|r| } |r|t| k|t|kB} d|| <nd} t| |d d } n2tjt|td } | |tt|| j |d d } |r|d k} |r| |t| kB|t|kB} |r| durt | | d |t| fS)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 Nonerr rJwrap)r)!rLrMrSr*r+rrKr'r rm _sort_mixedargsortr decimalInvalidOperationrrn _sort_tuplesr rrNrrr#r map_locationslookupr1r'rputarangeputmask) r>rRrrrrorderedrtorder2r new_codesreverse_indexerrYrYrZrsb0         rc Cstjdd|Dtd}tjdd|Dtd}||@}t||}t||}|d|}|d|}|d}t|||g} || S)z3order ints before strings before nulls in 1d arrayscSsg|]}t|tqSrY)rLra.0xrYrYrZ 0sz_sort_mixed..rJcSsg|]}t|qSrY)r/rKrYrYrZrN1sr)rMr2rr=nonzeror  concatenate) r>str_posnull_posnum_pos str_argsort num_argsortstr_locsnum_locs null_locslocsrYrYrZr<.s   r<cCs:ddlm}ddlm}||d\}}||dd}||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.constructionrZpandas.core.sortingr[)r>rZr[arraysrindexerrYrYrZr@=s   r@lvalsArrayLike | Indexrvalsc Csddlm}ttjddtdt|dd}t|dd}Wdn1s)wY|j|dd \}}t |j |j }|||j d dd }t |t rZt |t rZ||}nt |trb|j}t |trj|j}t||g}t|}t|}||j }t||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. rr;ignorezrrLr,appendrr+rr$r3reindexrepeat) rarcr;l_countr_count final_count unique_valscombinedrepeatsrYrYrZunion_with_duplicatesLs0         rt na_actionLiteral['ignore'] | Noneconvert#np.ndarray | ExtensionArray | Indexc s |dvrd|d}t|t|r=t|tr%t|dr%|fdd}nddlm}t|dkr9||tj d }n||}t|t r[|d krM||j }|j |}t|j|}|St|sc|S|jtd d }|d urvtj|||dStj||t|tj|dS)a Map values using an input mapping or function. Parameters ---------- mapper : function, dict, or Series Mapping correspondence. na_action : {None, 'ignore'}, default None If 'ignore', propagate NA values, without passing them to the mapping correspondence. convert : bool, default True Try to find better dtype for elementwise function results. If False, leave as dtype=object. Returns ------- Union[ndarray, Index, ExtensionArray] The output of the mapping function applied to the array. If the function returns a tuple with more than one element a MultiIndex will be returned. )Nrez+na_action must either be 'ignore' or None, z was passed __missing__cs$t|trt|rtjS|Sr)rLfloatrMrr)rMdict_with_defaultrYrZrs zmap_array..rrdrJreFrDN)rw)rrw)r#rrLdictr"rr;rrMrtr-rr get_indexerr1rrErUrWr map_infermap_infer_maskr/rTrC) r mapperrurwmsgr;r` new_valuesr>rYr{rZ map_arrays2     r)r>r r?r@)r>r rKrr[r r?r )r`rar?r )r>r@)r>r@r?ra)r>r r?rr)rr)rr6r>r6r?r)TNNN) r>r@rrrrrrWrrr?r)FTN)rrrrrrr?r)TFFNT) rrrrrrrrr?r;)r>r@rrrrr?r)rN)r>r rrrrr?r)TN)r>r rrrrr?r )rrrTF)r>r rr rrarrarrrrr?r)rFN)rrrr rr)r N) r r r rrrrrr?r)r)rrrr )NTFT) r>r7rRr8rrrrrrr?r9)r?r )r>r@r?r@)rarbrcrbr?rb)NT)r r rurvrwrr?rx)__doc__ __future__rr>rtextwraprtypingrrrrjnumpyrM pandas._libsrrrr r pandas._typingr r r rrrpandas.util._decoratorsrpandas.util._exceptionsrpandas.core.dtypes.castrrpandas.core.dtypes.commonrrrrrrrrrrrr r!r"r#pandas.core.dtypes.concatr$pandas.core.dtypes.dtypesr%r&r'r(pandas.core.dtypes.genericr)r*r+r,r-r.pandas.core.dtypes.missingr/r0pandas.core.array_algos.taker1pandas.core.constructionr2rr3r4pandas.core.indexersr5r6r7r8rr9r:r;pandas.core.arraysr<r=rPr_rqComplex128HashTableComplex64HashTableFloat64HashTableFloat32HashTableUInt64HashTableUInt32HashTableUInt16HashTableUInt8HashTableInt64HashTableInt32HashTableInt16HashTable Int8HashTableStringHashTablePyObjectHashTabler~rr}rrrunique1drrrrrrrrrrr rr)r6rr<r@rtrrYrYrYrZs     D     N !   a  ] >: 1 f !  . C x X s    :