3
���ho� � @ s� d dl mZmZ d dlZd dlZd dlmZ d dlm Z m
Z
m Z d dl m
Z d dlmZ d dlmZ d dlmZmZmZmZmZmZmZmZm Z m Z m Z m Z d d l m!Z! d d
l"m#Z#m$Z$m%Z%m&Z&m'Z' d d l(m)Z)m*Z* d d l+m,Z,m-Z- d d
l.m/Z/m0Z0 d dl1m2Z2 d dl3j4j5Z6d dl7m8Z8 d dl9m:Z: d dl;m<Z< ddddhZ=i Z>e?dddd�Z@de>d< ee>d e?dd d dddejAd �d � �G d d� de
e/��ZBd!d"� ZCdS )#� )�le�ltN)�
get_option)�Interval�
IntervalMixin� intervals_to_interval_bounds)�function)�Appender)�maybe_convert_platform) �is_categorical_dtype�is_datetime64_any_dtype�is_float_dtype�is_integer_dtype� is_interval�is_interval_dtype� is_list_like�is_object_dtype� is_scalar�is_string_dtype�is_timedelta64_dtype� pandas_dtype)�
IntervalDtype)�ABCDatetimeIndex�
ABCIndexClass�ABCIntervalIndex�ABCPeriodIndex� ABCSeries)�isna�notna)�take� value_counts)�ExtensionArray� _extension_array_shared_docs)� Categorical)�array)�check_array_indexer)� ensure_index�left�right�bothZneither�
IntervalArrayzarrays.IntervalArray� )�klass�qualname�namea�
%(summary)s
.. versionadded:: %(versionadded)s
Parameters
----------
data : array-like (1-dimensional)
Array-like 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.
.. versionadded:: 0.23.0
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
<https://pandas.pydata.org/pandas-docs/stable/user_guide/advanced.html#intervalindex>`_
for more.
%(examples)s�classz@Pandas array for interval data that are closed on the same side.z0.24.0a� 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)])
<IntervalArray>
[(0, 1], (1, 5]]
Length: 2, closed: right, dtype: interval[int64]
It may also be constructed using one of the constructor
methods: :meth:`IntervalArray.from_arrays`,
:meth:`IntervalArray.from_breaks`, and :meth:`IntervalArray.from_tuples`.
)r, �summaryZ versionaddedr. Zextra_attributesZ
extra_methods�examplesc @ sF e Zd ZdZdZej ZZdve e d�dd�Z
e dwdd ��Z e dxd
d ��Z
e d d
� �Zejd�ed< e eed ed ejd�d� �dydd���Zejd�ed< e eed ed ejd�d� �dzdd���Zejd�ed< e eed ed ejd �d� �d{d d ���Zd d � Zd!d"� Zed#�d$d%�Zd&d'� Zd(d)� Z d*d+� Z d|d,d-�Z e d.d/� �Z d}d0d1�Z!e d2d3� �Z"d4d5� Z#d6d7� Z$d8d9� Z%e ed#�d:d;��Z&e ed#�d<d=��Z'd~ee(d d>�d?d@�Z)ddAdB�Z*d�dCdD�Z+dEdF� Z,e-d#�dGdH�Z.dIdJ� Z/e dKdL� �Z0e dMdN� �Z1e dOdP� �Z2ejdQ�edR< eedR ed ejdS�d� �dTdU� �Z3e dVdW� �Z4e dXdY� �Z5dZed[< e eed[ e6 �d\d]� ��Z7d�ej8d#�d^d_�Z9d�d`da�Z:dbedc< eedc edddedf� �d�dgdh��Z;ee<di e6 �d�djdk��Z=ejdl�edm< eedm ed ejdn�d� �dodp� �Z>ejdq�edr< eedr ed ejds�d� �dtdu� �Z?dS )�r* � TNF)�copy�verify_integrityc
C s� t |t�rt|j�r|j}t || tf�r@|j}|j}|p<|j}nHt |�rb| j
� d|� d�}t |��t |�}t
||d kd�\}}} |p�| }| j||||||d�S )Nz5(...) must be called with a collection of some kind, z was passed)Zvalidate_closed)r3 �dtyper4 )�
isinstancer r r5 �_valuesr r' r( �closedr �__name__� TypeError� maybe_convert_platform_intervalr � _simple_new)
�cls�datar8 r5 r3 r4 r' r( �msgZ infer_closed� r@ �=/tmp/pip-build-5_djhm0z/pandas/pandas/core/arrays/interval.py�__new__� s( zIntervalArray.__new__c C s� t j| �}|pd}t||d�}t||d�}|d k rxt|�}t|�sVd|� �}t|��n"|jd k rx|j|j�}|j|j�}t|�r�t |�r�|j|j
�}n t|�r�t |�r�|j|j
�}t |�t |�kr�dt |�j � dt |�j � d�}t
|��n~t|j
�p�t|j
��rd}t|��nZt|t��r(d}t
|��n@t|t��rht|j�t|j�k�rhd |j� d
|j� d �}t
|��||_||_||_|�r�|j� |S ) Nr( )r3 z$dtype must be an IntervalDtype, got z must 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 '�')r rB r& r r r: �subtype�astyper
r r5 �typer9 �
ValueErrorr r r6 r r �str�tz�_left�_right�_closed� _validate) r= r' r( r8 r3 r5 r4 �resultr? r@ r@ rA r< � sD
"zIntervalArray._simple_newc C s | |||d�S )N)r5 r3 r@ )r= Zscalarsr5 r3 r@ r@ rA �_from_sequence� s z IntervalArray._from_sequencec C s( t |�dkr|j|jj�}| ||jd�S )Nr )r8 )�lenrE r5 rD r8 )r= �values�originalr@ r@ rA �_from_factorized� s z IntervalArray._from_factorizeda
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.
copy : bool, default False
Copy the data.
dtype : dtype or None, default None
If None, dtype will be inferred.
.. versionadded:: 0.23.0
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_breaksz� Examples
--------
>>> pd.arrays.IntervalArray.from_breaks([0, 1, 2, 3])
<IntervalArray>
[(0, 1], (1, 2], (2, 3]]
Length: 3, closed: right, dtype: interval[int64]
)r, r1 r( c C s, t |�}| j|d d� |dd � |||d�S )Nr2 )r3 r5 ���)r; � from_arrays)r= Zbreaksr8 r3 r5 r@ r@ rA rT & s zIntervalArray.from_breaksaY
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.
.. versionadded:: 0.23.0
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 rV z� >>> pd.arrays.IntervalArray.from_arrays([0, 1, 2], [1, 2, 3])
<IntervalArray>
[(0, 1], (1, 2], (2, 3]]
Length: 3, closed: right, dtype: interval[int64]
c C s& t |�}t |�}| j|||||dd�S )NT)r3 r5 r4 )r; r< )r= r' r( r8 r3 r5 r@ r@ rA rV o s 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.
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.
.. versionadded:: 0.23.0
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)])
<IntervalArray>
[(0, 1], (1, 2]]
Length: 2, closed: right, dtype: interval[int64]
c
C s� t |�rg g }}n| }}x�|D ]�}t|�r:tj }} n�| j}
y |\}} W nr tk
r� } z |
� d|� �} t| �| �W Y d d } ~ X n: tk
r� } z |
� d|� �} t| �| �W Y d d } ~ X nX |j|� |j| � q"W | j|||d|d�S )Nz..from_tuples requires tuples of length 2, got z'.from_tuples received an invalid item, F)r3 r5 ) rP r �np�nanr9 rG r: �appendrV )
r= r> r8 r3 r5 r' r( �d�lhs�rhsr. �errr? r@ r@ rA rW � s$
zIntervalArray.from_tuplesc C s� | j tkr d| j � �}t|��t| j�t| j�kr>d}t|��t| j�}t| j�}||kj� sjd}t|��| j| | j| kj� s�d}t|��dS )z�
Verify that the IntervalArray is valid.
Checks that
* closed is valid
* left and right match lengths
* left and right have the same missing values
* left is always below right
z invalid option for 'closed': 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)r8 �
_VALID_CLOSEDrG rP r' r( r �all)�selfr? Z left_maskZ
right_maskr@ r@ rA rM � s
zIntervalArray._validatec C s t tj| ��S )N)�iterrX �asarray)ra r@ r@ rA �__iter__� s zIntervalArray.__iter__)�returnc C s
t | j�S )N)rP r' )ra r@ r@ rA �__len__� s zIntervalArray.__len__c C sn t | |�}| j| }| j| }t|t�sbt|�r>t|�r>| jS tj |�dkrTt
d��t ||| j �S | j
||�S )Nr2 z&multi-dimensional indexing not allowed)r% r' r( r6 r r r � _fill_valuerX �ndimrG r r8 �
_shallow_copy)ra �valuer' r( r@ r@ rA � __getitem__� s
zIntervalArray.__getitem__c C s> d}t |�r`t|�r`t| jj�r&d}n.t| jj�r>tjd�}nt| jj�rTtj d�}|| }}n�t
|�srt |t �r�| j
|dd� |j|j }}nXyt|�}|j|j }}W n< tk
r� } z dt|�� d�}t|�|�W Y d d }~X nX |r�td��t| |�}| jjdd �} || j|< | | _| jjdd �}
||
j|< |
| _d S )
NFTZNaTrj )r. z('value' should be an interval type, got z instead.z4Cannot set float NaN to integer-backed IntervalArray)�deep)r r r r5 rD r rX Z
datetime64r Z timedelta64r r6 r �_check_closed_matchesr' r( r* r: rF rG r% r3 r7 rJ rK ) ra �keyrj Zneeds_float_conversionZ
value_leftZ value_rightr$ r^ r? r' r( r@ r@ rA � __setitem__ s6
zIntervalArray.__setitem__c C sx t |�r*t| �t|�kr td��t|�}n t|t�sFtjt| �td�S t|t�rZt d�}nPt
|j �sl|j }n>|j j }t
|�r�| j|j jkr�tjt| �td�S |j j|j�}t
|�r�| j|jkr�tjt| �td�S | j|jk| j|jk@ S t|��stjt| �td�S tjt| �td�}x\t|�D ]P\}}t|t��r | j|jk�r | j| |jk�r | j| |jk�r d||< �q W |S )Nz Lengths must match to compare)r5 �intervalT)r rP rG r$ r6 r rX �zeros�boolr r r5 �
categoriesr r8 r �codesr' r( r � enumerate)ra �otherZ other_dtyperN �i�objr@ r@ rA �__eq__6 s:
zIntervalArray.__eq__c C s~ |dk rt d��|dk r t d��t|t�sDdt|�j� d�}t |��| j|dd� | jj|jd�}| jj|jd�}| j ||�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.
Returns
-------
filled : IntervalArray with NA/NaN filled
Nz5Filling by method is not supported for IntervalArray.z)limit is not supported for IntervalArray.zU'IntervalArray.fillna' only supports filling with a scalar 'pandas.Interval'. Got a 'z
' instead.rj )r. )rj )
r: r6 r rF r9 rm r' �fillnar( ri )ra rj �method�limitr? r' r( r@ r@ rA rz g s
zIntervalArray.fillnac C s t | jj�S )N)r r' r5 )ra r@ r@ rA r5 � s zIntervalArray.dtypec C s@ ddl m} |dk r t|�}t|�r�|| jkr>|r:| j� S | S y | jj|j�}| j j|j�}W n@ t
k
r� } z$d| j� d|� d�}t
|�|�W Y dd}~X nX | j ||�S t |�r�t
tj| ��S t||�r�|j� j| dd�S ytj| �j||d�S t
tfk
�r: } z&d t| �j� d
|� �}t
|�|�W Y dd}~X nX dS ) 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.
r )� StringDtypeNzCannot convert z to z; subtypes are incompatibleF)r3 z Cannot cast z
to dtype )Zpandas.core.arrays.string_r} r r r5 r3 r' rE rD r( r: ri r r# rX rc r6 Zconstruct_array_typerO rG rF r9 )ra r5 r3 r} Znew_leftZ new_rightr^ r? r@ r@ rA rE � s,
zIntervalArray.astypec C sd dd� |D �}t |�dkr"td��|j� }tjdd� |D ��}tjdd� |D ��}| j|||dd �S )
z�
Concatenate multiple IntervalArray
Parameters
----------
to_concat : sequence of IntervalArray
Returns
-------
IntervalArray
c S s h | ]
}|j �qS r@ )r8 )�.0rp r@ r@ rA � <setcomp>� s z2IntervalArray._concat_same_type.<locals>.<setcomp>r2 z.Intervals must all be closed on the same side.c S s g | ]
}|j �qS r@ )r' )r~ rp r@ r@ rA �
<listcomp>� s z3IntervalArray._concat_same_type.<locals>.<listcomp>c S s g | ]
}|j �qS r@ )r( )r~ rp r@ r@ rA r� � s F)r8 r3 )rP rG �poprX Z concatenater< )r= Z to_concatr8 r' r( r@ r@ rA �_concat_same_type� s
z IntervalArray._concat_same_typec C s | j ||| jdd�S )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.
F)r8 r4 )r< r8 )ra r' r( r@ r@ rA ri � s zIntervalArray._shallow_copyc C s6 | j jdd�}| jjdd�}| j}t| �j|||d�S )zd
Return a copy of the array.
Returns
-------
IntervalArray
T)rl )r8 )r' r3 r( r8 rF rV )ra r' r( r8 r@ r@ rA r3 � s zIntervalArray.copyc C s
t | j�S )N)r r' )ra r@ r@ rA r � s zIntervalArray.isnac C s | j j| jj S )N)r' �nbytesr( )ra r@ r@ rA r� � s zIntervalArray.nbytesc C s | j jS )N)r' �size)ra r@ r@ rA r� s zIntervalArray.size)�periods�
fill_valuere c C s� t | � s|dkr| j� S t|�r*| jj}tt|�t | ��}t|�rb| jj}t j
|g|d �}n| j |g| �}|dkr�|}| d | � }n| t|�d � }|}| j ||g�S )Nr r2 )
rP r3 r r5 Zna_value�min�absr' � _na_valuer* rT rO r� )ra r� r� Z empty_len�empty�a�br@ r@ rA �shift s zIntervalArray.shiftc K s� t jt� |� | }}|r�|dkr0| jj }}nRt|�rV| j|dd� |j|j }}n,t|� r�t |�r�dt
|�j � d�}t |��t
| j|||d�} t
| j|||d�}
| j| |
�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.
Nr� )r. z['IntervalArray.fillna' only supports filling with a 'scalar pandas.Interval or NA'. Got a 'z
' instead.)�
allow_fillr� )�nvZ
validate_take�tupler' r� r rm r( r r rF r9 rG r ri ) ra �indicesr� r� �axis�kwargsZ fill_leftZ
fill_rightr? Z left_takeZ
right_taker@ r@ rA r " s .zIntervalArray.takec C s t tj| �|d�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
)�dropna)r rX rc )ra r� r@ r@ rA r j s zIntervalArray.value_countsc
s& t | �}ttd�p|d d�}t� |dkr0d}n�|dkrR� | d �}d|� d�}n�|dkr�� | d �}� | d �}d|� d |� d�}n�||kr�t|d d�}� fd
d �| d |� D �}� fd d �| | d � D �}d j|�}d j|�} d|� d
| � d�}n(� fdd �| D �}d j|�} d| � d�}|S )Nzdisplay.max_seq_items�
r z[]r2 �[�]� z, c s g | ] }� |��qS r@ r@ )r~ �x)� formatterr@ rA r� � s z.IntervalArray._format_data.<locals>.<listcomp>c s g | ] }� |��qS r@ r@ )r~ r� )r� r@ rA r� � s z ... c s g | ] }� |��qS r@ r@ )r~ r� )r� r@ rA r� � s rU )rP r� r rH �join)
ra �nZ
max_seq_itemsr0 �first�last�head�tailZhead_strZtail_strr@ )r� rA � _format_data� s.
zIntervalArray._format_datac C sD | j � }dt| �j� d�}|� |� dt| �� d| j� d| j� �}|S )N�<z>
z
Length: z
, closed: z , dtype: )r� rF r9 rP r8 r5 )ra r> �
class_name�templater@ r@ rA �__repr__� s &zIntervalArray.__repr__c C s dt t| �j�d }d|� �S )N� r2 �
)rP rF r9 )ra �spacer@ r@ rA �
_format_space� s zIntervalArray._format_spacec C s | j S )zf
Return the left endpoints of each Interval in the IntervalArray as
an Index.
)rJ )ra r@ r@ rA r' � s zIntervalArray.leftc C s | j S )zg
Return the right endpoints of each Interval in the IntervalArray as
an Index.
)rK )ra r@ r@ rA r( � s zIntervalArray.rightc C s | j S )zi
Whether the intervals are closed on the left-side, right-side, both or
neither.
)rL )ra r@ r@ rA r8 � s zIntervalArray.closeda�
Return an %(klass)s identical to the current one, but closed on the
specified side.
.. versionadded:: 0.24.0
Parameters
----------
closed : {'left', 'right', 'both', 'neither'}
Whether the intervals are closed on the left-side, right-side, both
or neither.
Returns
-------
new_index : %(klass)s
%(examples)s �
set_closeda� Examples
--------
>>> index = pd.arrays.IntervalArray.from_breaks(range(4))
>>> index
<IntervalArray>
[(0, 1], (1, 2], (2, 3]]
Length: 3, closed: right, dtype: interval[int64]
>>> index.set_closed('both')
<IntervalArray>
[[0, 1], [1, 2], [2, 3]]
Length: 3, closed: both, dtype: interval[int64]
c C s4 |t krd|� �}t|��t| �j| j| j|dd�S )Nz invalid option for 'closed': F)r' r( r8 r4 )r_ rG rF r< r' r( )ra r8 r? r@ r@ rA r� � s
zIntervalArray.set_closedc C sB y | j | j S tk
r< } zd}t|�|�W Y dd}~X nX dS )zq
Return an Index with entries denoting the length of each Interval in
the IntervalArray.
z]IntervalArray contains Intervals without defined length, e.g. Intervals with string endpointsN)r( r' r: )ra r^ r? r@ r@ rA �length� s
zIntervalArray.lengthc C s6 yd| j | j S tk
r0 | j d| j S X dS )zX
Return the midpoint of each Interval in the IntervalArray as an Index.
g �?N)r' r( r: r� )ra r@ r@ rA �mid s zIntervalArray.midz�
Return True if the %(klass)s is non-overlapping (no Intervals share
points) and is either monotonic increasing or monotonic decreasing,
else False.
� is_non_overlapping_monotonicc C s� | j dkrNt| jd d� | jdd � k j� pJ| jd d� | jdd � kj� �S t| jd d� | jdd � kj� p�| jd d� | jdd � kj� �S )Nr) r2 rU rU rU rU )r8 rr r( r' r` )ra r@ r@ rA r� $ s
" z*IntervalArray.is_non_overlapping_monotonicc C sr | j }| j}| j� }| j}tjt|�td�}x@tt|��D ]0}|| rRtj ||< q:t
|| || |�||< q:W |S )zt
Return the IntervalArray's data as a numpy array of Interval
objects (with dtype='object')
)r5 ) r' r( r rL rX r� rP �object�rangerY r )ra r5 r' r( �maskr8 rN rw r@ r@ rA � __array__= s zIntervalArray.__array__c
C sp ddl }ddlm} y|j| jj�}W n8 tk
r^ } z td| jj� d��|�W Y dd}~X nX ||| j�}|jj |j
| j |dd�|j
| j |dd�gdd gd
�}| j
� }|j� r�|j
| �j� d } |jj|jt|�| g|jd�|jd �gd �}|dk �rb|j|j��r |S t||��rR|j|��sbtd
| jj� d|j� d| j� d|j� d� ��ntd|� d���|jj||�S )z6
Convert myself into a pyarrow Array.
r N)�ArrowIntervalTypez"Conversion to arrow with subtype 'z' is not supportedT)rF Z from_pandasr' r( )�namesr2 )�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)�pyarrowZ pandas.core.arrays._arrow_utilsr� Zfrom_numpy_dtyper5 rD r: r8 Z StructArrayrV r$ r' r( r �any�buffersZ from_buffersrF rP �field�equalsZ storage_typer6 r! Z from_storage)
ra rF r� r� rD r^ Z
interval_typeZ
storage_arrayr� Z null_bitmapr@ r@ rA �__arrow_array__O s>
,z IntervalArray.__arrow_array__a�
Return an %(return_type)s of tuples of the form (left, right).
Parameters
----------
na_tuple : bool, default True
Returns NA as a tuple if True, ``(nan, nan)``, or just as the NA
value itself if False, ``nan``.
.. versionadded:: 0.23.0
Returns
-------
tuples: %(return_type)s
%(examples)s � to_tuples�ndarrayr+ )� return_typer1 c C s2 t jt| j| j��}|s.tj| j� |tj�}|S )N) �comZasarray_tuplesafe�zipr' r( rX �wherer rY )ra Zna_tupleZtuplesr@ r@ rA r� � s zIntervalArray.to_tuples�repeatc C s: t jt� t|d�� | jj|�}| jj|�}| j||d�S )N)r� )r' r( )r� Zvalidate_repeatr� �dictr' r� r( ri )ra Zrepeatsr� Z left_repeatZ right_repeatr@ r@ rA r� � s 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.
.. versionadded:: 0.25.0
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
<IntervalArray>
[(0, 1], (1, 3], (2, 4]]
Length: 3, closed: right, dtype: interval[int64]
c C sF t |t�rtd��| jr"| j|k n| j|k| jr:|| jk n|| jk@ S )Nz*contains not implemented for two intervals)r6 r �NotImplementedErrorZ open_leftr' Z
open_rightr( )ra rv r@ r@ rA r� � s
zIntervalArray.containsak
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.
.. versionadded:: 0.24.0
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
<IntervalArray>
[(0, 1], (1, 3], (2, 4]]
Length: 3, closed: right, dtype: interval[int64]
c C sz t |ttf�rt�n"t |t�s6dt|�j� �}t|��| jrF|j rFt
nt }|jrZ| j rZt
nt }|| j |j
�||j | j
�@ S )Nz#`other` must be Interval-like, got )r6 r* r r� r rF r9 r: Z closed_leftZ closed_rightr r r' r( )ra rv r? Zop1Zop2r@ r@ rA r� s
zIntervalArray.overlaps)NNFT)NFNT)NF)r( FN)r( FN)r( FN)NNN)T)r2 N)FNN)T)N)N)T)N)@r9 �
__module__� __qualname__rh Z can_hold_narX rY r� rg rr rB � classmethodr< rO rS �textwrap�dedent�_interval_shared_docsr r� rT rV rW rM rd �intrf rk ro ry rz �propertyr5 rE r� ri r3 r r� r� r� r� r r r� rH r� r� r' r( r8 r� r� r� �_shared_docs_kwargsr� r� r� r� r� r" r� r� r� r@ r@ r@ rA r* v s�
$ 6
0
-1
-
2
H
"
E
'
c C sD t | ttf�r*t| �dkr*tjg tjd�S t| �r<tj| �} t | �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
r )r5 )
r6 �listr� rP rX r$ Zint64r rc r
)rQ r@ r@ rA r; ) s
r; )D�operatorr r r� ZnumpyrX Zpandas._configr Zpandas._libs.intervalr r r Zpandas.compat.numpyr r� Zpandas.util._decoratorsr Zpandas.core.dtypes.castr
Zpandas.core.dtypes.commonr r r
r r r r r r r r r Zpandas.core.dtypes.dtypesr Zpandas.core.dtypes.genericr r r r r Zpandas.core.dtypes.missingr r Zpandas.core.algorithmsr r Zpandas.core.arrays.baser! r" Z pandas.core.arrays.categoricalr# Zpandas.core.common�core�commonr� Zpandas.core.constructionr$ Zpandas.core.indexersr% Zpandas.core.indexes.baser& r_ r� r� r� r� r* r; r@ r@ r@ rA �<module> sZ 8 B
|