+ Ŝi* a0t$^RIHt^RIt^RIHtHt^RIt^RIHtH t H t H t H t ^RI t^RIHt^RIHtHtHtHt^RIHt^RIHtHtHtHtHtHtHtH t H!t!H"t"H#t#^R I$H%t&^R I'H(t(^R I)H*t*^R I+H,t,H-t-^R I.H/t/H0t0H1t1H2t2H3t3H4t4H5t5H6t6^RI7H8t8H9t9^RI:H;t;Ht>^RI?H@t@HAtAHBtB^RICHDtDHEtEHFtF^RIGHHtH^RIIHJtJ^RIKHLtL^RIMHNtN^RIOHPuHQtR^RISHTtUHVtVHWtW^RIXHYtYHZtZ^RI[H\t\H]t]]'d^RI^H_t_H`t`Hata^RIbHctc]"]P,teR]fR&]]g,thR]fR&/tiR]fR&R R!R"R#R$R%/tjR&]iR'&]*!R(4!R)R!]]J44tkR*R+ltlR#),) annotationsN)lelt) TYPE_CHECKINGLiteralSelf TypeAliasoverload)lib) VALID_CLOSEDInterval IntervalMixinintervals_to_interval_bounds)NA) ArrayLikeAxisIntDtypeIntervalClosedTypeNpDtypePositionalIndexer ScalarIndexerSequenceIndexerSortKind TimeArrayLikenpt)function)IntCastingNaNError) set_module)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)isintakeunique)ArrowExtensionArray)ExtensionArray) DatetimeArray)TimedeltaArray)arrayensure_wrapped_if_datetimelike extract_array)check_array_indexergetitem_returns_view)invalid_comparisonunpack_zerodim_and_defer)CallableIteratorSequenceIndexr IntervalSide IntervalOrNAzdict[str, str]_interval_shared_docsklass IntervalArrayqualnamezarrays.IntervalArraynamea %(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.arraysca]tRt^t$RtRt]P;tt ] RRl4t R] R&R] R&R] R &RR R llt ]RRl4t]RRRll4t]RR RR /RRll4t]RRl4t]P(!R4]R&]RRRll4t]P(!R4]R&]RRRll4t]P(!R 4]R!&]RR"R#ll4t]R$R%l4tR&R'lt] R(R)l4t] R*R+l4t] R,R-l4tR.R/ltR0R1lt] R2R3l4t!] R4R5l4t!R6R7lt!R8R9lt"R:t#]$!R;4R<4t%]$!R=4R>4t&]$!R?4R@4t']$!RA4RB4t(]$!RC4RD4t)]$!RE4RF4t*RGRRHRIRJRK/RLV3RMlllt+RNR ROR/RPRQllt,RNR ROR/RRRSllt-RRTRUllt.RRVV3RWlllt/RXRYlt0]RZR[l4t1R\R]lt2R^R_lt3RR`Rallt4RbR RcR RNR /RdRellt5Rft6Rgt7Rht8RRiRjllt9] RkRll4t:] RmRnl4t;] RoRpl4t<] RqRrl4t=]P(!Rs4]Rt&Rut>] RvRwl4t?]P(!Rx4]Ry&RzR{lt@R|]R}&] R~Rl4tARRRlltBRRltC]P(!R4]R&RRRlltDRRltERRltFRRltGRRRlltH]P(!R4]R&RtIRRltJ] RRl4tKRRltLRRltMRtNV;tO#)rIa Pandas array for interval data that are closed on the same side. Parameters ---------- data : array-like (1-dimensional) Array-like (ndarray, :class:`DateTimeArray`, :class:`TimeDeltaArray`) containing Interval objects from which to build the IntervalArray. 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. verify_integrity : bool, default True Verify that the IntervalArray is valid. Attributes ---------- left right closed mid length is_empty is_non_overlapping_monotonic Methods ------- from_arrays from_tuples from_breaks contains overlaps set_closed to_tuples See Also -------- Index : The base pandas Index type. Interval : A bounded slice-like interval; the elements of an IntervalArray. 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 -------- 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`. TcV^8dQhRR/#)returnz Literal[1])formats"d/Users/mibo/.openclaw/workspace/.venv-ak/lib/python3.14/site-packages/pandas/core/arrays/interval.py __annotate__IntervalArray.__annotate__sjc ^#)rRselfs&rTndimIntervalArray.ndimsrWrE_left_rightr*_dtypeNFc ,V^8dQhRRRRRRRRRR /#) rPclosedIntervalClosedType | Nonedtype Dtype | Nonecopyboolverify_integrityrQrrR)rSs"rTrUrV s>1 1 *1  1  1  1  1 rWc \VRR7p\W4'dGVPpVPpT;'g VPp\ VP VR7pM\V4'dVP RV R2p\V4h\V4p\WRJR7wrgp VP \8Xd-\P!V4p\P!V4pT;'gT pVPVVVVVR7wrgpV'dVP!WgVR7VP#VVVR7#) T extract_numpyrbz5(...) must be called with a collection of some kind, z was passedN)validate_closedrbrfrdrd)r; isinstancer^r_rbr*rdr%__name__ TypeError _maybe_convert_platform_intervalrobjectr maybe_convert_objects_ensure_simple_new_inputs _validate _simple_new) clsdatarbrdrfrhleftrightmsg infer_closeds &&&&&& rT__new__IntervalArray.__new__ s>T6 d !%D"&++E**t{{F!$**V!> "?" D  MM$UM 3    rWc(V^8dQhRRRRRRRR/#)rPr{rEr|rdr*rQrrR)rSs"rTrUrV>s2       rWc V\P!V4pWnW$nW4nV#N)rrr^r_r`)ryr{r|rdresults&&&& rTrxIntervalArray._simple_new=s(&&s+    rWc(V^8dQhRRRRRRRR/#) rPrbrcrfrgrdrerQz0tuple[IntervalSide, IntervalSide, IntervalDtype]rR)rSs"rTrUrVLs:j"j"* j"  j"  j" :j"rWc ( ^RIHpV!WR7p\V4pV!W$R7p\V4pVf#\V\4'd VP pT;'gRpVe\ V4p\V\4'dFVPe7VPVP4pVPVP4pMRV 2p\V4hVP f\ VPV4pMW5P 8wd \R4h\VP4'd8\VP4'dVPVP4pMQ\VP4'd7\VP4'dVPVP4p\V4\V48wd;R\V4P R\V4P R2p\V4h\VP\ 4'g\#VP4'dR p\V4h\V\$4'dR p\V4h\V\&4'dV\)VP*4\)VP*48wd)R VP* R VP* R 2p\V4h\-VP4'dSVP.VP.8wd8VP0P3VP04wrV!V4pV!V 4p\5V4p\7VRR7p\5V4p\7VRR7p\V\84'g\V\84'dMa\;VRV4p \;V RV 4P<p \;VRV4p \;V RV 4P<p V eWJdVP?4p\ VPVR7pVPp VPp V P@R9d?V P@R9d.V P@V P@8wd\RV RV R24hWV3#)z;Ensure correctness of input parameters for cls._simple_new.) ensure_indexrfr|z$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 ''Trj_ndarray_datarliuz9Left and right arrays must have matching signedness. Got z and .)!pandas.core.indexes.baserr rpr*rbr(subtypeastyperr ValueErrorr!rdr"typerqr)r&r.r,strtzr'unitr_ensure_matching_resosr:r;r5getattrbaserfkind)ryr{r|rbrfrdrr}left_arr right_arrlbaserbase left_dtype right_dtypes&&&&&& rTrv'IntervalArray._ensure_simple_new_inputsKs :D,,T2U.-e4 >j >>\\F""7   'E%//==,;;u}}5D!LL7E>> pd.arrays.IntervalArray.from_breaks([0, 1, 2, 3]) [(0, 1], (1, 2], (2, 3]] Length: 3, dtype: interval[int64, right] NrYNNrfrd)rs from_arrays)rybreaksrbrfrds&&&&&rTrIntervalArray.from_breakss1R2&9vcr{F2JQVWWrWaC 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 rc(V^8dQhRRRRRRRR/#rrR)rSs"rTrUrVEs:G9G9* G9  G9  G9 G9rWc \V4p\V4pVPVVVVVR7wrpVPWVR7VPWVR7#)a 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. copy : bool, default False Copy the data. dtype : dtype, optional If None, dtype will be inferred. Returns ------- IntervalArray 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. IntervalArray.from_breaks : Construct an IntervalArray from an array of splits. IntervalArray.from_tuples : Construct an IntervalArray 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 -------- >>> pd.arrays.IntervalArray.from_arrays([0, 1, 2], [1, 2, 3]) [(0, 1], (1, 2], (2, 3]] Length: 3, dtype: interval[int64, right] rnro)rsrvrwrx)ryr{r|rbrfrds&&&&&&rTrIntervalArray.from_arraysDsgx0507 ::   ; U d /t%88rWa 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_tuplesc(V^8dQhRRRRRRRR/#rrR)rSs"rTrUrVs@@M@M*@M @M  @M  @MrWc \V4'd..reMT;rVVFop\V\4'g$\V4'd\P ;rMVP p VwrVPV4VPV 4Kq VPWVVRVR7# \dp T RT 2p \T 4T hRp ? i\dp T RT 2p \T 4T hRp ? ii;i)a Construct an IntervalArray 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. 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 ------- IntervalArray See Also -------- interval_range : Function to create a fixed frequency IntervalIndex. IntervalArray.from_arrays : Construct an IntervalArray from a left and right array. IntervalArray.from_breaks : Construct an IntervalArray from an array of splits. Examples -------- >>> pd.arrays.IntervalArray.from_tuples([(0, 1), (1, 2)]) [(0, 1], (1, 2]] Length: 2, dtype: interval[int64, right] z..from_tuples requires tuples of length 2, got Nz'.from_tuples received an invalid item, Fr) lenrptupler0npnanrqrrrappendr) ryrzrbrfrdr{r|dlhsrhsrKerrr}s &&&&& rTrIntervalArray.from_tuplessT t99b% DAa''DGGFF"c||2 HC KK  LL "tFeLL"3!F"PQRPSTC$S/s2 2!F"I!MC#C.c12s*$B## C'.C C'C'C""C'c V^8dQhRRRR/#)rPrdr*rQNonerR)rSs"rTrUrVs""="T"rWc x\V\4'gRV 2p\V4h\V4\V48wdRp\V4h\ V4p\ V4pWV8HP 4'gRp\V4hW,W%,8*P 4'gRp\V4hR#)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)rpr*rrr1all)ryr{r|rdr} left_mask right_masks&&&& rTrwIntervalArray._validates%//#E7+CS/ ! t9E ">><= ="&">">u"E !$,$ 3& CrWc \V4'd1\V4\V48wd \R4h\V4pM\ V\ 4'gqV\ Jd[^RIHp\P!VP\R7p\P!VP\R7pV!WE4#\WV4#\ V\ 4'd \R4pM\ VP \"4'gVP pMVP$P p\ V\&4'dxVP(VP$P(8wd \WV4#VP$P*P-VP.RVP$P0R7p\ V\&4'EdVP(VP(8wd \WV4#\ V\ 4'g\3V4!V4pV\4P6Jd8VP8VP:8HVP<VP>8H,#V\4P@Jd8VP8VP:8gVP<VP>8g,#V\4PBJdVVP8VP:8VP8VP:8HVP<VP>8,,#V\4PDJdW8HW8,#V\4PFJdVVP8VP:8VP8VP:8HVP<VP>8,,#W8HW8,#\IV4'g \WV4#\PJ!\V4\R7p\MV4FwrV!W,V 4Wx&K V# \Nd-T \ Jd!TPQ\R4p\ Yx&KRhi;i)zLengths must match to compare) BooleanArrayrointervalT allow_fill fill_value)*r#rrpd_arrayrpr rpandas.core.arraysrremptyshapergonesr>r(rdr) categoriesr*rb_valuesr3codes _na_valueroperatoreqr^r{r_r|negtgerr$zeros enumeraterrrrt) r[otheroprarrmask other_dtyperiobjs &&& rT _cmp_methodIntervalArray._cmp_method_s2   4yCJ& !@AAUOEE8,,{;hhtzz6wwtzz6#C..%d26 6 eX & &&z2KEKK)9::++K **00K+}55;;%"2"2"9"99-d2>>((0055KKDU=M=M=W=W6 k= 1 1{{ell*)$r::x00T 5)X[[  ejj0T[[EKK5OPPx{{" ejj0T[[EKK5OPPx{{" UZZ/ZZ5::-$++ 2KLx{{" $,77x{{" UZZ/ZZ5::-$++ 2KL  $,77{++%d26 6#d)40&FA tw, '  "9$]]62F "FI sP2QQ__eq__c BVPV\P4#r)rrrr[rs&&rTr!IntervalArray.__eq__x{{33rW__ne__c BVPV\P4#r)rrrr#s&&rTr&IntervalArray.__ne__r%rW__gt__c BVPV\P4#r)rrrr#s&&rTr)IntervalArray.__gt__r%rW__ge__c BVPV\P4#r)rrrr#s&&rTr,IntervalArray.__ge__r%rW__lt__c BVPV\P4#r)rrrr#s&&rTr/IntervalArray.__lt__r%rW__le__c BVPV\P4#r)rrrr#s&&rTr2IntervalArray.__le__r%rW ascendingr quicksort na_positionlastc(V^8dQhRRRRRRRR/#) rPr5rgrrr7rrQrrR)rSs"rTrUrVs4         rWc <\P!VRV4pV'd;VR8Xd4VR8Xd-\P!VPVP 34#\ SV`!RRVRVRV/VB#)r6r8r5rr7rR)nvvalidate_argsort_with_ascendingrlexsortr|r{superargsort)r[r5rr7kwargs __class__s&$$$,rTr?IntervalArray.argsorts{66y"fM ,1F::tzz49956 6w  &* 8C GM  rWaxisskipnac$V^8dQhRRRRRR/#rPrCAxisInt | NonerDrgrQrFrR)rSs"rTrUrV!>$,rWc F\P!WP4\V4'g VP#VP 4pVP 4'dV'g VP#W(,pMTpVP4^,pWE,#)rr;validate_minmax_axisr\rrr0anyr?r[rCrDrrindexers&$$ rTminIntervalArray.minsp ii04yy>> !yy{ 88::~~%u+CC++-"|rWc$V^8dQhRRRRRR/#rFrR)rSs"rTrUrVrHrWc F\P!WP4\V4'g VP#VP 4pVP 4'dV'g VP#W(,pMTpVP4R,pWE,#)rYrrJrMs&$$ rTmaxIntervalArray.maxsp ii04yy>> !yy{ 88::~~%u+CC++-#|rWc$V^8dQhRRRRRR/#)rPlimitz int | NonerfrgrQrrR)rSs"rTrUrVs!!/!/:!/D!/D!/rWc VRJd\hVe \R4hVPV4wrEVPP VR7pVP P VR7pVP Wg4#)af 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. limit : int, default None (Not implemented yet for IntervalArray) The maximum number of entries where NA values 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 Fzlimit must be None)r)NotImplementedErrorr_validate_scalarr{fillnar|r)r[rrVrfrrr{r|s&&&& rTrZIntervalArray.fillnasu0 5=% %  12 2"&"7"7"> yyj1 !! !4!!$..rWcV^8dQhRR/#)rPrfrgrR)rSs"rTrUrVs;.;.$;.rWc j<^RIHpVe \V4p\V\4'dWP 8XdV'dVP 4#T#\VP P4'd:\VP4'dRVP RV R2p\V4hV!VPRR7PVP4pV!VPRR7PVP4pTP!YV4#\"SV`1WR7# \dh\\3d%pRTP RT R2p\T4ThRp?ii;i \\3d-pR\%T4P& R T 2p\T4ThRp?ii;i) 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. rCNzCannot convert z to z; subtypes are incompatibleFrz Cannot cast z to dtype )pandasrDr(rpr*rdrfr!rr'rrr^rr_rrrr>rrq) r[rdrfrDr}new_left new_rightrrAs &&& rTrIntervalArray.astypes& !   'E e] + + "&*tyy{44djj00116I 77 &djj\eW>> 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') rCFr)r^rDr^r[rDs& rTr{IntervalArray.left8s@ !TZZe,,rWcV^8dQhRR/#rrR)rSs"rTrUrV]s . .u .rWc 6^RIHpV!VPRR7#)a Return the right endpoints of each Interval in the IntervalArray as an Index. This property extracts the right endpoints from each interval contained within the IntervalArray. This can be helpful in use cases where you need to work with or compare only the upper bounds of intervals, such as when performing range-based filtering, determining interval overlaps, or visualizing the end boundaries of data segments. See Also -------- arrays.IntervalArray.left : Return the left endpoints of each Interval in the IntervalArray as an Index. arrays.IntervalArray.mid : Return the midpoint of each Interval in the IntervalArray as an Index. arrays.IntervalArray.contains : Check elementwise if the Intervals contain the value. 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') rCFr)r^rDr_rs& rTr|IntervalArray.right\s> !T[[u--rWcV^8dQhRR/#rrR)rSs"rTrUrVs&&&rWc <VPVP, #)a Return an Index with entries denoting the length of each Interval. The length of an interval is calculated as the difference between its `right` and `left` bounds. This property is particularly useful when working with intervals where the size of the interval is an important attribute, such as in time-series analysis or spatial data analysis. See Also -------- arrays.IntervalArray.left : Return the left endpoints of each Interval in the IntervalArray as an Index. arrays.IntervalArray.right : Return the right endpoints of each Interval in the IntervalArray as an Index. arrays.IntervalArray.mid : 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.length Index([1, 4], dtype='int64') )r|r{rZs&rTlengthIntervalArray.lengths<zzDII%%rWcV^8dQhRR/#rrR)rSs"rTrUrVs11U1rWc RVPVP,,# \d(TPRTP,,u#i;i)a Return the midpoint of each Interval in the IntervalArray as an Index. The midpoint of an interval is calculated as the average of its ``left`` and ``right`` bounds. This property returns a ``pandas.Index`` object containing the midpoint for each interval. See Also -------- Interval.left : Return left bound for the interval. Interval.right : Return right bound for the interval. Interval.length : Return 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.mid Index([0.5, 3.0], dtype='float64') g?)r{r|rrrrZs&rTmidIntervalArray.midsF4 1$))djj01 1 199sT[[00 0 1s#&/AAaH 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 : Interval 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]) overlapsc \V\\34'd\h\V\4'g$R\ V4P 2p\V4hVP'dVP'd\M\pVP'dVP'd\M\pV!VPVP4V!VPVP4,#)a+ Check elementwise if an Interval overlaps the values in the IntervalArray. 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 : IntervalArray 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 -------- >>> 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] >>> 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]) z#`other` must be Interval-like, got )rprIr-rXr rrqrr closed_left closed_rightrrr{r|)r[rr}op1op2s&& rTrIntervalArray.overlapssX em-=> ? ?% %%**7U 8L8L7MNCC. %%%%*<*<*>> 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' )rdrbrZs&rTrbIntervalArray.closed$sDzz   rWaZ 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_closedc V^8dQhRRRR/#)rPrbrrQrrR)rSs"rTrUrVZs&:&:!3&:&:rWc V\9dRV 2p\V4hVPVPrC\ VP VR7pVP W4VR7#)a Return an identical IntervalArray 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 ------- IntervalArray A new IntervalArray with the specified side closures. See Also -------- IntervalArray.closed : Returns inclusive side of the Interval. arrays.IntervalArray.closed : Returns inclusive side of the IntervalArray. 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] zinvalid option for 'closed': rlro)r rr^r_r*rdrx)r[rbr}r{r|rds&& rTrIntervalArray.set_closedZsX@  %1&:CS/ !jj$++edjj8599rWak 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_monotoniccV^8dQhRR/#rcrR)rSs"rTrUrVsA A dA rWc VPR8Xdt\VPRRVPR,8P 4;'g2VPRRVPR,8P 44#\VPRRVPR,8*P 4;'g2VPRRVPR,8P 44#)a Return a boolean whether the IntervalArray/IntervalIndex is non-overlapping and monotonic. Non-overlapping means (no Intervals share points), and monotonic means either monotonic increasing or monotonic decreasing. See Also -------- overlaps : Check if two IntervalIndex objects overlap. 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 bothNrr)rbrgr_r^rrZs&rTr*IntervalArray.is_non_overlapping_monotonicsn ;;& Sb!DJJrN2779==JJsOdkk"o5::<  [[" B / 4 4 6 : : 3B4;;r?2779  rWc$V^8dQhRRRRRR/#)rPrdzNpDtype | Nonerfz bool | NonerQrrR)rSs"rTrUrVs$#2= rWc pVRJd \R4hVPpVPpVP4pVPp\ P !\V4\R7p\V4F<wrWX,'d\ PWx&K'\WV,V4Wx&K> V#)z\ Return the IntervalArray's data as a numpy array of Interval objects (with dtype='object') Fz:Unable to avoid copy while creating an array as requested.ro) rr^r_r0rbrr rrtrrr ) r[rdrfr{r|rrbrr left_values &&& rT __array__IntervalArray.__array__s 5=L zz yy{#d)62&t_MAwwFF $Zq6B -  rWc  n^RIp^RIHpVPVPP 4pT!Y@P4pTPPTPTPTRR7TPTPTRR7.RR.R 7pTP4pTP4'd{TPT(4P4^,p TPP!TP"\%T4T .TP'^4TP'^4.R 7pTeTP)TP*4'dT#\-Y4'dcTP)T4'gK\ R TPP R TP R TP R TP R2 4hM\ RT R24hTP.P1Yg4# \ d*p\ RTPP R24ThRp?ii;i)z& Convert myself into a pyarrow Array. N)ArrowIntervalTypez"Conversion to arrow with subtype 'z' is not supportedT)r from_pandasr{r|)names)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_typesrfrom_numpy_dtyperdrrrrb StructArrayrr9r^r_r0rLbuffers from_buffersrrfieldrf storage_typerpr6 from_storage) r[rrrrr interval_type storage_arrayr null_bitmaps && rT__arrow_array__IntervalArray.__arrow_array__ s N ..tzz/A/ABG *';;? ++77 djjwD I dkkT J 7# 8 yy{ 88::!--.668;K#//<<""M" '--a0-2E2Ea2HI =M  {{=5566$$D44{{=11#004 0B0B/C4 ~V))- T$++lT2 A$vN%%22=PPQ 4TZZ5G5G4HI##  s%H H4 $H//H4am 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_tuplesc V^8dQhRRRR/#)rPna_tuplergrQrrR)rSs"rTrUrVQs22$2*2rWc \P!\VPVPRR74pV'g6\ P !VP4(V\ P4pV#)a Return an ndarray (if self is IntervalArray) or Index (if self is IntervalIndex) 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 ------- ndarray or Index An ndarray of tuples representing the intervals if `self` is an IntervalArray. An Index of tuples representing the intervals if `self` is an IntervalIndex. See Also -------- IntervalArray.to_list : Convert IntervalArray to a list of tuples. IntervalArray.to_numpy : Convert IntervalArray to a numpy array. IntervalArray.unique : Find unique intervals in an IntervalArray. 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([(np.int64(0), np.int64(1)), (np.int64(1), np.int64(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') T)strict) comasarray_tuplesafezipr^r_rwherer0r)r[rtupless&& rTrIntervalArray.to_tuplesQsL\&&s4::t{{4'PQXXtyy{lFBFF;F rWc V^8dQhRRRR/#)rPrnpt.NDArray[np.bool_]rQrrR)rSs"rTrUrVs 4 42 4d 4rWc $VPV4wr4\VP\P4'dq\P !VPW4\VP \P4'gQh\P !VP W4R#VPPW4\VP \P4'dQhVP PW4R#r)rrpr^rrputmaskr__putmask)r[rrrrs&&& rTrIntervalArray._putmasks"&">">u"E djj"** - - JJtzz4 4dkk2::66 66 JJt{{D 6 JJ   1!$++rzz:: :: KK  3rWc$V^8dQhRRRRRR/#)rPlocritemr rQrrR)rSs"rTrUrVs!77#7X7$7rWc VPV4wr4VPPW4pVPPW4pVP WV4#)a  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 )rYr{insertr|r)r[rr left_insert right_insertr_r`s&&& rTrIntervalArray.insertsP%)$9$9$$?! 99##C5JJ%%c8 !!(66rWcV^8dQhRR/#rrR)rSs"rTrUrVs B BT BrWc \VP\P4'dp\P!VPV4p\VP \P4'gQh\P!VP V4pMbVPP V4p\VP \P4'dQhVP P V4pVP W#R7#)r{r|)rpr^rrdeleter_r)r[rr_r`s&& rTrIntervalArray.deletes djj"** - -yyS1Hdkk2::66 66 $++s3Izz((-H!$++rzz:: :: **3/I!!x!AArWc$V^8dQhRRRRRR/#)rPrepeatszint | Sequence[int]rCrGrQrrR)rSs"rTrUrVs-1H1H$1H1H  1HrWc \P!RRV/4VPPV4pVPPV4pVP W4R7#)a3 Repeat elements of an IntervalArray. Returns a new IntervalArray where each element of the current IntervalArray is repeated consecutively a given number of times. Parameters ---------- repeats : int or array of ints The number of repetitions for each element. This should be a non-negative integer. Repeating 0 times will return an empty IntervalArray. axis : None Must be ``None``. Has no effect but is accepted for compatibility with numpy. Returns ------- IntervalArray Newly created IntervalArray with repeated elements. See Also -------- Series.repeat : Equivalent function for Series. Index.repeat : Equivalent function for Index. numpy.repeat : Similar method for :class:`numpy.ndarray`. ExtensionArray.take : Take arbitrary positions. Examples -------- >>> cat = pd.Categorical(["a", "b", "c"]) >>> cat ['a', 'b', 'c'] Categories (3, str): ['a', 'b', 'c'] >>> cat.repeat(2) ['a', 'a', 'b', 'b', 'c', 'c'] Categories (3, str): ['a', 'b', 'c'] >>> cat.repeat([1, 2, 3]) ['a', 'b', 'b', 'c', 'c', 'c'] Categories (3, str): ['a', 'b', 'c'] rCrrR)r;validate_repeatr{repeatr|r)r[rrC left_repeat right_repeats&&& rTrIntervalArray.repeatsU\ 2~.ii&&w/ zz((1 !!{!GGrWa 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]) containsc \V\4'd \R4hVP'dVPV8MVPV8*VP 'dWP 8,#WP 8*,#)a  Check elementwise if the Intervals contain the value. Return a boolean mask whether the value is contained in the Intervals of the IntervalArray. Parameters ---------- other : scalar The value to check whether it is contained in the Intervals. Returns ------- boolean array A boolean mask whether the value is contained in the Intervals. See Also -------- Interval.contains : Check whether Interval object contains value. IntervalArray.overlaps : Check if an Interval overlaps the values in the IntervalArray. Examples -------- >>> 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] >>> intervals.contains(0.5) array([ True, False, False]) z*contains not implemented for two intervals)rpr rX open_leftr^ open_rightr_r#s&&rTrIntervalArray.containssmD eX & &%&RS S&*nnn U"$**:M#'???EKK   8=8L  rWc V^8dQhRRRR/#)rPrrrQrrR)rSs"rTrUrV0s@@9@)>@rWc \V\4'EdVPVP8wd'\P!VP \ R7#VPVP8Xd=VPpVPp\P!W#4P4#\VPP4\VPP4, 'd'\P!VP \ R7#\VP\4VP\44#r)rprIrbrrr rgrd _combinedr2ravelr'r{rrt)r[rr{r|s&& rTr2IntervalArray.isin0s fm , ,{{fmm+xx $77zzV\\)~~((wwt+1133$TYY__58K !!9xx $77DKK'v)>??rWcV^8dQhRR/#)rPrQrErR)rSs"rTrUrVDs<rWc VPPPR^4pVPPPR^4p\ VP 4'd/VP W.^R7pVPR4R,pV#\P!VP4RR7pVP4Vn V#)rY)rC complex128rorNNNr) r{rreshaper|r'rdrnviewrrrimag)r[r{r|combs& rTrIntervalArray._combinedCsyy  ((Q/ ""**2q1 tzz * *)) A*D99\*40D ::djjl,?D DI rWc V^8dQhRRRR/#)rPcombinedrrQrIrR)rSs"rTrUrVWsBBzBmBrWc VPPp\V4'dVPR4P R^4p\ VP\ \34'gQh\VP4PVR,VR7p\ VP\ \34'gQh\VP4PVR,VR7pM\ V\P4'gQh\P!V4PV4P4p\P!V4PV4P4pVP!WER7#)zI Create a new IntervalArray with our dtype from a 1D complex128 ndarray. i8rorrr)rrY)r^rdr'rrrpr7r8rrr_rrealrrr r)r[r rdncr_r`s&& rT_from_combinedIntervalArray._from_combinedWs2     u % %t$,,R3Bdjj=.*IJJ JJDH EnRXUn3 dkkM>+JKK KKEI FnRXUn3 eRXX.. ..wwx(//6<<>H)007==?I!!x!AArWcV^8dQhRR/#)rPrQrIrR)rSs"rTrUrVms<< '#:;;rWrR)NNFT)NFN)r|FN)NT)T)rYNre)NNr)Prq __module__ __qualname____firstlineno____doc__ can_hold_narrrrpropertyr\__annotations__r classmethodrxrvrrtextwrapdedentrGrrrrwrrdrrrrr rrrr?r!r&r)r,r/r2r?rOrSrZrrfrnrfr0r}r3rrYrrr{r|rrrrbrrrrrrrrrrr2rrr4__static_attributes__ __classcell__)rAs@rTrIrIs@DK ff$I      1 f  j"j"X4# 4  44@@,4?? ,-(>*X*XX,4??. 0,-(dG9G9R,4?? ,-(B@M@MD""::&44&BB <<,'M^h'4(4h'4(4h'4(4h'4(4h'4(4h'4(4  %  "   (D"D"!/F;.;.z 990 : .11>)1$ &)*%P9Iz!!!!F+3// +,'$&:P(= 89TA A L22Qh*2 *+&"2l 47, B1Hf)1 )*%<' R@&&B,<r?collections.abcr@rArBr^rDrrErfloatrFrG_shared_docs_kwargsrIrs)r)s@rTrFsR"" $    /,.      378     ("**4 i4"U* i*(*~* _& B8"gv Oww<w