U
|
¬ý°dGï ã @ s U d dl mZ d dlZd dlmZmZ d dlZd dlmZmZm Z m
|
Z
|
m Z m Z m Z mZ d dlZd dlmZ d dlmZ d dlmZmZmZmZ d dlmZ d d l m Z m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z' d d
|
l(m)Z* d d l+m,Z, d d l-m.Z. d d l/m0Z0m1Z1 d dl2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z= d dl>m?Z? d dl@mAZAmBZBmCZCmDZD d dlEmFZFmGZGmHZH d dlImJZJmKZKmLZLmMZM d dlNmOZOmPZP d dlQmRZR d dlSmTZT d dlUmV mWZX d dlYmZZ[m\Z\m]Z] d dl^m_Z_ d dl`maZambZb erd dlcmdZdmeZe e ddd Zfe e&ejgf Zhe eeif Zji Zkd eld < dd d d!Zmd"ekd#< e.ekd# dd$d%d d d e nd&¡d' G d(d deeOZod)d*d+d,ZpdS )-é )Ú annotationsN)ÚleÚlt)Ú TYPE_CHECKINGÚIteratorÚLiteralÚSequenceÚTypeVarÚUnionÚcastÚoverload)Ú
|
get_option)Úlib)Ú VALID_CLOSEDÚIntervalÚ IntervalMixinÚ intervals_to_interval_bounds)ÚNA) Ú ArrayLikeÚAxisIntÚDtypeÚIntervalClosedTypeÚNpDtypeÚPositionalIndexerÚ ScalarIndexerÚSequenceIndexerÚSortKindÚ TimeArrayLikeÚnpt)Úfunction)ÚIntCastingNaNError)ÚAppender)ÚLossySetitemErrorÚ maybe_upcast_numeric_to_64bit) Úis_categorical_dtypeÚis_dtype_equalÚis_float_dtypeÚis_integer_dtypeÚis_interval_dtypeÚ is_list_likeÚis_object_dtypeÚ is_scalarÚis_string_dtypeÚneeds_i8_conversionÚ pandas_dtype)Ú IntervalDtype)Ú ABCDataFrameÚABCDatetimeIndexÚABCIntervalIndexÚABCPeriodIndex)Úis_valid_na_for_dtypeÚisnaÚnotna)ÚisinÚtakeÚuniqueÚ value_counts)ÚExtensionArrayÚ _extension_array_shared_docs)Ú DatetimeArray)ÚTimedeltaArray)ÚarrayÚ ensure_wrapped_if_datetimelikeÚ extract_array)Úcheck_array_indexer)Úinvalid_comparisonÚunpack_zerodim_and_defer)ÚIndexÚSeriesÚIntervalArrayTÚ IntervalArray)Úboundzdict[str, str]Ú_interval_shared_docszarrays.IntervalArrayÚ )ÚklassÚqualnameÚnamea
|
%(summary)s
|
|
.. versionadded:: %(versionadded)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
|
<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, 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`.
|
)rL ÚsummaryZ versionaddedrN Zextra_attributesZ extra_methodsÚexamplesc s
|
e Zd ZU dZej ZZeddddZ de
|
d< de
|
d< d e
|
d
|
< dçd ddddddZ e d ddd ddddZ e dèdddddddZe d d d d dddd d d Ze d d ddd!d"d#Ze d$¡ed%< e eed% d d&e d'¡d( déd ddddd*d+d,Ze d-¡ed.< e eed. d d&e d/¡d( dêd ddddd*d0d1Ze d2¡ed3< e eed3 d d&e d4¡d( dëd ddddd*d5d6Ze d d7d8d9d:Zddd;d<d=Zed dd>d?Zed@ddAdBZed@ddCdDZ dEddFdGZ d@ddHdIZ e dJdKdLdMdNZ e ddOddPdQdNZ ddRdSdPdTdNZ d7ddUdVZ!dWdX Z"e#dYdZd[ Z$e#d\d]d^ Z%e#d_d`da Z&e#dbdcdd Z'e#dedfdg Z(e#dhdidj Z)ddkdldmddndod dp fdqdrZ*d ddsdtddKdudvdwZ+d ddsdtddKdudxdyZ,dìddd;dzd{Z-dídd| fd}d~ Z.ddddZ/e d dddddZ0ddd;d
dZ1d dddZ2dîd@dd dddZ3d d d dddddddZ4dd Z5dd Z6dd Z7dïdddddZ8dodddZ9dodddZ:dodd d¡Z;ed¢d£ Z<ed¤d¥ Z=ed¦dd§d¨Z>ed¦dd©dªZ?e d«¡ed¬< eed¬ d e d¡d® d¯d° Z@ed±dd²d³ZAe d´¡edµ< eedµ d e d¶¡d® dd±dd·d¸d¹ZBdºed»< eeed» eC ddd¼d½ZDdðd¾d d8d¿dÀZEdñdÁdÂZFdÃedÄ< eedÄ dÅd&dÆ dòdd dÇdÈdÉZGdÊd7dËdÌdÍZHdd@dÎddÏdÐdÑZIddd;dÒdÓZJeeKdÔ eC dóddÕdtddÖd×dØZLe dÙ¡edÚ< eedÚ d e dÛ¡d® dÜdÝ ZMdÊddÞdßZNedddàdáZOd d dâdãdäZPd ddådæZQ ZRS )ôrH Tz
|
Literal[1]©Úreturnc C s dS )Né © ©ÚselfrU rU úRd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/arrays/interval.pyÚndimÚ s zIntervalArray.ndimÚ IntervalSideTÚ_leftÚ_rightr/ Ú_dtypeNFztype[IntervalArrayT]z Dtype | NoneÚbool)ÚclsÚdtypeÚcopyÚverify_integrityc
|
C sà t |dd}t|| r<|j}|j}|p*|j}t|j|d}nt|r^| j d| d}t |t
|
|}t ||d kd\}}} |jt krt |¡}t |¡}|p | }| j|||||d\}}}|rÐ| j|||d | j|||dS ) NT©Z extract_numpy©Úclosedz5(...) must be called with a collection of some kind, z was passed)Zvalidate_closed©re ra r` ©r` )rA Ú
|
isinstancer[ r\ re r/ r` r+ Ú__name__Ú TypeErrorÚ _maybe_convert_platform_intervalr Úobjectr Zmaybe_convert_objectsÚ_ensure_simple_new_inputsÚ _validateÚ _simple_new)
|
r_ Údatare r` ra rb ÚleftÚrightÚmsgZ infer_closedrU rU rX Ú__new__æ sB
|
|
ÿ ÿ
|
|
|
û ýzIntervalArray.__new__rG )r_ rq rr r` rS c C s t | ¡}||_||_||_|S ©N)r rt r[ r\ r] )r_ rq rr r` ÚresultrU rU rX ro s
|
|
zIntervalArray._simple_newzIntervalClosedType | Nonez2tuple[IntervalSideT, IntervalSideT, IntervalDtype])re ra r` rS c
|
C s@ ddl m} |||d}t|}|||d}t|}|dkrLt|trL|j}|pRd}|dk rÖt|}t|rtt|}|j dk r¬|
|
|j ¡}|
|
|j ¡}nd| }t ||jdkrÄt|j |}n||jkrÖt dt |rôt|rô|
|
|j¡}n t |rt|r|
|
|j¡}t|t|krLdt|j d t|j d
|
}t |t|jsdt|jrpd }t |t|trd }t |t|trÈt|jt|jkrÈd |j d|j d}t |t|}t|dd}t|}t|dd}t|d|j}t|d|j} |dk r(|| kr(| ¡ }t|j|d}|||fS )z;Ensure correctness of input parameters for cls._simple_new.r )Ú ensure_index©ra Nrr z$dtype must be an IntervalDtype, got z*closed keyword does not match dtype.closedz 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 'ú'Trc Z_ndarrayrd ) Zpandas.core.indexes.baserw r# rh r/ re r. r( r ÚsubtypeÚastyperj Ú
|
ValueErrorr& r' r` Útyperi r$ r, r3 r1 ÚstrÚtzr@ rA ÚgetattrÚbasera )
|
r_ rq rr re ra r` rw rs ZlbaseZrbaserU rU rX rm ' sd
|
|
|
|
|
|
ÿÿ "ÿ z'IntervalArray._ensure_simple_new_inputs©r` ra )r_ r` ra rS c C s | |||dS )Nr rU )r_ Zscalarsr` ra rU rU rX Ú_from_sequence} s z IntervalArray._from_sequencez
|
np.ndarray)r_ ÚvaluesÚoriginalrS c C s( t |dkr| |jj¡}| ||jdS )Nr rd )Úlenr{ r` rz re )r_ r r
rU rU rX Ú_from_factorized s z IntervalArray._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_breaksrK zÒ Examples
|
--------
|
>>> pd.arrays.IntervalArray.from_breaks([0, 1, 2, 3])
|
<IntervalArray>
|
[(0, 1], (1, 2], (2, 3]]
|
Length: 3, dtype: interval[int64, right]
|
)rL rN rQ rr )r_ re ra r` rS c C s, t |}| j|d d
|dd
|||dS )NéÿÿÿÿrT ©ra r` )rk Ú from_arrays)r_ Zbreaksre ra r` rU rU rX r ± s 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 r z¸ >>> pd.arrays.IntervalArray.from_arrays([0, 1, 2], [1, 2, 3])
|
<IntervalArray>
|
[(0, 1], (1, 2], (2, 3]]
|
Length: 3, dtype: interval[int64, right]
|
c C sJ t |}t |}| j|||||d\}}}| j|||d | j|||dS )Nrf rg )rk rm rn ro )r_ rq rr re ra r` rU rU rX r 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. %(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)])
|
<IntervalArray>
|
[(0, 1], (1, 2]]
|
Length: 2, dtype: interval[int64, right]
|
c C sò t |rg g }}n| }}|D ]¼}t|tsBt|rBtj }} n| j}
|
z |\}} W nr tk
|
r } z |
|
d| } t| | W 5 d } ~ X Y n: tk
|
rÆ } z |
|
d| } t| | W 5 d } ~ X Y nX | |¡ | | ¡ q | j
|
|||d|dS )Nz..from_tuples requires tuples of length 2, got z'.from_tuples received an invalid item, Fr ) r rh Útupler5 ÚnpÚnanri r| rj Úappendr ) r_ rp re ra r` rq rr ÚdÚlhsÚrhsrN Úerrrs rU rU rX r G s$
|
zIntervalArray.from_tuplesÚNone)r` rS c C s t |ts d| }t|t|t|kr8d}t|t|}t|}||k ¡ s`d}t||| || k ¡ sd}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)rh r/ r| r r6 Úall)r_ rq rr r` rs Z left_maskZ
|
right_maskrU rU rX rn y s
|
|
ÿzIntervalArray._validate)rW rS c C s6 t |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.
|
rd rg )r/ r` re rm ro ©rW rq rr r` rU rU rX Ú _shallow_copy s zIntervalArray._shallow_copyc C s | j S ru )r] rV rU rU rX r` ª s zIntervalArray.dtypeÚintc C s | j j| jj S ru )rq Únbytesrr rV rU rU rX r ® s zIntervalArray.nbytesc C s | j jS ru )rq ÚsizerV rU rU rX r ² s zIntervalArray.sizer c C s t t | ¡S ru )Úiterr ÚasarrayrV rU rU rX Ú__iter__º s zIntervalArray.__iter__c C s
|
t | jS ru )r r[ rV rU rU rX Ú__len__½ s zIntervalArray.__len__r Ú IntervalOrNA)ÚkeyrS c C s d S ru rU ©rW r¡ rU rU rX Ú __getitem__À s zIntervalArray.__getitem__r )rW r¡ rS c C s d S ru rU r¢ rU rU rX r£ Ä s r z IntervalArrayT | IntervalOrNAc C sz t | |}| j| }| j| }t|tjtfsRt|rDt|rD| j S t
|
||| j S t |¡dkrht d| j||| jdS )NrT z&multi-dimensional indexing not allowedrg )rB r[ r\ rh r Úndarrayr; r+ r5 Ú _fill_valuer re rY r| ro r` )rW r¡ rq rr rU rU rX r£ È s
|
|
|
c C s0 | |¡\}}t| |}|| j|< || j|< d S ru )Ú_validate_setitem_valuerB r[ r\ )rW r¡ ÚvalueÚ
|
value_leftÚ value_rightrU rU rX Ú __setitem__Ý s
|
|
zIntervalArray.__setitem__c
|
C s t |r*t| t|kr tdt|}nTt|ts~|tkrrddlm} t j
|
| j t d}t j | j t d}|||S t| ||S t|trtd}nTt|js¤|j}nB|jj}t|ræ| j|jjkrÎt| ||S |jj|jd|jjd}t|rö| j|jkr
|
t| ||S t|ts"t| |}|tjkrF| j|j k| j |j k@ S |tj krj| j|j k| j |j kB S |tj kr| j|j k| j|j k| j |j k@ B S |tj!kr¶| |k| |kB S |tj"kræ| j|j k | j|j k| j |j k @ B S | |k| |k B S t#|s t| ||S t j$t| t d}t%|D ]X\}} z|| | | ||< W n6 t&k
|
rz | tkrt| 't(¡}t||< n Y nX q&|S )Nz Lengths must match to comparer )Ú BooleanArrayrg ÚintervalT©Ú
|
allow_fillÚ
|
fill_value))r) r r| Úpd_arrayrh r r Zpandas.core.arraysr« r ÚemptyÚshaper^ ZonesrC r. r$ r` Ú
|
categoriesr( re r8 ÚcodesÚ _na_valuer} ÚoperatorÚeqr[ rq r\ rr ÚneÚgtÚger r* ÚzerosÚ enumeraterj r{ rl )
|
rW ÚotherÚopr« ZarrÚmaskZ other_dtyperv ÚiÚobjrU rU rX Ú _cmp_methodä sp
|
|
|
|
|
|
ÿ
|
|
ÿ
|
ÿ
|
|
|
|
zIntervalArray._cmp_methodÚ__eq__c C s | |tj¡S ru )r r¶ r· ©rW r½ rU rU rX rà 3 s zIntervalArray.__eq__Ú__ne__c C s | |tj¡S ru )r r¶ r¸ rÄ rU rU rX rÅ 7 s zIntervalArray.__ne__Ú__gt__c C s | |tj¡S ru )r r¶ r¹ rÄ rU rU rX rÆ ; s zIntervalArray.__gt__Ú__ge__c C s | |tj¡S ru )r r¶ rº rÄ rU rU rX rÇ ? s zIntervalArray.__ge__Ú__lt__c C s | |tj¡S ru )r r¶ r rÄ rU rU rX rÈ C s zIntervalArray.__lt__Ú__le__c C s | |tj¡S ru )r r¶ r rÄ rU rU rX rÉ G s zIntervalArray.__le__Ú quicksortÚlast©Ú ascendingÚkindÚ na_positionr r~ )rÍ rÎ rÏ rS c sN t |d|¡}|r4|dkr4|dkr4t | j| jf¡S t jf |||d|S )NrU rÊ rË rÌ )ÚnvZ validate_argsort_with_ascendingr Zlexsortrr rq ÚsuperÚargsort)rW rÍ rÎ rÏ Úkwargs©Ú __class__rU rX rÒ K s ÿÿzIntervalArray.argsort)ÚaxisÚskipnazAxisInt | None)rÖ r× rS c C sZ t || j¡ t| s | jS | ¡ }| ¡ rB|s6| jS | | }n| }| ¡ d }|| S )Nr ©rÐ Zvalidate_minmax_axisrY r rµ r5 ÚanyrÒ ©rW rÖ r× r¿ rÁ ZindexerrU rU rX Úmin_ s zIntervalArray.minc C sZ t || j¡ t| s | jS | ¡ }| ¡ rB|s6| jS | | }n| }| ¡ d }|| S )Nr rØ rÚ rU rU rX Úmaxp s zIntervalArray.maxc C sV |dk rt d|dk r t d| |¡\}}| 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.
|
|
Returns
|
-------
|
filled : IntervalArray with NA/NaN filled
|
Nz5Filling by method is not supported for IntervalArray.z)limit is not supported for IntervalArray.)r§ )rj Ú_validate_scalarrq Úfillnarr r )rW r§ ÚmethodÚlimitr¨ r© rq rr rU rU rX rÞ s zIntervalArray.fillnarx c
|
sh ddl m} |dk r t|}t|r|| jkr@|r<| ¡ S | S t| jjrrt|jrrd| j d| d}t |z0|| j
|
dd |j¡}|| j dd |j¡}W nX t k
|
r¸ Y nD t tfk
|
rú } z"d| j d| d}t ||W 5 d}~X Y nX | ||¡S zt j ||dW S t tfk
|
rb } z$d t| j d
|
| }t ||W 5 d}~X Y 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 ©rE NzCannot convert z to z; subtypes are incompatibleFrx z Cannot cast z
|
to dtype )ÚpandasrE r. r( r` ra r& rz r- rj r[ r{ r\ r r| r rÑ r} ri )rW r` ra rE rs Únew_leftÚ new_rightr rÔ rU rX r{ © s6
|
|
ÿÿÿ zIntervalArray.astypec C s@ t | t |krdS t| j|jko<| j |j¡o<| j |j¡S )NF)r} r^ re rq Úequalsrr rÄ rU rU rX rå æ s ÿ ýzIntervalArray.equalszSequence[IntervalArrayT])r_ Ú to_concatrS c C sx dd |D }t |dkr"td| ¡ }t dd |D ¡}t dd |D ¡}| j|||d\}}}| j|||d S )
|
zÀ
|
Concatenate multiple IntervalArray
|
|
Parameters
|
----------
|
to_concat : sequence of IntervalArray
|
|
Returns
|
-------
|
IntervalArray
|
c S s h | ]
|
}|j qS rU rd ©Ú.0r¬ rU rU rX Ú <setcomp>ÿ s z2IntervalArray._concat_same_type.<locals>.<setcomp>rT z.Intervals must all be closed on the same side.c S s g | ]
|
}|j qS rU )rq rç rU rU rX Ú
|
<listcomp> s z3IntervalArray._concat_same_type.<locals>.<listcomp>c S s g | ]
|
}|j qS rU )rr rç rU rU rX rê s rd rg )r r| Úpopr Ú concatenaterm ro )r_ ræ Z
|
closed_setre rq rr r` rU rU rX Ú_concat_same_typeð s z IntervalArray._concat_same_typec C s* | j ¡ }| j ¡ }| j}| j|||dS )zd
|
Return a copy of the array.
|
|
Returns
|
-------
|
IntervalArray
|
rg )r[ ra r\ r` ro r rU rU rX ra s
|
|
zIntervalArray.copyc C s
|
t | jS ru )r5 r[ rV rU rU rX r5 s zIntervalArray.isnarT rl )Úperiodsr¯ rS c C s¼ t | r|dkr| ¡ S | |¡ tt|t | }t|rnddlm} || jddj }t
|
|g|d ¡}n| |g| ¡}|dkr|}| d |
}n| t|d
}|}| ||g¡S )Nr rá Frx rT )r ra rÝ rÛ Úabsr5 râ rE r[ rµ rH r r rí )rW rî r¯ Z empty_lenrE r± ÚaÚbrU rU rX Úshift s
|
zIntervalArray.shift)r® r¯ rÖ )rW r® rS c
|
K sV t d|¡ | }}|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.
|
rU r )rÐ Z validate_takerÝ r8 r[ r\ r )
|
rW Úindicesr® r¯ rÖ rÓ Z fill_leftZ
|
fill_rightZ left_takeZ
|
right_takerU rU rX r8 7 s" 6 ÿ ÿzIntervalArray.takec
|
C sÀ z(t |}| j|dd |j|j }}W n< tk
|
rd } z dt| d}t||W 5 d }~X Y nX z| j |¡ W n@ ttfk
|
r¶ } z dt| d}t||W 5 d }~X Y nX ||fS )Nr§ ©rN z('value' should be an interval type, got z instead.z2'value' should be a compatible interval type, got )rH Ú_check_closed_matchesrq rr rj r} Ú_validate_fill_valuer" )rW r§ r? r¨ r© r rs rU rU rX Ú_validate_listlike| s ÿ z IntervalArray._validate_listlikec C sT t |tr(| j|dd |j|j }}n$t|| jjrD| jj }}ntd||fS )Nr§ rô z=can only insert Interval objects and NA into an IntervalArray) rh r rõ rq rr r4 r` rµ rj )rW r§ rq rr rU rU rX rÝ s
|
ÿz IntervalArray._validate_scalarc C s t || jjr6| jj}t| jjr*td|| }}nJt|trv| j |dd |j|j
|
}}| j |¡ | j |¡ n
|
| |¡S ||fS )Nz4Cannot set float NaN to integer-backed IntervalArrayr§ rô ) r4 rq r` rµ r' rz rj rh r rõ rr rö r÷ )rW r§ r¨ r© rU rU rX r¦ s
|
|
z%IntervalArray._validate_setitem_valuerF )ÚdropnarS c C s t t | ¡|dS )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
|
)rø )r: r r )rW rø rU rU rX r: · s zIntervalArray.value_countsc
|
s& t | }ttdp|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
|
|¡}d
|
|¡} d| d| d}n( fdd | D }d
|
|¡} d| d}|S )Nzdisplay.max_seq_itemsé
|
r z[]rT ú[ú]é r z, c s g | ] } |qS rU rU ©rè Úx©Ú formatterrU rX rê â s z.IntervalArray._format_data.<locals>.<listcomp>c s g | ] } |qS rU rU rý rÿ rU rX rê ã s z ... c s g | ] } |qS rU rU rý rÿ rU rX rê è s )r rÛ r r~ Újoin)
|
rW ÚnZ max_seq_itemsrP ÚfirstrË ÚheadÚtailZhead_strZtail_strrU rÿ rX Ú _format_dataÎ s.
|
|
|
zIntervalArray._format_datac C s< | ¡ }dt| j d}| | dt| d| j }|S )Nú<z>
|
z
|
Length: z , dtype: )r r} ri r r` )rW rp Ú
|
class_nameÚtemplaterU rU rX Ú__repr__î s zIntervalArray.__repr__c C s dt t| jd }d| S )Nú rT Ú
|
)r r} ri )rW ÚspacerU rU rX Ú _format_spaceø s zIntervalArray._format_spacec C s ddl m} || jddS )z^
|
Return the left endpoints of each Interval in the IntervalArray as an Index.
|
r rá Frx )râ rE r[ ©rW rE rU rU rX rq ÿ s zIntervalArray.leftc C s ddl m} || jddS )z_
|
Return the right endpoints of each Interval in the IntervalArray as an Index.
|
r rá Frx )râ rE r\ r rU rU rX rr s zIntervalArray.rightrE c C s | j | j S )zT
|
Return an Index with entries denoting the length of each Interval.
|
)rr rq rV rU rU rX Úlength s zIntervalArray.lengthc C s< zd| j | j W S tk
|
r6 | j d| j Y S X dS )zX
|
Return the midpoint of each Interval in the IntervalArray as an Index.
|
g à?N)rq rr rj r rV rU rU rX Úmid 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
|
<IntervalArray>
|
[(0, 1], (1, 3], (2, 4]]
|
Length: 3, dtype: interval[int64, right]
|
)rL rQ c C sx t |ttfrtt |ts4dt|j }t|| jrD|j rDt
|
nt }|jrX| j rXt
|
nt }|| j |j ||j | j @ S )Nz#`other` must be Interval-like, got )rh rH r2 ÚNotImplementedErrorr r} ri rj Z closed_leftZ closed_rightr r rq rr )rW r½ rs Zop1Zop2rU rU rX r K s
|
zIntervalArray.overlapsr c C s | j jS )z
|
String describing the inclusive side the intervals.
|
|
Either ``left``, ``right``, ``both`` or ``neither``.
|
)r` re rV rU rU rX re m s zIntervalArray.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
|
<IntervalArray>
|
[(0, 1], (1, 2], (2, 3]]
|
Length: 3, dtype: interval[int64, right]
|
>>> index.set_closed('both')
|
<IntervalArray>
|
[[0, 1], [1, 2], [2, 3]]
|
Length: 3, dtype: interval[int64, both]
|
)rW re rS c C sF |t krd| }t|| j| j }}t|j|d}| j|||dS )Nz invalid option for 'closed': rd rg )r r| r[ r\ r/ r` ro )rW re rs rq rr r` rU rU rX r s
|
zIntervalArray.set_closedzç
|
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.
|
Ú is_non_overlapping_monotonicc C s | j dkrNt| jd d
| jdd
k ¡ pJ| jd d
| jdd
k ¡ S t| jd d
| jdd
k ¡ p| jd d
| jdd
k ¡ S )NZbothr rT )re r^ r\ r[ r rV rU rU rX r ¯ s
|
þ þz*IntervalArray.is_non_overlapping_monotoniczNpDtype | Nonec C sj | j }| j}| ¡ }| j}tjt|td}t|D ]0\}}|| rPtj ||< q4t
|
||| |||< q4|S )zt
|
Return the IntervalArray's data as a numpy array of Interval
|
objects (with dtype='object')
|
rg ) r[ r\ r5 re r r± r rl r¼ r r ) rW r` rq rr r¿ re rv rÀ Z
|
left_valuerU rU rX Ú __array__Ê s zIntervalArray.__array__c
|
|
C sp ddl }ddlm} z| | jj¡}W n8 tk
|
r^ } ztd| jj d|W 5 d}~X Y nX ||| j}|jj |j
|
| j |dd|j
|
| j |ddgdd gd
|
}| ¡ }| ¡ rð|
|
| ¡ ¡ d } |jj|jt|| g| d¡| d ¡gd }|dk rb| |j¡r |S t||rR| |¡sbtd | jj d|j d| j d|j d ntd| d|j ||¡S )z6
|
Convert myself into a pyarrow Array.
|
r N)ÚArrowIntervalTypez"Conversion to arrow with subtype 'z' is not supportedT)r} Z from_pandasrq rr )ÚnamesrT )Ú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.extension_typesr Zfrom_numpy_dtyper` rz rj re Z StructArrayr r? r[ r\ r5 rÙ ÚbuffersZ from_buffersr} r Úfieldrå Z storage_typerh r; Z from_storage)
|
rW r} r r rz r Z interval_typeZ storage_arrayr¿ Z null_bitmaprU rU rX Ú__arrow_array__Ü sL ÿý þûü
|
&ÿ
|
ÿz IntervalArray.__arrow_array__ak
|
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``.
|
|
Returns
|
-------
|
tuples: %(return_type)s
|
%(examples)s Ú to_tuplesr¤ )Ú return_typerQ )Úna_tuplerS c C s2 t t| j| j¡}|s.t | ¡ |tj¡}|S ru ) ÚcomZasarray_tuplesafeÚzipr[ r\ r Úwherer5 r )rW r ZtuplesrU rU rX r ! s zIntervalArray.to_tuplesznpt.NDArray[np.bool_])r¿ rS c C s | |¡\}}t| jtjrPt | j||¡ t| jtjs>tt | j||¡ n.| j ||¡ t| jtjrpt| j ||¡ d S ru ) r¦ rh r[ r r¤ Zputmaskr\ ÚAssertionErrorÚ_putmask)rW r¿ r§ r¨ r© rU rU rX r% - s zIntervalArray._putmaskr )rW ÚlocÚitemrS c C s6 | |¡\}}| 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Ý rq Úinsertrr r )rW r& r' Z left_insertZ right_insertrã rä rU rU rX r( 9 s zIntervalArray.insertc C sv t | jtjr>t | j|¡}t | jtjs.tt | j|¡}n*| j |¡}t | jtjr\t| j |¡}| j||dS )N©rq rr )rh r[ r r¤ Údeleter\ r$ r )rW r& rã rä rU rU rX r* O s zIntervalArray.deleteÚrepeatzint | Sequence[int])rW ÚrepeatsrÖ rS c C s6 t dd|i¡ | j |¡}| j |¡}| j||dS )NrU rÖ r) )rÐ Zvalidate_repeatrq r+ rr r )rW r, rÖ Z left_repeatZ right_repeatrU rU rX r+ Z 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.
|
|
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, dtype: interval[int64, right]
|
c C sF t |trtd| jr"| j|k n| j|k| jr:|| jk n|| jk@ S )Nz*contains not implemented for two intervals)rh r r Z open_leftr[ Z
|
open_rightr\ rÄ rU rU rX r- s
|
|
ÿzIntervalArray.containsc C s¶ t |dst |¡}t|dd}t|jr | j|jkrFtj| jt dS t
|
| j|jrx| j d¡}|j d¡}t ||¡S t| jjt|jjA r tj| jt dS t| t¡| t¡S )Nr` Trc rg Ú
|
complex128)Úhasattrr r? rA r( r` re r» r² r^ r% Ú _combinedÚviewZin1dr- rq r7 r{ rl )rW r rq rr rU rU rX r7 s
|
|
|
ÿzIntervalArray.isinc C sT | j j dd¡}| jj dd¡}t|jr>|j||gdd}ntj||gdd}|S )Nr rT )rÖ ) rq Z_valuesÚreshaperr r- r` rí r rì )rW rq rr ÚcombrU rU rX r0 º s
|
zIntervalArray._combined)ÚcombinedrS c C sÖ | d¡ dd¡}| jj}t|rt| jttfs6tt | jj
|
|dd
df |d}t| j ttfsjtt | j j
|
|dd
df |d}n<t|t jst|dd
df |¡}|dd
df |¡}| j ||dS ) zY
|
Create a new IntervalArray with our dtype from a 1D complex128 ndarray.
|
Úi8r rü Nr rg rT r) )r1 r2 r[ r` r- rh r= r> r$ r} r r\ r r )rW r4 Úncr` rã rä rU rU rX Ú_from_combinedÄ s "z IntervalArray._from_combinedc C s6 t | j d¡d d
df }|d d
d f }| |¡S )Nr. r )r9 r0 r1 r7 )rW r6 rU rU rX r9 Ö s
|
ÿzIntervalArray.unique)NNFT)NFN)rr FN)rr FN)rr FN)NNN)T)rT N)T)N)N)T)N)Sri Ú
|
__module__Ú __qualname__Z can_hold_nar r rµ r¥ ÚpropertyrY Ú__annotations__rt Ú classmethodro rm r r ÚtextwrapÚdedentrJ r! r r r rn r r` r r r r r r£ rª r rD rà rÅ rÆ rÇ rÈ rÉ rÒ rÛ rÜ rÞ r{ rå rí ra r5 rò r8 r÷ rÝ r¦ r: r r
|
r rq rr r r r re r Ú_shared_docs_kwargsr r r r r% r( r* r< r+ r- r7 r0 r7 r9 Ú __classcell__rU rU rÔ rX rH º s°
|
|
ú3 úUû
|
ÿ ÿýÿÿ û ÿ2ÿýÿÿ ú ÿ!ÿýÿÿ û O
|
|
|
|
|
|
û ÿ(=
|
úE
|
|
|
|
ÿ(ÿþÿÿ
|
ÿÿþÿÿ þÿ
|
ÿ
|
6þÿÿ ý
|
ÿ ÿþÿÿ
|
r rR c C s¶ t | ttfr*t| dkr*tjg tjdS t| r<t | tr@| S t | rTt
|
| ¡} n*t | dsrt | ttt fsr| S t | dd} t | ds²t
|
| ¡} t| r²| 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
|
r rg r` Trc )rh Úlistr r r r? Úint64r) r0 r$ r r/ ÚrangerA r' r` r{ )r rU rU rX rk à s
|
|
rk )qÚ
|
__future__r r¶ r r r= Útypingr r r r r r
|
r r Únumpyr Zpandas._configr Z pandas._libsr Zpandas._libs.intervalr r r r Zpandas._libs.missingr Zpandas._typingr r r r r r r r r r r Zpandas.compat.numpyr rÐ Z pandas.errorsr Zpandas.util._decoratorsr! Zpandas.core.dtypes.castr" r# Zpandas.core.dtypes.commonr$ r% r& r' r( r) r* r+ r, r- r. Zpandas.core.dtypes.dtypesr/ Zpandas.core.dtypes.genericr0 r1 r2 r3 Zpandas.core.dtypes.missingr4 r5 r6 Zpandas.core.algorithmsr7 r8 r9 r: Zpandas.core.arrays.baser; r< Z pandas.core.arrays.datetimesr= Z pandas.core.arrays.timedeltasr> Zpandas.core.commonÚcoreÚcommonr! Zpandas.core.constructionr? r° r@ rA Zpandas.core.indexersrB Zpandas.core.opsrC rD râ rE rF rG r¤ rZ Úfloatr rJ r; r? r> rH rk rU rU rU rX Ú<module> s ( 4 4 ý þÿ?ÿùÿÿ
|
