Pi dZddlmZddlmZmZddlmZmZm Z m Z ddl Z ddl mZddlmZmZmZddlmZmZmZmZmZdd lmZdd lmZmZdd lmZdd l m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&dd l'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1ddl2m3Z3m4Z4ddl5m6Z6ddl7m8Z8ddl9m:Z:ddl;mcm?Z@ddlAmBZBddlCmDZDmEZEmFZFddlGmHZHmIZIddlJmKZKmLZLddlMmNZNddlOmPZPmQZQerddlRmSZSddlTmUZUmVZVmWZWmXZXdZYdZZdZ[eLddge`__ for more. Examples -------- A new ``IntervalIndex`` is typically constructed using :func:`interval_range`: >>> pd.interval_range(start=0, end=5) IntervalIndex([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]], dtype='interval[int64, right]') It may also be constructed using one of the constructor methods: :meth:`IntervalIndex.from_arrays`, :meth:`IntervalIndex.from_breaks`, and :meth:`IntervalIndex.from_tuples`. See further examples in the doc strings of ``interval_range`` and the mentioned constructor methods. intervalindexr<rgboolrfrarbrcrdr-_data_valuesFNTIntervalClosedType | Noner@ Dtype | Nonecopy bool | NonenameHashable | Noneverify_integrityreturnr ct|||}||||\}}td|j5t |||||}dddn #1swxYwY|||S)Nr-)rgrrr@rv)r1_maybe_copy_array_inputr__name__r- _simple_new)rXdatargr@rrrtrvarrays rP__new__zIntervalIndex.__new__s"$c2200tUCC d  = =  !!1 E               ud+++sA""A&)A&rightctd|j5tj||||}dddn #1swxYwY|||S)a\ Construct an IntervalIndex 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 : str, optional Name of the resulting IntervalIndex. copy : bool, default False Copy the data. dtype : dtype or None, default None If None, dtype will be inferred. Returns ------- IntervalIndex See Also -------- interval_range : Function to create a fixed frequency IntervalIndex. IntervalIndex.from_arrays : Construct from a left and right array. IntervalIndex.from_tuples : Construct from a sequence of tuples. Examples -------- >>> pd.IntervalIndex.from_breaks([0, 1, 2, 3]) IntervalIndex([(0, 1], (1, 2], (2, 3]], dtype='interval[int64, right]') r-rgrrr@Nrt)rrzr- from_breaksr{)rXbreaksrgrtrrr@r}s rPrzIntervalIndex.from_breakssT = =  !-vDE               u4000 ;??ctd|j5tj|||||}dddn #1swxYwY|||S)aH 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 : str, optional Name of the resulting IntervalIndex. copy : bool, default False Copy the data. dtype : dtype, optional If None, dtype will be inferred. Returns ------- IntervalIndex 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. IntervalIndex.from_breaks : Construct an IntervalIndex from an array of splits. IntervalIndex.from_tuples : Construct an IntervalIndex 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.IntervalIndex.from_arrays([0, 1, 2], [1, 2, 3]) IntervalIndex([(0, 1], (1, 2], (2, 3]], dtype='interval[int64, right]') r-)rrr@Nr)rrzr-rWr{)rXleftrrgrtrrr@r}s rPrWzIntervalIndex.from_arraysIs| = =  !-eV$eE               u4000s<AActd|j5tj||||}dddn #1swxYwY|||S)a Construct an IntervalIndex 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 : str, optional Name of the resulting IntervalIndex. 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 ------- IntervalIndex See Also -------- interval_range : Function to create a fixed frequency IntervalIndex. IntervalIndex.from_arrays : Construct an IntervalIndex from a left and right array. IntervalIndex.from_breaks : Construct an IntervalIndex from an array of splits. Examples -------- >>> pd.IntervalIndex.from_tuples([(0, 1), (1, 2)]) IntervalIndex([(0, 1], (1, 2]], dtype='interval[int64, right]') r-rNr)rrzr- from_tuplesr{)rXr|rgrtrrr@arrs rPrzIntervalIndex.from_tuplessX = = Y Y+DdRWXXXC Y Y Y Y Y Y Y Y Y Y Y Y Y Y Ys...rr c||j}t|}||j}t|}t |||jS)Nrg)_maybe_convert_i8rrrr rg)selfrrs rP_enginezIntervalIndex._engines_%%di00,T22&&tz22-e44D% <<<>> idx = pd.Index([1, 2, 3]) >>> idx.memory_usage() 24 )r)r memory_usager)rrs rPrzIntervalIndex.memory_usages7By%%4%004:3J3JPT3J3U3UUUrRc"|dddjS)z Return True if the IntervalIndex is monotonic decreasing (only equal or decreasing values), else False N)is_monotonic_increasingrs rPis_monotonic_decreasingz%IntervalIndex.is_monotonic_decreasing s DDbDz11rRct|j}|j}|dkrdS|js|jrdSt }t j|dd}|D].}||||f}||vrdS| |/dS)zX Return True if the IntervalIndex contains unique elements, else False. rBFT)keepr) rrisnasum is_uniquesetrIwhere duplicatedadd)rrr seen_pairs check_idxidxpairs rPrzIntervalIndex.is_unique(s y  99;;??  q 5 > U_ 4UU HT__%_8899!<  ! !CIuSz*Dz!!uu NN4 trRc|jjS)a Return True if the IntervalIndex has overlapping intervals, else False. Two intervals overlap if they share a common point, including closed endpoints. Intervals that only have an open endpoint in common do not overlap. Returns ------- bool Boolean indicating if the IntervalIndex has overlapping intervals. See Also -------- Interval.overlaps : Check whether two Interval objects overlap. IntervalIndex.overlaps : Check an IntervalIndex elementwise for overlaps. Examples -------- >>> index = pd.IntervalIndex.from_tuples([(0, 2), (1, 3), (4, 5)]) >>> index IntervalIndex([(0, 2], (1, 3], (4, 5]], dtype='interval[int64, right]') >>> index.is_overlapping True Intervals that share closed endpoints overlap: >>> index = pd.interval_range(0, 3, closed="both") >>> index IntervalIndex([[0, 1], [1, 2], [2, 3]], dtype='interval[int64, both]') >>> index.is_overlapping True Intervals that only have an open endpoint in common do not overlap: >>> index = pd.interval_range(0, 3, closed="left") >>> index IntervalIndex([[0, 1), [1, 2), [2, 3)], dtype='interval[int64, left]') >>> index.is_overlapping False )ris_overlappingrs rPrzIntervalIndex.is_overlapping@s`|**rRct|dd}t|tst|tr||jSt tttf}t||S)a  Check if a given key needs i8 conversion. Conversion is necessary for Timestamp, Timedelta, DatetimeIndex, and TimedeltaIndex keys. An Interval-like requires conversion if its endpoints are one of the aforementioned types. Assumes that any list-like data has already been cast to an Index. Parameters ---------- key : scalar or Index-like The key that should be checked for i8 conversion Returns ------- bool r@N) rErGr(r _needs_i8_conversionrrrr2r7)rr key_dtypei8_typess rPrz"IntervalIndex._needs_i8_conversionrsl$C$// i / / 7:c83L3L 7,,SX66 6y-H#x(((rRct|rt|}t|}||s|St |}t |dd}t |tst |tr\| |j }| |j }|rtn tj }||||jS|rt|\}}t |t r|j}nt |t$r|j}n{t |t(jt(jfr|d}n?|jt3|jd}}|jr||j}|jj}||krt?d|d||S) a Maybe convert a given key to its equivalent i8 value(s). Used as a preprocessing step prior to IntervalTree queries (self._engine), which expects numeric data. Parameters ---------- key : scalar or list-like The key that should maybe be converted to i8. Returns ------- scalar or list-like The original key if no conversion occurred, int if converted scalar, Index with an int64 dtype if converted list-like. r@Nri8Frrz)Cannot index an IntervalIndex of subtype z with values of dtype ) r!r0rrr$rErGr(r rrrrkrWrgrrordinalr_valuerI datetime64rJviewr@r/asi8rr_isnansubtype ValueError) rrscalarrrr constructorkey_i8rs rPrzIntervalIndex._maybe_convert_i8s"    5s##C/44C((-- J3C$// i / / @:c83L3L @))#(33D**3955E&,K((-2KK;tU4;??? ?  3 7 < < Iv#v&& +FI.. +FR]BN$CDD +T**!$ 5+F+F+FvI{ 3 szk22 *$ i  /G//#,//   rRrsideLiteral['left', 'right']cn|jstdt|ttfrt d|dkr |jjs|dkr*|jjs|j}|j rt|}n|j}|j rt|}| ||S)Nzrcan only get slices from an IntervalIndex if bounds are non-overlapping and all monotonic increasing or decreasingz,Interval objects are not currently supportedrr)rfrrGr rkNotImplementedErrorrrrrdrQrcrT_searchsorted_monotonic)rrOrsub_idxs rPrz%IntervalIndex._searchsorted_monotonics0 M  em]; < < V%&TUU U FNNty@N GOODI$EOjG /'..iG~ /'....ud;;;rRint | slice | np.ndarrayc||t|trA|j|jkrt ||j|jk|j|jkz}nt||jr| }nq|j rtnt}|j rtnt} ||j||||jz}n"#t$r}t ||d}~wwxYw|}|dkrt ||dkr!t!|St%j|d}t|t*r/|j(t+|jt1||j}|S)a6 Get integer location, slice or boolean mask for requested label. The `get_loc` method is used to retrieve the integer index, a slice for slicing objects, or a boolean mask indicating the presence of the label in the `IntervalIndex`. Parameters ---------- key : label The value or range to find in the IntervalIndex. Returns ------- int if unique index, slice if monotonic index, else mask The position or positions found. This could be a single number, a range, or an array of true/false values indicating the position(s) of the label. See Also -------- IntervalIndex.get_indexer_non_unique : Compute indexer and mask for new index given the current index. Index.get_loc : Similar method in the base Index class. Examples -------- >>> i1, i2 = pd.Interval(0, 1), pd.Interval(1, 2) >>> index = pd.IntervalIndex([i1, i2]) >>> index.get_loc(1) 0 You can also supply a point inside an interval. >>> index.get_loc(1.5) 1 If a label is in several intervals, you get the locations of all the relevant intervals. >>> i3 = pd.Interval(0, 2) >>> overlapping_index = pd.IntervalIndex([i1, i2, i3]) >>> overlapping_index.get_loc(0.5) array([ True, False, True]) Only exact matches will be returned if an interval is provided. >>> index.get_loc(pd.Interval(0, 1)) 0 NrrBu1)_check_indexing_errorrGr rgrrrr)r@rrarrrbrMrrargmaxr maybe_booleans_to_slicerrstopstartlenstep)rrmaskop_leftop_righterrmatchesrs rPrzIntervalIndex.get_locsf ""3''' c8 $ $ -{cj((smm#I)djCI.EFDD "3 3 3 -99;;DD!,4bb"G!.6rrBH -wty#..#tz1J1JJ - - -smm, -((** a<<3--  a<<+DKKMM:: :)$))D//:: c5 ! ! 8ch&6 3t99ch77C s#C%% D/C??Dtargetr/method str | Nonelimit int | None tolerance Any | Nonenpt.NDArray[np.intp]ct|trJ|jjr"|jjr||}n||d}nxt|jsIt|js5| |}|j |j }n||dSt|S)Nr)rGrkrrr_get_indexer_unique_sides_get_indexer_pointwiser#r@r%rr get_indexervaluesr)rrrrrindexers rP _get_indexerzIntervalIndex._get_indexer8s fm , , : y" Atz'; A88@@55f==a@!&,// :?6<3P3P :++F33Fl..v}==GG..v66q9 9"7+++rR1tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]ct|}||s-||s||ddSt |t ra|jjr@|jjr4| |}|dk d}n| |St|j s||s| |S||}|j|j\}}t%|t%|fS)aq Compute indexer and mask for new index given the current index. The indexer should be then used as an input to ndarray.take to align the current data to the new index. Parameters ---------- target : IntervalIndex or list of Intervals An iterable containing the values to be used for computing indexer. Returns ------- indexer : np.ndarray[np.intp] Integers from 0 to n - 1 indicating that the index at these positions matches the corresponding target values. Missing values in the target are marked by -1. missing : np.ndarray[np.intp] An indexer into the target of the values not found. These correspond to the -1 in the indexer array. See Also -------- Index.get_indexer : Computes indexer and mask for new index given the current index. Index.get_indexer_for : Returns an indexer even when non-unique. Examples -------- >>> index = pd.Index(["c", "b", "a", "b", "b"]) >>> index.get_indexer_non_unique(["b", "b"]) (array([1, 3, 4, 1, 3, 4]), array([], dtype=int64)) In the example below there are no matched values. >>> index = pd.Index(["c", "b", "a", "b", "b"]) >>> index.get_indexer_non_unique(["q", "r", "t"]) (array([-1, -1, -1]), array([0, 1, 2])) For this reason, the returned ``indexer`` contains only integers equal to -1. It demonstrates that there's no match between the index and the ``target`` values at these positions. The mask [0, 1, 2] in the return value shows that the first, second, and third elements are missing. Notice that the return value is a tuple contains two items. In the example below the first item is an array of locations in ``index``. The second item is a mask shows that the first and third elements are missing. >>> index = pd.Index(["c", "b", "a", "b", "b"]) >>> index.get_indexer_non_unique(["f", "b", "s"]) (array([-1, 1, 3, 4, -1]), array([0, 2])) NFr*rr)r0_should_compare_should_partial_index_get_indexer_non_comparablerGrkrrrrnonzerorr#r@rrget_indexer_non_uniquerr)rrrmissings rPrz$IntervalIndex.get_indexer_non_uniqueUsUnf%%##F++ RD4N4Nv4V4V R33FD3OO O  . . Ry" ;tz'; ;88@@"b=1133A6226::: V\ * * R$2L2LV2T2T R..v66 6 ++F33F#|BB6=QQ GW"7++-@-I-IIIrRc|j|j}|j|j}tj||k|d}|S)zZ _get_indexer specialized to the case where both of our sides are unique. r)rrrrIr)rr left_indexer right_indexerrs rPrz'IntervalIndex._get_indexer_unique_sidessOy,,V[99  ..v|<< (<=8,KKrRcgg}}t|D]#\}} ||}t|tr(t j|j|j|jd}nEtj |rt j |d}nt j |d}no#t$r-||t j dg}Yn9t$r-||t j dg}YnwxYw||%t j|}t#|t#|fS)zV pointwise implementation for get_indexer and get_indexer_non_unique. intpr@rB)ndminrr) enumeraterrGrrIarangerrrr rr}rrappendr concatenater)rrrrirlocss rPrz$IntervalIndex._get_indexer_pointwisesh r'' ! !FAs &||C((dE**-9TZDIVTTTDD^D))-8D222DD8D>>!,D & & &q!!!x~~$ & & &q!!!x~~  & NN4 .))"7++-@-I-IIIsBB334D)3DDc2|j o|jjdkS)N)rr _na_countrs rP_index_as_uniquezIntervalIndex._index_as_uniques&&E4<+AA+EErRzKcannot handle overlapping indices; use IntervalIndex.get_indexer_non_uniquekindLiteral['loc', 'getitem']c|jF|jdks;d}|dkrt||dkrt|st|t||S)NrBzClabel-based slicing with step!=1 is not supported for IntervalIndexlocgetitem)rrr.super_convert_slice_indexer)rrr msg __class__s rPrz$IntervalIndex._convert_slice_indexerss CHMMXCu}} oo%y  055*$S//)ww--c4888rRc(|jjjdvS)NrA)r@rr rs rP_should_fallback_to_positionalz,IntervalIndex._should_fallback_to_positionals z!&$..rRcJt||||SN)rE_maybe_cast_slice_bound)rrOrs rPrz%IntervalIndex._maybe_cast_slice_bounds"tT""::5$GGGrRr;c|t|tsdSt|j|g}t | S)NF)rGr(rr@r#)rr@common_subtypes rP_is_comparable_dtypez"IntervalIndex._is_comparable_dtypes>%// 5)4:u*=>>">2222rRc8t|jjdS)aM Return left bounds of the intervals in the IntervalIndex. The left bounds of each interval in the IntervalIndex are returned as an Index. The datatype of the left bounds is the same as the datatype of the endpoints of the intervals. Returns ------- Index An Index containing the left bounds of the intervals. See Also -------- IntervalIndex.right : Return the right bounds of the intervals in the IntervalIndex. IntervalIndex.mid : Return the mid-point of the intervals in the IntervalIndex. IntervalIndex.length : Return the length of the intervals in the IntervalIndex. Examples -------- >>> iv_idx = pd.IntervalIndex.from_arrays([1, 2, 3], [4, 5, 6], closed="right") >>> iv_idx.left Index([1, 2, 3], dtype='int64') >>> iv_idx = pd.IntervalIndex.from_tuples( ... [(1, 4), (2, 5), (3, 6)], closed="left" ... ) >>> iv_idx.left Index([1, 2, 3], dtype='int64') Fr)r/rnrrs rPrzIntervalIndex.leftsFTZ_51111rRc8t|jjdS)aQ Return right bounds of the intervals in the IntervalIndex. The right bounds of each interval in the IntervalIndex are returned as an Index. The datatype of the right bounds is the same as the datatype of the endpoints of the intervals. Returns ------- Index An Index containing the right bounds of the intervals. See Also -------- IntervalIndex.left : Return the left bounds of the intervals in the IntervalIndex. IntervalIndex.mid : Return the mid-point of the intervals in the IntervalIndex. IntervalIndex.length : Return the length of the intervals in the IntervalIndex. Examples -------- >>> iv_idx = pd.IntervalIndex.from_arrays([1, 2, 3], [4, 5, 6], closed="right") >>> iv_idx.right Index([4, 5, 6], dtype='int64') >>> iv_idx = pd.IntervalIndex.from_tuples( ... [(1, 4), (2, 5), (3, 6)], closed="left" ... ) >>> iv_idx.right Index([4, 5, 6], dtype='int64') Fr)r/rnrrs rPrzIntervalIndex.right!sFTZ%E2222rRc8t|jjdS)ae Return the midpoint of each interval in the IntervalIndex as an Index. Each midpoint is calculated as the average of the left and right bounds of each interval. The midpoints are returned as a pandas Index object. Returns ------- pandas.Index An Index containing the midpoints of each interval. See Also -------- IntervalIndex.left : Return the left bounds of the intervals in the IntervalIndex. IntervalIndex.right : Return the right bounds of the intervals in the IntervalIndex. IntervalIndex.length : Return the length of the intervals in the IntervalIndex. Notes ----- The midpoint is the average of the interval bounds, potentially resulting in a floating-point number even if bounds are integers. The returned Index will have a dtype that accurately holds the midpoints. This computation is the same regardless of whether intervals are open or closed. Examples -------- >>> iv_idx = pd.IntervalIndex.from_arrays([1, 2, 3], [4, 5, 6]) >>> iv_idx.mid Index([2.5, 3.5, 4.5], dtype='float64') >>> iv_idx = pd.IntervalIndex.from_tuples([(1, 4), (2, 5), (3, 6)]) >>> iv_idx.mid Index([2.5, 3.5, 4.5], dtype='float64') Fr)r/rnmidrs rPr!zIntervalIndex.midFsNTZ^%0000rRc8t|jjdS)a` Calculate the length of each interval in the IntervalIndex. This method returns a new Index containing the lengths of each interval in the IntervalIndex. The length of an interval is defined as the difference between its end and its start. Returns ------- Index An Index containing the lengths of each interval. See Also -------- Interval.length : Return the length of the Interval. Examples -------- >>> intervals = pd.IntervalIndex.from_arrays( ... [1, 2, 3], [4, 5, 6], closed="right" ... ) >>> intervals.length Index([3, 3, 3], dtype='int64') >>> intervals = pd.IntervalIndex.from_tuples([(1, 5), (6, 10), (11, 15)]) >>> intervals.length Index([4, 4, 4], dtype='int64') Fr)r/rnlengthrs rPr#zIntervalIndex.lengthos<TZ&U3333rRsortch|jjr"|jjr||}nm|jjrL|jjr@|dkr||}n||}|r|}|S)zL intersection specialized to the case with matching dtypes. rB)rrr_intersection_uniquerr_intersection_non_unique sort_values)rotherr$takens rP _intersectionzIntervalIndex._intersections 9  94:#7 9--e44EE Z ! 9ek&; 9 @Q@QUV@V@V..t44EE11%88E  (%%''E rRr)c:|j|j}|j|j}||k|dkz}||d}t |}||S)a' Used when the IntervalIndex does not have any common endpoint, no matter left or right. Return the intersection with another IntervalIndex. Parameters ---------- other : IntervalIndex Returns ------- IntervalIndex rr)rrrtakerr+)rr)lindexerrindexermatchrs rPr&z"IntervalIndex._intersection_uniques9((44:))%+66X%(b.9--  233//yy!!!rRctjt|t}|jrK|jrDtjt||d}d||<tt|j |j d}tt|j |j dD]\}}||vrd||<||S)a Used when the IntervalIndex does have some common endpoints, on either sides. Return the intersection with another IntervalIndex. Parameters ---------- other : IntervalIndex Returns ------- IntervalIndex rrT)strict) rIzerosrrmrrrrziprrr)rr)r first_nan_loc other_tupsrtups rPr'z&IntervalIndex._intersection_non_uniques xD ... < 'EM 'Ic$ii00=a@M"&D UZTBBBCC DItz$ G G GHH  FAsj  QDzrR np.ndarrayc td)NzRIntervalIndex does not use libjoin fastpaths or pass values to IndexEngine objectsrrs rP_get_engine_targetz IntervalIndex._get_engine_targets" "   rRc td)Nz,IntervalIndex does not use libjoin fastpathsr:)rresults rP_from_join_targetzIntervalIndex._from_join_targets!"PQQQrR)NNNNT) rgrpr@rqrrrsrtrurvrmrwr )rNFN) rgrprtrurrrmr@rqrwrk) rgr<rtrurrrmr@rqrwrk)rwr )rrrwrm)rrrwrk)rwr6)rwr)F)rrmrwrrwrm)r)rr)rwr)NNN) rr/rrrrrrrwr)rr/rwr)rrkrwr)rrr r)rr)r@r;rwrm)rwr/)r$rm)r)rkrwrk)rwr8)2rz __module__ __qualname____doc___typ__annotations___can_hold_stringsr- _data_clsr~ classmethodrrWrrrrrrrpropertyrrrrrrrrrrrrrr _requires_unique_msgrrrrrrr!r#r+r&r'r;r> __classcell__)rs@rPrkrks"LL\ D&&&&OOOI-1" $!%,,,,,2-4 $" -1-1-1-1[-1^ &- $"A1A1A1A1[A1F&- $" -/-/-/-/[-/d===^=2<<<<XXX^X999X!V!V!V!V!VJ222^2^./+/+/+X/+b))))2===~<<<<<:OOOOh" $ ,,,,,:PJPJPJPJd    JJJJ@FFF^F V 9 9 9 9 9 9///^/HHHH3333"2"2"2^"2H"3"3"3^"3H&1&1&1^&1P444X4D("""",>    RRRRRRRrRrkrwrmctt|t|tt|t|dugS)zJ Helper for interval_range to check if start/end are valid types. N)anyr"rGrr)endpoints rP_is_valid_endpointrNsH  h   x + + x + +      rRcd}d}t|rt|p@||o ||p*||o ||ptj||S)zK Helper for interval_range to check type compat of start/end/freq. c:t|ttfSr)rGrrxs rPz%_is_type_compatible..ZIz+BCCrRc:t|ttfSr)rGrrrQs rPrSz%_is_type_compatible..rTrR)r"comany_none)ab is_ts_compat is_td_compats rP_is_type_compatibler\s~DCLCCL 1 &)A,,  LOO / Q  LOO / Q  <1   rRrrtrur<c >t|}t|}||n|}|)tj|||rt|rdnd}tj||||dkrt dt |st d|t |st d|t|}|Et|s6 t|}n%#t $r}t d||d}~wwxYwtt||t||t||gstd ||dz }t|rtj d }tj|||rt|tjtjfr>t|tjtjfr|j |j kr|j }nwt|t$tjfsBt|t$tjfs!t|t$tjfrtj d }tj|||d zz|} t)| |} nL|t+||z |zdz}n| ||dz |zz }n | ||dz |zz}tj|||} td tj|||Drt)| |} n`. Examples -------- Numeric ``start`` and ``end`` is supported. >>> pd.interval_range(start=0, end=5) IntervalIndex([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]], dtype='interval[int64, right]') Additionally, datetime-like input is also supported. >>> pd.interval_range( ... start=pd.Timestamp("2017-01-01"), end=pd.Timestamp("2017-01-04") ... ) IntervalIndex([(2017-01-01 00:00:00, 2017-01-02 00:00:00], (2017-01-02 00:00:00, 2017-01-03 00:00:00], (2017-01-03 00:00:00, 2017-01-04 00:00:00]], dtype='interval[datetime64[us], right]') The ``freq`` parameter specifies the frequency between the left and right. endpoints of the individual intervals within the ``IntervalIndex``. For numeric ``start`` and ``end``, the frequency must also be numeric. >>> pd.interval_range(start=0, periods=4, freq=1.5) IntervalIndex([(0.0, 1.5], (1.5, 3.0], (3.0, 4.5], (4.5, 6.0]], dtype='interval[float64, right]') Similarly, for datetime-like ``start`` and ``end``, the frequency must be convertible to a DateOffset. >>> pd.interval_range(start=pd.Timestamp("2017-01-01"), periods=3, freq="MS") IntervalIndex([(2017-01-01 00:00:00, 2017-02-01 00:00:00], (2017-02-01 00:00:00, 2017-03-01 00:00:00], (2017-03-01 00:00:00, 2017-04-01 00:00:00]], dtype='interval[datetime64[us], right]') Specify ``start``, ``end``, and ``periods``; the frequency is generated automatically (linearly spaced). >>> pd.interval_range(start=0, end=6, periods=4) IntervalIndex([(0.0, 1.5], (1.5, 3.0], (3.0, 4.5], (4.5, 6.0]], dtype='interval[float64, right]') The ``closed`` parameter specifies which endpoints of the individual intervals within the ``IntervalIndex`` are closed. >>> pd.interval_range(end=5, periods=4, closed="both") IntervalIndex([[1, 2], [2, 3], [3, 4], [4, 5]], dtype='interval[int64, both]') NrBDzVOf the four parameters: start, end, periods, and freq, exactly three must be specifiedz,start must be numeric or datetime-like, got z*end must be numeric or datetime-like, got z7freq must be numeric or convertible to DateOffset, got z+start, end, freq need to be type compatibleint64float64g?c34K|]}t|VdSr)r).0rRs rP z!interval_range..s(EEz!}}EEEEEErR)rendperiodsfreq)rrg)rtrgr@)rrVrWr"count_not_nonerrNr,rallr\rMrIr@ all_not_nonerGintegerfloatingfloatrrrlinspacenot_nonerr3r8rkrr() rrerfrgrtrgrMrr@rs rPinterval_rangerpsD #5 ) )E  % %C)uusH | WeS99|h''0qqS %gt4499 4   e $ $QOOOPPP c " "MKcKKLLLw''G  $ T??DD   P$PP    s + + t , , T * *   GEFFF1 #S(7++  E3 - - 652:r{";<< ,sRZ$=>> ,K39,, 55"+"677 ,cE2;#788 ,dUBK$899 , ++YucTCZ&8$??F+FE::FFsU{t344q8w{d22w{d22[W55F EEcl5#t&D&DEEE E E ;+FE::F Hi ( (S%S'MMM u#wTRRR  $ $ FL@@@ %  sC-- D7D  Dr?)NNNNNr)rtrurgr<rwrk)`rB __future__roperatorrrtypingrrrr numpyrI pandas._libsr pandas._libs.intervalr r r pandas._libs.tslibsrrrrr pandas.errorsrpandas.util._decoratorsrrpandas.util._exceptionsrpandas.core.dtypes.castrrrrrrpandas.core.dtypes.commonrrrr r!r"r#r$r%r&pandas.core.dtypes.dtypesr'r(pandas.core.dtypes.missingr)pandas.core.algorithmsr+pandas.core.arrays.datetimeliker,pandas.core.arrays.intervalr-pandas.core.commoncorecommonrVpandas.core.indexersr.pandas.core.indexes.baser/r0r1pandas.core.indexes.datetimesr2r3pandas.core.indexes.extensionr4r5pandas.core.indexes.multir6pandas.core.indexes.timedeltasr7r8collections.abcr9pandas._typingr:r;r<r=rQrTrZrkrNr\rprVrRrPrsi"""""" ,+++++655555                        =<<<<<))))))<<<<<<! :::::: 100000 ((((((QQQ"QQQ"    k*MEEE     .9=PTUUU HFRFRFRFRFRNFRFRVU  FE FRV"         H    !( wwwwwwwrR