U +if@sUdZddlmZddlZddlmZmZmZmZm Z m Z m Z m Z m Z ddlZddlmmZddlmZmZmZmZmZmZddlmZddlmZddlm Z dd l!m"Z"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(m)Z)dd l*m+Z+m,Z,m-Z-dd l.m/Z/m0Z0dd l1m2Z2m3Z3m4Z4ddl5m6Z6ddl7m8Z8m9Z9m:Z:ddl;mZ>ddl?m@Z@mAZAmBZBervddlmCZCmDZDddlEmFZFiZGdeHd<dddddZIe dddZJGddde6ZKGdddZLGd d!d!eMZNGd"d#d#eMZOGd$d%d%eeZPGd&dde<ZQdS)'z. Base and utility classes for pandas objects. ) annotationsN) TYPE_CHECKINGAnyGenericHashableLiteralTypeVarcastfinaloverload) ArrayLikeDtypeObj IndexLabelNDFrameTShapenpt)PYPY)functionAbstractMethodError)cache_readonlydoc)is_categorical_dtype is_dict_likeis_extension_array_dtypeis_object_dtype is_scalar) ABCDataFrameABCIndex ABCSeries)isnaremove_na_arraylike) algorithmsnanopsops) DirNamesMixin) duplicatedunique1d value_counts)OpsMixin)ExtensionArray)!create_series_with_explicit_dtypeensure_wrapped_if_datetimelike extract_array) NumpySorterNumpyValueArrayLike) Categoricalzdict[str, str] _shared_docs IndexOpsMixin)klassZinplaceuniquer&_T)boundcs\eZdZUdZded<eddZdddd Zdd d d ddZddfdd Z Z S) PandasObjectz/ Baseclass for various pandas objects. zdict[str, Any]_cachecCst|S)zJ Class constructor (for this class it's just `__class__`. )typeselfr=C/home/mars/bis/venv/lib/python3.8/site-packages/pandas/core/base.py _constructorhszPandasObject._constructorstrreturncCs t|S)zI Return a string representation for a particular object. )object__repr__r;r=r=r>rDoszPandasObject.__repr__Nz str | NoneNone)keyrBcCs4t|dsdS|dkr"|jn|j|ddS)zV Reset cached properties. If ``key`` is passed, only clears that key. r9N)hasattrr9clearpop)r<rFr=r=r> _reset_cachevs   zPandasObject._reset_cacheintcs<t|dd}|r2|dd}tt|r(|n|StS)zx Generates the total memory usage for an object that returns either a value or Series of values memory_usageNTdeep)getattrrKrsumsuper __sizeof__)r<rLZmem __class__r=r>rRs   zPandasObject.__sizeof__)N) __name__ __module__ __qualname____doc____annotations__propertyr?rDrJrR __classcell__r=r=rSr>r8`s   r8c@s&eZdZdZddZddddZdS) NoNewAttributesMixina Mixin which prevents adding new attributes. Prevents additional attributes via xxx.attribute = "something" after a call to `self.__freeze()`. Mainly used to prevent the user from using wrong attributes on an accessor (`Series.cat/.str/.dt`). If you really want to add a new attribute at a later time, you need to use `object.__setattr__(self, key, value)`. cCst|dddS)z9 Prevents setting additional attributes. __frozenTN)rC __setattr__r;r=r=r>_freezeszNoNewAttributesMixin._freezer@)rFcCsTt|ddrB|dksB|t|jksBt||ddk sBtd|dt|||dS)Nr]Fr9z"You cannot add any new attribute '')rOr:__dict__AttributeErrorrCr^)r<rFvaluer=r=r>r^s  z NoNewAttributesMixin.__setattr__N)rUrVrWrXr_r^r=r=r=r>r\s r\c@s eZdZdS) DataErrorNrUrVrWr=r=r=r>rdsrdc@s eZdZdS)SpecificationErrorNrer=r=r=r>rfsrfc@seZdZUdZded<dZded<ded<d d gZeeZe e d d Z e d dZ e e ddddZe e ddZddZdddddZddZeZdS)SelectionMixinz mixin implementing the selection & aggregation interface on a group-like object sub-classes need to define: obj, exclusions robjNzIndexLabel | None _selectionzfrozenset[Hashable] exclusionsr9 __setstate__cCs&t|jtttttjfs |jgS|jSN) isinstancerilisttuplerrnpndarrayr;r=r=r>_selection_lists zSelectionMixin._selection_listcCs,|jdkst|jtr|jS|j|jSdSrl)rirmrhrr;r=r=r> _selected_objszSelectionMixin._selected_objrKrAcCs|jjSrl)rsndimr;r=r=r>rtszSelectionMixin.ndimcCsP|jdk r"t|jtr"|j|jSt|jdkrF|jj|jddddS|jSdS)NrFT)axisZ consolidateZ only_slice)rirmrhrrrlenrjZ _drop_axisr;r=r=r>_obj_with_exclusionss z#SelectionMixin._obj_with_exclusionscCs|jdk rtd|jdt|tttttjfrt |j j |t t |krtt ||j j }tdt|dd|jt|ddSt|dd s||j j krtd ||j|ddS||j krtd ||j |}|j}|j|||d SdS) Nz Column(s) z already selectedzColumns not found: rurtZas_indexFzColumn not found: )rtsubset)ri IndexErrorrmrnrorrrprqrwrhcolumns intersectionset differenceKeyErrorr@_gotitemrOrt)r<rFbad_keysr|rtr=r=r> __getitem__s      zSelectionMixin.__getitem__r{cCs t|dS)a sub-classes to define return a sliced object Parameters ---------- key : str / list of selections ndim : {1, 2} requested ndim of result subset : object, default None subset to act on Nr)r<rFrtr|r=r=r>rs zSelectionMixin._gotitemcOs t|dSrlr)r<funcargskwargsr=r=r> aggregateszSelectionMixin.aggregate)N)rUrVrWrXrYriZ_internal_namesrZ_internal_names_setr rZrrrrsrtrxrrrZaggr=r=r=r>rgs*     rgc@seZdZUdZdZedgZded<edddd Z ed dd d Z d d dddZ ee ddZ eddddZ ddddZeddddZddZeddddZedddd Zed!dd"d#Zd$d%ejfd&d'd(d)d*d+Zed'dd,d-Zdd'd/d0d1Zed2d3d4d5dd'dd6d7d8Zdd'd/d9d:Zeed3d2d;d5ddddd?ZeZd@dAZe d'ddBdCZ!dDdEZ"dFd.d$d$dGdHdIdJdKZ#e$ddLdMZ%dd'd'd'd'dNdOdPZ&dQdRZ'dd'ddSdTdUZ(ed'ddVdWZ)ed'ddXdYZ*ed'ddZd[Z+ed'dd\d]Z,dd'dd^d_d`Z-ee.j/dadadae01dbdcdd'dedfdgdhZ/die2dj<e3ddldmdndodpdqdrZ4e3ddsdmdndtdpdudrZ4ee2djdvdwddydmdndzdpd{drZ4dd}d~Z5e$ddddddZ6ddZ7ddZ8d$S)r2zS Common ops mixin to support a unified interface / docs for Series / Index itolistzfrozenset[str] _hidden_attrsr rAcCs t|dSrlrr;r=r=r>dtypeszIndexOpsMixin.dtypezExtensionArray | np.ndarraycCs t|dSrlrr;r=r=r>_values$szIndexOpsMixin._valuesr6)r<rBcOst|||S)zw Return the transpose, which is by definition self. Returns ------- %(klass)s )nvZvalidate_transpose)r<rrr=r=r> transpose)s zIndexOpsMixin.transposezD Return the transpose, which is by definition self. )rrcCs|jjS)zE Return a tuple of the shape of the underlying data. )rshaper;r=r=r>r;szIndexOpsMixin.shaperKcCs t|dSrlrr;r=r=r>__len__BszIndexOpsMixin.__len__cCsdS)zO Number of dimensions of the underlying data, by definition 1. rur=r;r=r=r>rtFszIndexOpsMixin.ndimcCs$t|dkrtt|StddS)a  Return the first element of the underlying data as a Python scalar. Returns ------- scalar The first element of %(klass)s. Raises ------ ValueError If the data is not length-1. ruz6can only convert an array of size 1 to a Python scalarN)rwnextiter ValueErrorr;r=r=r>itemMs  zIndexOpsMixin.itemcCs|jjS)zD Return the number of bytes in the underlying data. )rnbytesr;r=r=r>r_szIndexOpsMixin.nbytescCs t|jS)zG Return the number of elements in the underlying data. )rwrr;r=r=r>sizefszIndexOpsMixin.sizer*cCs t|dS)aM The ExtensionArray of the data backing this Series or Index. Returns ------- ExtensionArray An ExtensionArray of the values stored within. For extension types, this is the actual array. For NumPy native types, this is a thin (no copy) wrapper around :class:`numpy.ndarray`. ``.array`` differs ``.values`` which may require converting the data to a different form. See Also -------- Index.to_numpy : Similar method that always returns a NumPy array. Series.to_numpy : Similar method that always returns a NumPy array. Notes ----- This table lays out the different array types for each extension dtype within pandas. ================== ============================= dtype array type ================== ============================= category Categorical period PeriodArray interval IntervalArray IntegerNA IntegerArray string StringArray boolean BooleanArray datetime64[ns, tz] DatetimeArray ================== ============================= For any 3rd-party extension types, the array type will be an ExtensionArray. For all remaining dtypes ``.array`` will be a :class:`arrays.NumpyExtensionArray` wrapping the actual ndarray stored within. If you absolutely need a NumPy array (possibly with copying / coercing data), then use :meth:`Series.to_numpy` instead. Examples -------- For regular NumPy types like int, and float, a PandasArray is returned. >>> pd.Series([1, 2, 3]).array [1, 2, 3] Length: 3, dtype: int64 For extension types, like Categorical, the actual ExtensionArray is returned >>> ser = pd.Series(pd.Categorical(['a', 'b', 'a'])) >>> ser.array ['a', 'b', 'a'] Categories (2, object): ['a', 'b'] Nrr;r=r=r>arrayms?zIndexOpsMixin.arrayNFznpt.DTypeLike | Noneboolz np.ndarray)rcopyrBcKst|jr$|jj|f||d|S|rHt|d}td|dtj|j |d}|sf|t j k r| }|t j k r||| <|S)a A NumPy ndarray representing the values in this Series or Index. Parameters ---------- dtype : str or numpy.dtype, optional The dtype to pass to :meth:`numpy.asarray`. copy : bool, default False Whether to ensure that the returned value is not a view on another array. Note that ``copy=False`` does not *ensure* that ``to_numpy()`` is no-copy. Rather, ``copy=True`` ensure that a copy is made, even if not strictly necessary. na_value : Any, optional The value to use for missing values. The default value depends on `dtype` and the type of the array. .. versionadded:: 1.0.0 **kwargs Additional keywords passed through to the ``to_numpy`` method of the underlying array (for extension arrays). .. versionadded:: 1.0.0 Returns ------- numpy.ndarray See Also -------- Series.array : Get the actual data stored within. Index.array : Get the actual data stored within. DataFrame.to_numpy : Similar method for DataFrame. Notes ----- The returned array will be the same up to equality (values equal in `self` will be equal in the returned array; likewise for values that are not equal). When `self` contains an ExtensionArray, the dtype may be different. For example, for a category-dtype Series, ``to_numpy()`` will return a NumPy array and the categorical dtype will be lost. For NumPy dtypes, this will be a reference to the actual data stored in this Series or Index (assuming ``copy=False``). Modifying the result in place will modify the data stored in the Series or Index (not that we recommend doing that). For extension types, ``to_numpy()`` *may* require copying data and coercing the result to a NumPy type (possibly object), which may be expensive. When you need a no-copy reference to the underlying data, :attr:`Series.array` should be used instead. This table lays out the different dtypes and default return types of ``to_numpy()`` for various dtypes within pandas. ================== ================================ dtype array type ================== ================================ category[T] ndarray[T] (same dtype as input) period ndarray[object] (Periods) interval ndarray[object] (Intervals) IntegerNA ndarray[object] datetime64[ns] datetime64[ns] datetime64[ns, tz] ndarray[object] (Timestamps) ================== ================================ Examples -------- >>> ser = pd.Series(pd.Categorical(['a', 'b', 'a'])) >>> ser.to_numpy() array(['a', 'b', 'a'], dtype=object) Specify the `dtype` to control how datetime-aware data is represented. Use ``dtype=object`` to return an ndarray of pandas :class:`Timestamp` objects, each with the correct ``tz``. >>> ser = pd.Series(pd.date_range('2000', periods=2, tz="CET")) >>> ser.to_numpy(dtype=object) array([Timestamp('2000-01-01 00:00:00+0100', tz='CET'), Timestamp('2000-01-02 00:00:00+0100', tz='CET')], dtype=object) Or ``dtype='datetime64[ns]'`` to return an ndarray of native datetime64 values. The values are converted to UTC and the timezone info is dropped. >>> ser.to_numpy(dtype="datetime64[ns]") ... # doctest: +ELLIPSIS array(['1999-12-31T23:00:00.000000000', '2000-01-01T23:00:00...'], dtype='datetime64[ns]') )rna_valuerz/to_numpy() got an unexpected keyword argument 'r`)r)rrrto_numpyrnkeys TypeErrorrpasarrayrlib no_defaultrr )r<rrrrrresultr=r=r>rsc    zIndexOpsMixin.to_numpycCs|j Srl)rr;r=r=r>empty!szIndexOpsMixin.emptyTskipnacOs&t|t||tj|j|dS)a Return the maximum value of the Index. Parameters ---------- axis : int, optional For compatibility with NumPy. Only 0 or None are allowed. skipna : bool, default True Exclude NA/null values when showing the result. *args, **kwargs Additional arguments and keywords for compatibility with NumPy. Returns ------- scalar Maximum value. See Also -------- Index.min : Return the minimum value in an Index. Series.max : Return the maximum value in a Series. DataFrame.max : Return the maximum values in a DataFrame. Examples -------- >>> idx = pd.Index([3, 2, 1]) >>> idx.max() 3 >>> idx = pd.Index(['c', 'b', 'a']) >>> idx.max() 'c' For a MultiIndex, the maximum is determined lexicographically. >>> idx = pd.MultiIndex.from_product([('a', 'b'), (2, 1)]) >>> idx.max() ('b', 2) r)rvalidate_minmax_axisZ validate_maxr#Znanmaxrr<rvrrrr=r=r>max%s(  zIndexOpsMixin.maxrminlargest)opZopposerc)rrBcOsX|j}t|t|||}t|trF|s<|r>> s = pd.Series({{'Corn Flakes': 100.0, 'Almond Delight': 110.0, ... 'Cinnamon Toast Crunch': 120.0, 'Cocoa Puff': 110.0}}) >>> s Corn Flakes 100.0 Almond Delight 110.0 Cinnamon Toast Crunch 120.0 Cocoa Puff 110.0 dtype: float64 >>> s.argmax() 2 >>> s.argmin() 0 The maximum cereal calories is the third element and the minimum cereal calories is the first element, since series is zero-indexed. ryrN) rrrZvalidate_argmax_with_skipnarmr*r anyargmaxr#Z nanargmaxr<rvrrrZdelegater=r=r>rQs4   zIndexOpsMixin.argmaxcOs&t|t||tj|j|dS)a Return the minimum value of the Index. Parameters ---------- axis : {None} Dummy argument for consistency with Series. skipna : bool, default True Exclude NA/null values when showing the result. *args, **kwargs Additional arguments and keywords for compatibility with NumPy. Returns ------- scalar Minimum value. See Also -------- Index.max : Return the maximum value of the object. Series.min : Return the minimum value in a Series. DataFrame.min : Return the minimum values in a DataFrame. Examples -------- >>> idx = pd.Index([3, 2, 1]) >>> idx.min() 1 >>> idx = pd.Index(['c', 'b', 'a']) >>> idx.min() 'a' For a MultiIndex, the minimum is determined lexicographically. >>> idx = pd.MultiIndex.from_product([('a', 'b'), (2, 1)]) >>> idx.min() ('a', 1) r)rrZ validate_minr#Znanminrrr=r=r>rs(  zIndexOpsMixin.minsmallestcOsX|j}t|t|||}t|trF|s<|rrs   zIndexOpsMixin.argmincCs |jS)a Return a list of the values. These are each a scalar type, which is a Python scalar (for str, int, float) or a pandas scalar (for Timestamp/Timedelta/Interval/Period) Returns ------- list See Also -------- numpy.ndarray.tolist : Return the array as an a.ndim-levels deep nested list of Python scalars. )rrr;r=r=r>rszIndexOpsMixin.tolistcCs2t|jtjst|jSt|jjt|jjSdS)a Return an iterator of the values. These are each a scalar type, which is a Python scalar (for str, int, float) or a pandas scalar (for Timestamp/Timedelta/Interval/Period) Returns ------- iterator N) rmrrprqrmaprrangerr;r=r=r>__iter__s  zIndexOpsMixin.__iter__cCstt|S)zc Return True if there are any NaNs. Enables various performance speedups. )rr rr;r=r=r>hasnansszIndexOpsMixin.hasnanscCs t|jSrl)r rr;r=r=r>r szIndexOpsMixin.isnar)rvr numeric_only filter_typer@namec Ks>t||d}|dkr,tt|jd||fd|i|S)zA Perform the reduction type operation if we can. Nz cannot perform the operation r)rOrr:rU) r<rrrvrrrkwdsrr=r=r>_reduces  zIndexOpsMixin._reducec s t|r9z+IndexOpsMixin._map_values..)Zdtype_if_emptyr0rNcSs ||Srl)rvaluesfr=r=r>r_rignorecSst||t|tjSrl)rZmap_infer_maskr viewrpZuint8rr=r=r>rcsz+na_action must either be 'ignore' or None, z was passed)rrmdictrGr+rpZfloat64rrrr rrindexZ get_indexerr"Ztake_ndrNotImplementedErrorZastyperCrZ map_inferr) r<ZmapperZ na_actioncatrZindexer new_valuesZmap_fmsgr=rr> _map_valuess>           zIndexOpsMixin._map_values) normalizesort ascendingdropnacCst||||||dS)a Return a Series containing counts of unique values. The resulting object will be in descending order so that the first element is the most frequently-occurring element. Excludes NA values by default. Parameters ---------- normalize : bool, default False If True then the object returned will contain the relative frequencies of the unique values. sort : bool, default True Sort by frequencies. ascending : bool, default False Sort in ascending order. bins : int, optional Rather than count values, group them into half-open bins, a convenience for ``pd.cut``, only works with numeric data. dropna : bool, default True Don't include counts of NaN. Returns ------- Series See Also -------- Series.count: Number of non-NA elements in a Series. DataFrame.count: Number of non-NA elements in a DataFrame. DataFrame.value_counts: Equivalent method on DataFrames. Examples -------- >>> index = pd.Index([3, 1, 2, 3, 4, np.nan]) >>> index.value_counts() 3.0 2 1.0 1 2.0 1 4.0 1 dtype: int64 With `normalize` set to `True`, returns the relative frequency by dividing all values by the sum of values. >>> s = pd.Series([3, 1, 2, 3, 4, np.nan]) >>> s.value_counts(normalize=True) 3.0 0.4 1.0 0.2 2.0 0.2 4.0 0.2 dtype: float64 **bins** Bins can be useful for going from a continuous variable to a categorical variable; instead of counting unique apparitions of values, divide the index in the specified number of half-open bins. >>> s.value_counts(bins=3) (0.996, 2.0] 2 (2.0, 3.0] 2 (3.0, 4.0] 1 dtype: int64 **dropna** With `dropna` set to `False` we can also see NaN index values. >>> s.value_counts(dropna=False) 3.0 2 1.0 1 2.0 1 4.0 1 NaN 1 dtype: int64 )rrrbinsr)r()r<rrrrrr=r=r>r(tsVzIndexOpsMixin.value_countscCsZ|j}t|tjsN|}|jjdkrVt|trVt|jdddkrVt |}nt |}|S)N)mMtz) rrmrprqr5rkindrrOrr')r<rrr=r=r>r5s  zIndexOpsMixin.unique)rrBcCs|}|rt|}t|S)a Return number of unique elements in the object. Excludes NA values by default. Parameters ---------- dropna : bool, default True Don't include NaN in the count. Returns ------- int See Also -------- DataFrame.nunique: Method nunique for DataFrame. Series.count: Count non-NA/null observations in the Series. Examples -------- >>> s = pd.Series([1, 3, 5, 7, 7]) >>> s 0 1 1 3 2 5 3 7 4 7 dtype: int64 >>> s.nunique() 4 )r5r!rw)r<rZuniqsr=r=r>nuniques"zIndexOpsMixin.nuniquecCs|jddt|kS)zr Return boolean if values in the object are unique. Returns ------- bool F)r)rrwr;r=r=r> is_uniques zIndexOpsMixin.is_uniquecCsddlm}||jS)z Return boolean if values in the object are monotonic_increasing. Returns ------- bool rIndex)pandasr is_monotonicr<rr=r=r>rs zIndexOpsMixin.is_monotoniccCs|jS)z) Alias for is_monotonic. )rr;r=r=r>is_monotonic_increasing!sz%IndexOpsMixin.is_monotonic_increasingcCsddlm}||jS)z Return boolean if values in the object are monotonic_decreasing. Returns ------- bool rr)rris_monotonic_decreasingrr=r=r>r)s z%IndexOpsMixin.is_monotonic_decreasing)rNrBcCsRt|jdr|jj|dS|jj}|rNt|rNtsNttj|j }|t |7}|S)aN Memory usage of the values. Parameters ---------- deep : bool, default False Introspect the data deeply, interrogate `object` dtypes for system-level memory consumption. Returns ------- bytes used See Also -------- numpy.ndarray.nbytes : Total bytes consumed by the elements of the array. Notes ----- Memory usage does not include memory consumed by elements that are not components of the array if deep=False or if used on PyPy rLrM) rGrrLrrrr rprqrrZmemory_usage_of_objects)r<rNvrr=r=r> _memory_usage7s zIndexOpsMixin._memory_usager3z sort : bool, default False Sort `uniques` and shuffle `codes` to maintain the relationship. )rorderZ size_hintrryz int | Noner na_sentinelcCstj|||dS)Nr)r" factorize)r<rrr=r=r>rZszIndexOpsMixin.factorizea Find indices where elements should be inserted to maintain order. Find the indices into a sorted {klass} `self` such that, if the corresponding elements in `value` were inserted before the indices, the order of `self` would be preserved. .. note:: The {klass} *must* be monotonically sorted, otherwise wrong locations will likely be returned. Pandas does *not* check this for you. Parameters ---------- value : array-like or scalar Values to insert into `self`. 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 `self` into ascending order. They are typically the result of ``np.argsort``. Returns ------- int or array of int A scalar or array of insertion points with the same shape as `value`. See Also -------- sort_values : Sort by the values along either axis. numpy.searchsorted : Similar method from NumPy. Notes ----- Binary search is used to find the required insertion points. Examples -------- >>> ser = pd.Series([1, 2, 3]) >>> ser 0 1 1 2 2 3 dtype: int64 >>> ser.searchsorted(4) 3 >>> ser.searchsorted([0, 4]) array([0, 3]) >>> ser.searchsorted([1, 3], side='left') array([0, 2]) >>> ser.searchsorted([1, 3], side='right') array([1, 3]) >>> ser = pd.Series(pd.to_datetime(['3/11/2000', '3/12/2000', '3/13/2000'])) >>> ser 0 2000-03-11 1 2000-03-12 2 2000-03-13 dtype: datetime64[ns] >>> ser.searchsorted('3/14/2000') 3 >>> ser = pd.Categorical( ... ['apple', 'bread', 'bread', 'cheese', 'milk'], ordered=True ... ) >>> ser ['apple', 'bread', 'bread', 'cheese', 'milk'] Categories (4, object): ['apple' < 'bread' < 'cheese' < 'milk'] >>> ser.searchsorted('bread') 1 >>> ser.searchsorted(['bread'], side='right') array([3]) If the values are not monotonically sorted, wrong locations may be returned: >>> ser = pd.Series([2, 1, 3]) >>> ser 0 2 1 1 2 3 dtype: int64 >>> ser.searchsorted(1) # doctest: +SKIP 0 # wrong result, correct would be 1 searchsorted.znpt._ScalarLike_cozLiteral[('left', 'right')]r.znp.intp)rcsidesorterrBcCsdSrlr=r<rcrrr=r=r>rs zIndexOpsMixin.searchsortedznpt.ArrayLike | ExtensionArrayznpt.NDArray[np.intp]cCsdSrlr=rr=r=r>rsr)r4leftz$NumpyValueArrayLike | ExtensionArrayznpt.NDArray[np.intp] | np.intpcCs4|j}t|tjs"|j|||dStj||||dS)N)rr)rrmrprqrr")r<rcrrrr=r=r>rs firstcCs|j|d}||SN)keep) _duplicated)r<rr&r=r=r>drop_duplicatess zIndexOpsMixin.drop_duplicatesz!Literal[('first', 'last', False)]znpt.NDArray[np.bool_])rrBcCst|j|dSr)r&r)r<rr=r=r>rszIndexOpsMixin._duplicatedc Csjt||}|j}t|ddd}t||j}t|}tjddt |||}W5QRX|j ||dS)NT)Z extract_numpyZ extract_ranger)allr) r$Zget_op_result_namerr-Zmaybe_prepare_scalar_for_oprr,rpZerrstateZ arithmetic_op_construct_result)r<otherrZres_nameZlvaluesZrvaluesrr=r=r> _arith_methods zIndexOpsMixin._arith_methodcCs t|dS)z~ Construct an appropriately-wrapped result from the ArrayLike result of an arithmetic-like operation. Nr)r<rrr=r=r>rszIndexOpsMixin._construct_result)NT)NT)NT)NT)N)FTFNT)T)F)Fry)..)..)rN)r)r)9rUrVrWrXZ__array_priority__ frozensetrrYrZrrrTrrrtrrrrrrrrrrrrrrZto_listrrrr rr rr(r5rrrrrrr"rtextwrapdedentr1r rrrrrr=r=r=r>r2s   Bs, C, Y_'   # g  )RrX __future__rrtypingrrrrrrr r r numpyrpZpandas._libs.libZ_libsrZpandas._typingr r rrrrZ pandas.compatrZpandas.compat.numpyrrZ pandas.errorsrZpandas.util._decoratorsrrZpandas.core.dtypes.commonrrrrrZpandas.core.dtypes.genericrrrZpandas.core.dtypes.missingr r!Z pandas.corer"r#r$Zpandas.core.accessorr%Zpandas.core.algorithmsr&r'r(Zpandas.core.arrayliker)Zpandas.core.arraysr*Zpandas.core.constructionr+r,r-r.r/rr0r1rYZ_indexops_doc_kwargsr6r8r\ Exceptionrdrfrgr2r=r=r=r>sF ,           /"[