o ŀg @sUddlmZddlZddlmZmZddlZddlmZmZm Z m Z ddl Z ddl Z ddlmZddlmZmZmZmZddlmZddlmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$dd l%m&Z'dd l(m)Z)dd l*m+Z+dd l,m-Z-m.Z.dd l/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7ddl8m9Z9m:Z:ddl;mZ>m?Z?ddl@mAZAmBZBmCZCddlDmEZEmFZFmGZGmHZIddlJmKZKddlLmMZMmNZNddlOmPZPddlQmRZRddlSmTmUZVddlWmXZYmZZZm[Z[ddl\m]Z]ddl^m_Z_m`Z`erddlambZbmcZcddldmeZemfZfe e#e jgfZhe eeifZjiZkdeld<dddd Zmd!ekd"<e+ekd"dd#dddend$d%Gd&ddeeMZod+d)d*ZpdS),) annotationsN)lelt) TYPE_CHECKINGLiteralUnionoverload)lib) VALID_CLOSEDInterval IntervalMixinintervals_to_interval_bounds)NA) ArrayLikeAxisIntDtype FillnaOptionsIntervalClosedTypeNpDtypePositionalIndexer ScalarIndexerSelfSequenceIndexerSortKind TimeArrayLikenpt)function)IntCastingNaNError)Appender)LossySetitemErrormaybe_upcast_numeric_to_64bit)is_float_dtypeis_integer_dtype is_list_likeis_object_dtype is_scalaris_string_dtypeneeds_i8_conversion pandas_dtype)CategoricalDtype IntervalDtype) ABCDataFrameABCDatetimeIndexABCIntervalIndexABCPeriodIndex)is_valid_na_for_dtypeisnanotna)isintakeuniquevalue_counts_internal)ArrowExtensionArray)ExtensionArray_extension_array_shared_docs) DatetimeArray)TimedeltaArray)arrayensure_wrapped_if_datetimelike extract_array)check_array_indexer)invalid_comparisonunpack_zerodim_and_defer)IteratorSequence)IndexSerieszdict[str, str]_interval_shared_docs IntervalArrayzarrays.IntervalArray)klassqualnamenamea %(summary)s Parameters ---------- data : array-like (1-dimensional) Array-like (ndarray, :class:`DateTimeArray`, :class:`TimeDeltaArray`) containing Interval objects from which to build the %(klass)s. closed : {'left', 'right', 'both', 'neither'}, default 'right' Whether the intervals are closed on the left-side, right-side, both or neither. dtype : dtype or None, default None If None, dtype will be inferred. copy : bool, default False Copy the input data. %(name)sverify_integrity : bool, default True Verify that the %(klass)s is valid. Attributes ---------- left right closed mid length is_empty is_non_overlapping_monotonic %(extra_attributes)s Methods ------- from_arrays from_tuples from_breaks contains overlaps set_closed to_tuples %(extra_methods)s See Also -------- Index : The base pandas Index type. Interval : A bounded slice-like interval; the elements of an %(klass)s. interval_range : Function to create a fixed frequency IntervalIndex. cut : Bin values into discrete Intervals. qcut : Bin values into equal-sized Intervals based on rank or sample quantiles. Notes ----- See the `user guide `__ for more. %(examples)sclassz@Pandas array for interval data that are closed on the same side.a Examples -------- A new ``IntervalArray`` can be constructed directly from an array-like of ``Interval`` objects: >>> pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)]) [(0, 1], (1, 5]] Length: 2, dtype: interval[int64, right] It may also be constructed using one of the constructor methods: :meth:`IntervalArray.from_arrays`, :meth:`IntervalArray.from_breaks`, and :meth:`IntervalArray.from_tuples`. )rHsummaryrJextra_attributes extra_methodsexamplescsTeZdZUdZejZZedddZ de d<de d<d e d < ddddZ e dddZ e ddddZe d d dddd Ze dd$d%Zed&ed'<e eed'dd(ed)d*  ddd+d,Zed-ed.<e eed.dd(ed/d*  ddd0d1Zed2ed3<e eed3dd(ed4d*  ddd5d6Ze dd8d9Zdd:d;Zeddeded<eeddeddddZ?edddZ@eded<eeddedddddZAded<eeedeBd dd„ZC ddddƄZDdddȄZEedɡed<eedded̡d͜ddddЄZFdddԄZGdddلZHdddۄZIeeJdeB ddddZKeded<eeddeddddZLdddZMedddZNdddZOd ddZPZQS(!rFTreturn Literal[1]cCsdS)NselfrSrSO/var/www/html/myenv/lib/python3.10/site-packages/pandas/core/arrays/interval.pyndimzIntervalArray.ndim IntervalSide_left_rightr*_dtypeNFclosedIntervalClosedType | Nonedtype Dtype | Nonecopyboolverify_integrityc Cst|dd}t||r|j}|j}|p|j}t|j|d}n@t|r/|jd|d}t |t |}t ||dud\}}} |jt krMt |}t |}|pP| }|j|||||d\}}}|rh|j|||d|j|||dS) NT extract_numpyr]z5(...) must be called with a collection of some kind, z was passed)validate_closedr]rar_r_)r= isinstancerZr[r]r*r_r%__name__ TypeError _maybe_convert_platform_intervalr objectr maybe_convert_objects_ensure_simple_new_inputs _validate _simple_new) clsdatar]r_rarcleftrightmsg infer_closedrSrSrV__new__sD       zIntervalArray.__new__rurvrcCs t|}||_||_||_|SN)r ryrZr[r\)rsrurvr_resultrSrSrVrrs zIntervalArray._simple_new0tuple[IntervalSide, IntervalSide, IntervalDtype]c Csddlm}|||d}t|}|||d}t|}|dur&t|tr&|j}|p)d}|durgt|}t|trI|jdurH||j}||j}n d|}t ||jdur^t|j|}n ||jkrgt dt |j rxt |j rx||j }nt |j rt |j r||j }t|t|krdt|jd t|jd }t |t|j tst|j rd }t |t|trd }t |t|trt|jt|jkrd |jd|jd}t |t|j r|j|jkr|j|j\}} ||}|| }t|}t|dd}t|}t|dd}t|tst|trn(t|d|} t| d| j} t|d|} t| d| j} | durB| | urB|}t|j |d}|||fS)z;Ensure correctness of input parameters for cls._simple_new.r) ensure_indexraNrvz$dtype must be an IntervalDtype, got z*closed keyword does not match dtype.closedzmust not have differing left [z ] and right [z] typeszIcategory, object, and string subtypes are not supported for IntervalArrayz:Period dtypes are not supported, use a PeriodIndex insteadz2left and right must have the same time zone, got 'z' and ''Trd_ndarray_datarf) pandas.core.indexes.baser}r rjr*r]r(subtypeastyperl ValueErrorr!r_r"typerkr)r&r.r,strtzr'unitr_ensure_matching_resosr<r=r6getattrbasera) rsrurvr]rar_r}rwleft_arr right_arrlbaserbaserSrSrVrp&s                z'IntervalArray._ensure_simple_new_inputsr_racCs||||dS)NrrS)rsscalarsr_rarSrSrV_from_sequenceszIntervalArray._from_sequencevalues np.ndarrayoriginalcCs|j||jdS)Nri)rr_)rsrrrSrSrV_from_factorizedzIntervalArray._from_factorizedac Construct an %(klass)s from an array of splits. Parameters ---------- breaks : array-like (1-dimensional) Left and right bounds for each interval. closed : {'left', 'right', 'both', 'neither'}, default 'right' Whether the intervals are closed on the left-side, right-side, both or neither. %(name)s copy : bool, default False Copy the data. dtype : dtype or None, default None If None, dtype will be inferred. Returns ------- %(klass)s See Also -------- interval_range : Function to create a fixed frequency IntervalIndex. %(klass)s.from_arrays : Construct from a left and right array. %(klass)s.from_tuples : Construct from a sequence of tuples. %(examples)s from_breaksrGz Examples -------- >>> pd.arrays.IntervalArray.from_breaks([0, 1, 2, 3]) [(0, 1], (1, 2], (2, 3]] Length: 3, dtype: interval[int64, right] )rHrJrOcCs,t|}|j|dd|dd|||dS)NrRrar_)rm from_arrays)rsbreaksr]rar_rSrSrVrs$zIntervalArray.from_breaksaC Construct from two arrays defining the left and right bounds. Parameters ---------- left : array-like (1-dimensional) Left bounds for each interval. right : array-like (1-dimensional) Right bounds for each interval. closed : {'left', 'right', 'both', 'neither'}, default 'right' Whether the intervals are closed on the left-side, right-side, both or neither. %(name)s copy : bool, default False Copy the data. dtype : dtype, optional If None, dtype will be inferred. Returns ------- %(klass)s Raises ------ ValueError When a value is missing in only one of `left` or `right`. When a value in `left` is greater than the corresponding value in `right`. See Also -------- interval_range : Function to create a fixed frequency IntervalIndex. %(klass)s.from_breaks : Construct an %(klass)s from an array of splits. %(klass)s.from_tuples : Construct an %(klass)s from an array-like of tuples. Notes ----- Each element of `left` must be less than or equal to the `right` element at the same position. If an element is missing, it must be missing in both `left` and `right`. A TypeError is raised when using an unsupported type for `left` or `right`. At the moment, 'category', 'object', and 'string' subtypes are not supported. %(examples)s rz Examples -------- >>> pd.arrays.IntervalArray.from_arrays([0, 1, 2], [1, 2, 3]) [(0, 1], (1, 2], (2, 3]] Length: 3, dtype: interval[int64, right] cCsJt|}t|}|j|||||d\}}}|j|||d|j|||dS)Nrhri)rmrprqrr)rsrurvr]rar_rSrSrVrs zIntervalArray.from_arraysa Construct an %(klass)s from an array-like of tuples. Parameters ---------- data : array-like (1-dimensional) Array of tuples. closed : {'left', 'right', 'both', 'neither'}, default 'right' Whether the intervals are closed on the left-side, right-side, both or neither. %(name)s copy : bool, default False By-default copy the data, this is compat only and ignored. dtype : dtype or None, default None If None, dtype will be inferred. Returns ------- %(klass)s See Also -------- interval_range : Function to create a fixed frequency IntervalIndex. %(klass)s.from_arrays : Construct an %(klass)s from a left and right array. %(klass)s.from_breaks : Construct an %(klass)s from an array of splits. %(examples)s from_tuplesz Examples -------- >>> pd.arrays.IntervalArray.from_tuples([(0, 1), (1, 2)]) [(0, 1], (1, 2]] Length: 2, dtype: interval[int64, right] c Cst|r gg}}n|}}|D]T}t|ts!t|r!tj}} n9|j} z|\}} Wn/tyB} z | d|} t| | d} ~ wtyY} z | d|} t| | d} ~ ww| || | q|j |||d|dS)Nz..from_tuples requires tuples of length 2, got z'.from_tuples received an invalid item, Fr) lenrjtupler0npnanrkrrlappendr) rsrtr]rar_rurvdlhsrhsrJerrrwrSrSrVrLs*       zIntervalArray.from_tuplesNonecCst|tsd|}t|t|t|krd}t|t|}t|}||ks0d}t|||||ks@d}t|dS)z Verify that the IntervalArray is valid. Checks that * dtype is correct * left and right match lengths * left and right have the same missing values * left is always below right zinvalid dtype: z(left and right must have the same lengthzMmissing values must be missing in the same location both left and right sidesz+left side of interval must be <= right sideN)rjr*rrr1all)rsrurvr_rw left_mask right_maskrSrSrVrq~s  zIntervalArray._validatecCs6t|j|jd}|j|||d\}}}|j|||dS)a# Return a new IntervalArray with the replacement attributes Parameters ---------- left : Index Values to be used for the left-side of the intervals. right : Index Values to be used for the right-side of the intervals. rfri)r*r_r]rprrrUrurvr_rSrSrV _shallow_copys zIntervalArray._shallow_copycCs|jSrz)r\rTrSrSrVr_szIntervalArray.dtypeintcCs|jj|jjSrz)runbytesrvrTrSrSrVrrzIntervalArray.nbytescC|jjSrz)rusizerTrSrSrVrszIntervalArray.sizerAcCstt|Srz)iterrasarrayrTrSrSrV__iter__szIntervalArray.__iter__cC t|jSrz)rrZrTrSrSrV__len__ zIntervalArray.__len__keyr IntervalOrNAcCdSrzrSrUrrSrSrV __getitem__rXzIntervalArray.__getitem__rcCrrzrSrrSrSrVrrXrSelf | IntervalOrNAcCszt||}|j|}|j|}t|tjtfs)t|r"t|r"|j St |||j St |dkr4t d|j|||jdS)NrRz&multi-dimensional indexing not allowedri)r>rZr[rjrndarrayr7r%r0 _fill_valuer r]rWrrrr_)rUrrurvrSrSrVrs   cCs0||\}}t||}||j|<||j|<dSrz)_validate_setitem_valuer>rZr[)rUrvalue value_left value_rightrSrSrV __setitem__s  zIntervalArray.__setitem__c Cszt|rt|t|krtdt|}n*t|ts?|tur9ddlm}t j |j t d}t j |j t d}|||St|||St|trItd}n-t|jtsS|j}n#|jj}t|trv|j|jjkrit|||S|jjj|jd|jjd}t|tr|j|jkrt|||St|tst||}|tjur|j|jk|j|jk@S|tj ur|j|jk|j|jkBS|tj!ur|j|jk|j|jk|j|jk@BS|tj"ur||k||kBS|tj#ur|j|jk|j|jk|j|jk@BS||k||kBSt$|st|||St j%t|t d}t&|D]+\}} z |||| ||<Wqt'y:| tur6|(t)}t||<nYqw|S)NzLengths must match to comparer) BooleanArrayriintervalT allow_fill fill_value)*r#rrpd_arrayrjr rpandas.core.arraysrremptyshaperbonesr?r(r_r) categoriesr*r]_valuesr3codes _na_valueroperatoreqrZrur[rvnegtgerr$zeros enumeraterlrrn) rUotheroprarrmask other_dtyper{iobjrSrSrV _cmp_methodsp                            zIntervalArray._cmp_method__eq__cC||tjSrz)rrrrUrrSrSrVr6zIntervalArray.__eq____ne__cCrrz)rrrrrSrSrVr:rzIntervalArray.__ne____gt__cCrrz)rrrrrSrSrVr>rzIntervalArray.__gt____ge__cCrrz)rrrrrSrSrVrBrzIntervalArray.__ge____lt__cCrrz)rrrrrSrSrVrFrzIntervalArray.__lt____le__cCrrz)rrrrrSrSrVrJrzIntervalArray.__le__ quicksortlast ascendingkind na_positionrrrrrc sNt|d|}|r|dkr|dkrt|j|jfStjd|||d|S)NrSrrr)nvvalidate_argsort_with_ascendingrlexsortrvrusuperargsort)rUrrrkwargs __class__rSrVrNszIntervalArray.argsort)axisskipnarAxisInt | NonercCZt||jt|s|jS|}|r!|s|jS||}n|}|d}||S)Nrrvalidate_minmax_axisrWrrr0anyrrUrrrrindexerrSrSrVminb  zIntervalArray.mincCr)NrrrrSrSrVmaxsrzIntervalArray.max)limit limit_arearamethodrr int | Noner#Literal['inside', 'outside'] | Nonecstj||||dS)N)rrrra)r_pad_or_backfill)rUrrrrarrSrVr s zIntervalArray._pad_or_backfillc s\|durt|durtj|||dS||\}}|jj|d}|jj|d}|||S)a Fill NA/NaN values using the specified method. Parameters ---------- value : scalar, dict, Series If a scalar value is passed it is used to fill all missing values. Alternatively, a Series or dict can be used to fill in different values for each index. The value should not be a list. The value(s) passed should be either Interval objects or NA/NaN. method : {'backfill', 'bfill', 'pad', 'ffill', None}, default None (Not implemented yet for IntervalArray) Method to use for filling holes in reindexed Series limit : int, default None (Not implemented yet for IntervalArray) If method is specified, this is the maximum number of consecutive NaN values to forward/backward fill. In other words, if there is a gap with more than this number of consecutive NaNs, it will only be partially filled. If method is not specified, this is the maximum number of entries along the entire axis where NaNs will be filled. copy : bool, default True Whether to make a copy of the data before filling. If False, then the original should be modified and no new memory should be allocated. For ExtensionArray subclasses that cannot do this, it is at the author's discretion whether to ignore "copy=False" or to raise. Returns ------- filled : IntervalArray with NA/NaN filled FN)rrr)r)NotImplementedErrorrfillna_validate_scalarrurvr) rUrrrrarrrurvrrSrVr s" zIntervalArray.fillnac sHddlm}|durt|}t|tr|||jkr |r|S|St|jjr9t |jr9d|jd|d}t |z||j dd |j}||j dd |j}Wn$tyYt tfyu}zd|jd|d}t ||d}~ww|||Sz tj ||dWSt tfy}zd t|jd |}t ||d}~ww) a( Cast to an ExtensionArray or NumPy array with dtype 'dtype'. Parameters ---------- dtype : str or dtype Typecode or data-type to which the array is cast. copy : bool, default True Whether to copy the data, even if not necessary. If False, a copy is made only if the old dtype does not match the new dtype. Returns ------- array : ExtensionArray or ndarray ExtensionArray or NumPy ndarray with 'dtype' for its dtype. rrCNzCannot convert z to z; subtypes are incompatibleFr~z Cannot cast z to dtype )pandasrCr(rjr*r_rar!rr'rlrZrr[rrrrrrk)rUr_rarCrwnew_left new_rightrrrSrVrs>       zIntervalArray.astypecCs@t|t|kr dSt|j|jko|j|jo|j|jS)NF)rrbr]ruequalsrvrrSrSrVrs   zIntervalArray.equals to_concatSequence[IntervalArray]cCsxdd|D}t|dkrtd|}tdd|D}tdd|D}|j|||d\}}}|j|||d S) z Concatenate multiple IntervalArray Parameters ---------- to_concat : sequence of IntervalArray Returns ------- IntervalArray cSsh|]}|jqSrSrf.0rrSrSrV z2IntervalArray._concat_same_type..rRz.Intervals must all be closed on the same side.cSg|]}|jqSrS)rurrSrSrV rz3IntervalArray._concat_same_type..cSrrS)rvrrSrSrVrrrfri)rrpopr concatenaterprr)rsr closed_setr]rurvr_rSrSrV_concat_same_types zIntervalArray._concat_same_typecCs*|j}|j}|j}|j|||dS)zd Return a copy of the array. Returns ------- IntervalArray ri)rZrar[r_rrrrSrSrVras  zIntervalArray.copycCrrz)r0rZrTrSrSrVr0,rzIntervalArray.isnarRperiodsrrncCst|r|dkr |S||tt|t|}t|r7ddlm}||jddj }t |g|d}n |j |g||j d}|dkrP|}|d| }n |t|d}|}|||gS)NrrFr~rRri)rrar rabsr0rrCrZrrFrrr_r)rUrr empty_lenrCrabrSrSrVshift/s  zIntervalArray.shift)rrrrc KsVtd||}}|r||\}}t|j|||d}t|j|||d} ||| S)am Take elements from the IntervalArray. Parameters ---------- indices : sequence of integers Indices to be taken. 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 other negative values raise a ``ValueError``. fill_value : Interval or NA, 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 many ExtensionArrays, there will be two representations of `fill_value`: a user-facing "boxed" scalar, and a low-level physical NA value. `fill_value` should be the user-facing version, and the implementation should handle translating that to the physical version for processing the take if necessary. axis : any, default None Present for compat with IntervalIndex; does nothing. Returns ------- IntervalArray Raises ------ IndexError When the indices are out of bounds for the array. ValueError When `indices` contains negative values other than ``-1`` and `allow_fill` is True. rSr)r validate_taker r3rZr[r) rUindicesrrrr fill_left fill_right left_take right_takerSrSrVr3Ks 6   zIntervalArray.takec Cszt|}|j|dd|j|j}}Wnty-}z dt|d}t||d}~wwz |j|W||fSttfyT}z dt|d}t||d}~ww)NrrJz('value' should be an interval type, got z instead.z2'value' should be a compatible interval type, got )rF_check_closed_matchesrurvrlr_validate_fill_valuer)rUrr;rrrrwrSrSrV_validate_listlikes(  z IntervalArray._validate_listlikecCsXt|tr|j|dd|j|j}}||fSt||jjr(|jj}}||fStd)Nrr+z=can only insert Interval objects and NA into an IntervalArray) rjr r,rurvr/r_rrl)rUrrurvrSrSrVr s   zIntervalArray._validate_scalarcCst||jjr|jj}t|jjrtd||}}||fSt|trA|j |dd|j|j }}|j ||j |||fS| |S)Nz4Cannot set float NaN to integer-backed IntervalArrayrr+) r/rur_rr"rrlrjr r,rvr-r.)rUrrrrSrSrVrs      z%IntervalArray._validate_setitem_valuedropnarDcCsPttjddtdtt||d}Wd|S1s!wY|S)a2 Returns a Series containing counts of each interval. Parameters ---------- dropna : bool, default True Don't include counts of NaN. Returns ------- counts : Series See Also -------- Series.value_counts ignorez>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(2, 5)]) >>> interv_arr [(0, 1], (2, 5]] Length: 2, dtype: interval[int64, right] >>> interv_arr.left Index([0, 2], dtype='int64') rrFr~)rrCrZrUrCrSrSrVru zIntervalArray.leftcCr9)a Return the right endpoints of each Interval in the IntervalArray as an Index. Examples -------- >>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(2, 5)]) >>> interv_arr [(0, 1], (2, 5]] Length: 2, dtype: interval[int64, right] >>> interv_arr.right Index([1, 5], dtype='int64') rrFr~)rrCr[r:rSrSrVrvr;zIntervalArray.rightcCs |j|jS)a Return an Index with entries denoting the length of each Interval. Examples -------- >>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)]) >>> interv_arr [(0, 1], (1, 5]] Length: 2, dtype: interval[int64, right] >>> interv_arr.length Index([1, 4], dtype='int64') )rvrurTrSrSrVlengths zIntervalArray.lengthcCs6z d|j|jWSty|jd|jYSw)a Return the midpoint of each Interval in the IntervalArray as an Index. Examples -------- >>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)]) >>> interv_arr [(0, 1], (1, 5]] Length: 2, dtype: interval[int64, right] >>> interv_arr.mid Index([0.5, 3.0], dtype='float64') g?)rurvrlr<rTrSrSrVmid-s  zIntervalArray.midaI Check elementwise if an Interval overlaps the values in the %(klass)s. Two intervals overlap if they share a common point, including closed endpoints. Intervals that only have an open endpoint in common do not overlap. Parameters ---------- other : %(klass)s Interval to check against for an overlap. Returns ------- ndarray Boolean array positionally indicating where an overlap occurs. See Also -------- Interval.overlaps : Check whether two Interval objects overlap. Examples -------- %(examples)s >>> intervals.overlaps(pd.Interval(0.5, 1.5)) array([ True, True, False]) Intervals that share closed endpoints overlap: >>> intervals.overlaps(pd.Interval(1, 3, closed='left')) array([ True, True, True]) Intervals that only have an open endpoint in common do not overlap: >>> intervals.overlaps(pd.Interval(1, 2, closed='right')) array([False, True, False]) overlapsz >>> data = [(0, 1), (1, 3), (2, 4)] >>> intervals = pd.arrays.IntervalArray.from_tuples(data) >>> intervals [(0, 1], (1, 3], (2, 4]] Length: 3, dtype: interval[int64, right] )rHrOcCsxt|ttfr tt|tsdt|j}t||jr"|j r"t nt }|jr,|j r,t nt }||j |j ||j |j @S)Nz#`other` must be Interval-like, got )rjrFr-r r rrkrl closed_left closed_rightrrrurv)rUrrwop1op2rSrSrVr>ks zIntervalArray.overlapsrcCr)a String describing the inclusive side the intervals. Either ``left``, ``right``, ``both`` or ``neither``. Examples -------- For arrays: >>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)]) >>> interv_arr [(0, 1], (1, 5]] Length: 2, dtype: interval[int64, right] >>> interv_arr.closed 'right' For Interval Index: >>> interv_idx = pd.interval_range(start=0, end=2) >>> interv_idx IntervalIndex([(0, 1], (1, 2]], dtype='interval[int64, right]') >>> interv_idx.closed 'right' )r_r]rTrSrSrVr]szIntervalArray.closedaZ Return an identical %(klass)s closed on the specified side. Parameters ---------- closed : {'left', 'right', 'both', 'neither'} Whether the intervals are closed on the left-side, right-side, both or neither. Returns ------- %(klass)s %(examples)s set_closedav Examples -------- >>> index = pd.arrays.IntervalArray.from_breaks(range(4)) >>> index [(0, 1], (1, 2], (2, 3]] Length: 3, dtype: interval[int64, right] >>> index.set_closed('both') [[0, 1], [1, 2], [2, 3]] Length: 3, dtype: interval[int64, both] cCsF|tvr d|}t||j|j}}t|j|d}|j|||dS)Nzinvalid option for 'closed': rfri)r rrZr[r*r_rr)rUr]rwrurvr_rSrSrVrCs  zIntervalArray.set_closedak Return a boolean whether the %(klass)s is non-overlapping and monotonic. Non-overlapping means (no Intervals share points), and monotonic means either monotonic increasing or monotonic decreasing. Examples -------- For arrays: >>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)]) >>> interv_arr [(0, 1], (1, 5]] Length: 2, dtype: interval[int64, right] >>> interv_arr.is_non_overlapping_monotonic True >>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1), ... pd.Interval(-1, 0.1)]) >>> interv_arr [(0.0, 1.0], (-1.0, 0.1]] Length: 2, dtype: interval[float64, right] >>> interv_arr.is_non_overlapping_monotonic False For Interval Index: >>> interv_idx = pd.interval_range(start=0, end=2) >>> interv_idx IntervalIndex([(0, 1], (1, 2]], dtype='interval[int64, right]') >>> interv_idx.is_non_overlapping_monotonic True >>> interv_idx = pd.interval_range(start=0, end=2, closed='both') >>> interv_idx IntervalIndex([[0, 1], [1, 2]], dtype='interval[int64, both]') >>> interv_idx.is_non_overlapping_monotonic False is_non_overlapping_monotoniccCs|jdkr't|jdd|jddkp%|jdd|jddkSt|jdd|jddkpG|jdd|jddkS)NbothrrR)r]rbr[rZrrTrSrSrVrDs   z*IntervalArray.is_non_overlapping_monotonicNpDtype | None bool | Nonec Csj|j}|j}|}|j}tjt|td}t|D]\}} ||r(tj ||<qt | |||||<q|S)zt Return the IntervalArray's data as a numpy array of Interval objects (with dtype='object') ri) rZr[r0r]rrrrnrrr ) rUr_rarurvrr]r{r left_valuerSrSrV __array__"s zIntervalArray.__array__c Cs^ddl}ddlm}z ||jj}Wnty*}z td|jjd|d}~ww|||j}|jj |j |j |dd|j |j |ddgdd gd }| }|rs| |d } |jj|jt|| g|d|d gd }|dur||jr|St||r||std |jjd|jd|jd|jd ntd|d|j||S)z6 Convert myself into a pyarrow Array. rN)ArrowIntervalTypez"Conversion to arrow with subtype 'z' is not supportedT)r from_pandasrurv)namesrR)childrenzINot supported to convert IntervalArray to type with different 'subtype' (z vs z) and 'closed' (z ) attributesz+Not supported to convert IntervalArray to 'z' type)pyarrow(pandas.core.arrays.arrow.extension_typesrJfrom_numpy_dtyper_rrlr] StructArrayrr;rZr[r0rbuffers from_buffersrrfieldr storage_typerjr7 from_storage) rUrrNrJrr interval_type storage_arrayr null_bitmaprSrSrV__arrow_array__6sb      zIntervalArray.__arrow_array__am Return an %(return_type)s of tuples of the form (left, right). Parameters ---------- na_tuple : bool, default True If ``True``, return ``NA`` as a tuple ``(nan, nan)``. If ``False``, just return ``NA`` as ``nan``. Returns ------- tuples: %(return_type)s %(examples)s to_tupleszFndarray (if self is IntervalArray) or Index (if self is IntervalIndex)aq Examples -------- For :class:`pandas.IntervalArray`: >>> idx = pd.arrays.IntervalArray.from_tuples([(0, 1), (1, 2)]) >>> idx [(0, 1], (1, 2]] Length: 2, dtype: interval[int64, right] >>> idx.to_tuples() array([(0, 1), (1, 2)], dtype=object) For :class:`pandas.IntervalIndex`: >>> idx = pd.interval_range(start=0, end=2) >>> idx IntervalIndex([(0, 1], (1, 2]], dtype='interval[int64, right]') >>> idx.to_tuples() Index([(0, 1), (1, 2)], dtype='object') ) return_typerOna_tuplecCs2tt|j|j}|st||tj}|Srz) comasarray_tuplesafeziprZr[rwherer0r)rUr]tuplesrSrSrVr[{s!zIntervalArray.to_tuplesrnpt.NDArray[np.bool_]cCs||\}}t|jtjr)t|j||t|jtjsJt|j||dS|j||t|jtjr9J|j||dSrz)rrjrZrrputmaskr[_putmask)rUrrrrrSrSrVreszIntervalArray._putmasklocitemr cCs6||\}}|j||}|j||}|||S)ac Return a new IntervalArray inserting new item at location. Follows Python numpy.insert semantics for negative values. Only Interval objects and NA can be inserted into an IntervalIndex Parameters ---------- loc : int item : Interval Returns ------- IntervalArray )r ruinsertrvr)rUrfrg left_insert right_insertrrrSrSrVrhs zIntervalArray.insertcCsvt|jtjrt|j|}t|jtjsJt|j|}n|j|}t|jtjr.J|j|}|j||dS)Nrurv)rjrZrrdeleter[r)rUrfrrrSrSrVrls  zIntervalArray.deleterepeatrepeatsint | Sequence[int]cCs6tdd|i|j|}|j|}|j||dS)NrSrrk)rvalidate_repeatrurmrvr)rUrnr left_repeat right_repeatrSrSrVrms  zIntervalArray.repeata Check elementwise if the Intervals contain the value. Return a boolean mask whether the value is contained in the Intervals of the %(klass)s. Parameters ---------- other : scalar The value to check whether it is contained in the Intervals. Returns ------- boolean array See Also -------- Interval.contains : Check whether Interval object contains value. %(klass)s.overlaps : Check if an Interval overlaps the values in the %(klass)s. Examples -------- %(examples)s >>> intervals.contains(0.5) array([ True, False, False]) containsz >>> intervals = pd.arrays.IntervalArray.from_tuples([(0, 1), (1, 3), (2, 4)]) >>> intervals [(0, 1], (1, 3], (2, 4]] Length: 3, dtype: interval[int64, right] cCsHt|tr td|jr|j|kn|j|k|jr||jk@S||jk@S)Nz*contains not implemented for two intervals)rjr r  open_leftrZ open_rightr[rrSrSrVrss zIntervalArray.containsrcCst|trA|j|jkrtj|jtdS|j|jkr-|j d}|j d}t || St |j jt |j jArAtj|jtdSt |t|tS)Nri complex128)rjrFr]rrrrbr_ _combinedviewr2ravelr'rurrn)rUrrurvrSrSrVr2s      zIntervalArray.isincCsV|jjdd}|jjdd}t|jr |j||gdd}|Stj||gdd}|S)NrrR)r) rurreshapervr'r_rrr)rUrurvcombrSrSrVrw-s zIntervalArray._combinedcombinedcCs|ddd}|jj}t|rFt|jttfsJt|jj |dddf|d}t|j ttfs5Jt|j j |dddf|d}nt|t jsNJ|dddf|}|dddf|}|j ||dS) zY Create a new IntervalArray with our dtype from a 1D complex128 ndarray. i8rNrrirRrk) rxrzrZr_r'rjr9r:rrr[rr)rUr|ncr_rrrSrSrV_from_combined=s "zIntervalArray._from_combinedcCs6t|jddddf}|dddf}||S)Nrvr)r4rwrxr)rUrrSrSrVr4Os  zIntervalArray.unique)rPrQ)NNFT)r]r^r_r`rarbrcrb)rurYrvrYr_r*rPr)NFN)r]r^rarbr_r`rPr|)r_r`rarbrPr)rrrrFrPr)rvFN)r]r^rarbr_r`rPr)r_r*rPr)rPr)rPr*)rPr)rPrA)rrrPr)rrrPr)rrrPr)rPr)rrbrrrrrPr)rrrrbrPr) rrrrrr rarbrPr)NNNT)rrrarbrPr)T)rarb)rPrb)rrrPr)rPr)rRN)rrrrnrPrF)rrbrPr)r/rbrPrD)F)r7rb)rPrC)rPr)r]rrPr)NN)r_rFrarGrPrrz)r]rbrPr)rrcrPr)rfrrgr rPr)rnrorrrPr)rrrPrc)rPrY)r|rrPrF)rPrF)Rrk __module__ __qualname__ can_hold_narrrrpropertyrW__annotations__ry classmethodrrrprrtextwrapdedentrErrrrrqrr_rrrrrrrrr@rrrrrrrrrr r rrrrar0r$r3r.r rr6r8rurvr<r=r>r]rC_shared_docs_kwargsrDrIrZr[rerhrlr8rmrsr2rwrr4 __classcell__rSrSrrVrFs    3  `  2!          O      - =    E (  ,  4      rPrcCst|ttfrt|dkrtjgtjdSt|rt|tr |Stt |ddt r/t |}nt |ds>t|ttt fs>|St|dd}t |ds`t |}|jjdvr`|jtjkr`|tj}|S)a Try to do platform conversion, with special casing for IntervalArray. Wrapper around maybe_convert_platform that alters the default return dtype in certain cases to be compatible with IntervalArray. For example, empty lists return with integer dtype instead of object dtype, which is prohibited for IntervalArray. Parameters ---------- values : array-like Returns ------- array rrir_NTrdiu)rjlistrrrr;int64r#r+rr)rhasattrranger=r_rr)rrSrSrVrmYs     rm)rPr)q __future__rrrrrtypingrrrrr2numpyr pandas._libsr pandas._libs.intervalr r r r pandas._libs.missingrpandas._typingrrrrrrrrrrrrrpandas.compat.numpyrr pandas.errorsrpandas.util._decoratorsrpandas.core.dtypes.castrr pandas.core.dtypes.commonr!r"r#r$r%r&r'r(pandas.core.dtypes.dtypesr)r*pandas.core.dtypes.genericr+r,r-r.pandas.core.dtypes.missingr/r0r1pandas.core.algorithmsr2r3r4r5r6rr6pandas.core.arrays.baser7r8pandas.core.arrays.datetimesr9pandas.core.arrays.timedeltasr:pandas.core.commoncorecommonr^pandas.core.constructionr;rr<r=pandas.core.indexersr>pandas.core.opsr?r@collections.abcrArBrrCrDrrYfloatrrErrrrFrmrSrSrSrVs  <   (        =