o i6@sddlmZddlmZddlZddlmZmZmZm Z m Z m Z m Z ddl Z ddlZddlmZmZmZmZddlmZddlmZddlmZmZmZmZmZm Z dd l!m"Z"dd l#m$Z$dd l%m&Z&dd l'm(Z(dd l)m*Z*ddl+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1ddl2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:ddl;mZ>m?Z?ddl@mAZAmBZBmCZCmDZDddlEmFZFddlGmHZHmIZImJZJddlKmLmMZNddlOmPZPmQZQmRZRmSZSmTZTddlUmVZVddlWmXZXmYZYmZZZddl[m\Z\ddl]m^Z^m_Z_m`Z`maZambZbmcZcmdZdddlemfZfddlgmhZhddlimLmjZkddllmLmmmnZnddlompZpmqZqddlrmsZsddltmLmuZuerDddlvmwZwmxZxddlymzZze{dZ|dcd#d$Z}Gd%d&d&ehZ~Gd'd(d(e~ZGd)d*d*ej~eZGd+d,d,eje~ZGd-d.d.eZGd/d0d0ejeZddd4d5ZGd6d7d7eZGd8d9d9eZGd:d;d;eZGd.newfuncNrRrS)rr r)rQr^r\r[r] maybe_split{s r`c@sleZdZUdZded<ded<ded<dZd Zd Zd Zd Z d Z e e d d Z e e dddZe e dddZe edddZe ddZe e ddZe ddZedddZejdd dZe ddd"d#Ze !ddd&d'Ze dd)d*Ze dd+d,Ze dd/d0Ze dd2d3Ze dd6d7Ze dd:d;Ze dd=d>Zddd@dAZ e ddCdDZ!e ddEdFZ"e ddGdHZ#e ddIdJZ$e dddLdMZ%e e&ddNdOZ' dddTdUZ(e ddWdXZ)e Yddd]d^Z*e ddd`daZ+e dddcddZ,e !dddhdiZ-e !dddkdlZ.e dddrdsZ/e dddudvZ0ddydzZ1d{d|Z2edd~dZ3dddZ4dddZ5ddddZ6d!e7j8fdddZ9dddZ:dddZ;dddZ ! ! ! ! !ddddZ?ddddZ@ddddZAe ddddZBdddZCedddZDedddZEddddZFddd„ZGd!S)Blockz Canonical n-dimensional unit of homogeneous dtype contained in a pandas data structure Index-ignorant; let the container take care of that np.ndarray | ExtensionArrayvaluesintrUr__init__r\FTcCs|j|jjfSN)_can_consolidatedtypenamerXr\r\r]_consolidate_keyszBlock._consolidate_keyrRboolcCs"|j}t|tjr|jdvS|jS)z7 Can we store NA values in this Block? )biu)rh isinstancenpkind _can_hold_narXrhr\r\r]rss  zBlock._can_hold_nacCstjdttdt|jtS)NzBlock.is_categorical is deprecated and will be removed in a future version. Use isinstance(block.values, Categorical) instead. See https://github.com/pandas-dev/pandas/issues/40226 stacklevel)warningswarnDeprecationWarningrrprcrArjr\r\r]is_categoricals  zBlock.is_categoricalcC t|jS)z^ We can be bool if a) we are bool dtype or b) object dtype with bool objects. )r3rcrjr\r\r]is_bools z Block.is_boolcCr{rf)external_valuesrcrjr\r\r]r} zBlock.external_valuescCst|jddS)NF)compat)r6rhrjr\r\r] fill_valuezBlock.fill_valuecCs |jtkrt||jr|j}|Srf)rh _dtype_objr4rrXvaluer\r\r]_standardize_fill_valueszBlock._standardize_fill_valuercC|jSrf _mgr_locsrjr\r\r]mgr_locszBlock.mgr_locs new_mgr_locsNonecCs ||_dSrfr)rXrr\r\r]rr~NcCs2|dur|j}|jrt||jd}t|||jdS)zm Create a new block, with type inference propagate any values that are not specified NrU placementrU)r is_extensionensure_block_shaperU new_block)rXrcrr\r\r] make_blocks zBlock.make_blockrBlockPlacement | NonecCsT|dur|j}|jjdvr t|}||urtjdttd|}t||||j dS)z2Wrap given values in a block of same type as self.N)mMzIn a future version, Block.make_block_same_class will assume that datetime64 and timedelta64 ndarrays have already been cast to DatetimeArray and TimedeltaArray, respectively.rur) rrhrrrJrwrxryrtyperU)rXrcr new_valuesr\r\r]make_block_same_classs zBlock.make_block_same_classstrcCslt|j}|jdkr|dt|d|j}|Sddd|jD}|d|jjd|d|j}|S) NrTz: z dtype: z x cSg|]}t|qSr\)r.0sr\r\r] z"Block.__repr__..z, z , dtype: ) r__name__rUlenrhjoinrVrindexer)rXriresultrVr\r\r]__repr__s   zBlock.__repr__cCr{rf)rrcrjr\r\r]__len__r~z Block.__len__slicerslice | npt.NDArray[np.intp]cCs<|j|}||}|j|jjkrtdt||||jSz Perform __getitem__-like, return result as block. Only supports slices that preserve dimensionality. z Only same dim slicing is allowed)r_slicerUrc ValueErrorrrXrrrr\r\r] getitem_blocks zBlock.getitem_blockslicecCs2||}|j|jjkrtdt||||jSr)rrUrcrrrr\r\r]getitem_block_columns-s zBlock.getitem_block_columnselementrcCst|dd}t|j|S)z#require the same dtype as ourselvesT extract_numpy)rKrrc)rXrr\r\r]_can_hold_element=s  zBlock._can_hold_elementrrcCs$z|j|jkWStyYdSw)z Should we set self.values[indexer] = value inplace or do we need to cast? Parameters ---------- value : np.ndarray or ExtensionArray Returns ------- bool F)rh TypeErrorrr\r\r] should_storeCs  zBlock.should_storerScKs||jfi|}||S)z[ apply the function to my values; return a block if we are not one )rc_split_op_result)rXfuncrZrr\r\r]applyYs z Block.applyignore_failuresc Csv|jdksJz||j}Wnttfy|rgYSw|jjdkr-t|gg}n|dd}||}|gS)NrT)rUrcrNotImplementedErrorrqarrayreshaper)rXrrr res_valuesnbr\r\r]reducecs   z Block.reducercCs||jdkr6t|jtr6g}t|jD]!\}}t|s#|||d}n||}|j||d}||q|S||}|gS)NrT)rcr) rUrprhr, enumeraterr%rappend)rXrnbsrnlocvalsblockrr\r\r]rxs  zBlock._split_op_resultcCsb|jdksJg}t|jD] \}}|jt||d}t|}t|||dd}||q|S)zD Split a block into a list of single-column blocks. rrTr)rUrrrcrrrr)rX new_blocksrnref_locrbprr\r\r]_splits z Block._splitcOsR|jdkr |jddksJg}|D]}||g|Ri|}||q|S)z Split the block and apply func column-by-column. Parameters ---------- func : Block method *args **kwargs Returns ------- List[Block] rrrT)rUrVrextend)rXrrYrZ res_blocksrrbsr\r\r]rWs   zBlock.split_and_operatecCst|j|}|j|ddS)z coerce the current block to a dtype compat for other we will return a block, possibly object, and not raise we can also safely try to coerce to the same dtype and will receive the same block Fcopy)rrcastype)rXother new_dtyper\r\r]coerce_to_target_dtypes zBlock.coerce_to_target_dtypeblockscsJdur|S|jtkrtdd|DSdur|Stfdd|DS)NFcSg|] }|jdddqS)TF)datetimenumericconvertrblkr\r\r]rz)Block._maybe_downcast..csg|]}|qSr\) _downcast_2drrmdowncastr\r]rs)rhr extend_blocks)rXrrr\rr]_maybe_downcasts  zBlock._maybe_downcastcCst|j|d}||gS)zs downcast specialized to 2D case post-validation. Refactored to allow use of maybe_split. rh)r rcr)rXrhrr\r\r]rs zBlock._downcast_2drrr timedeltacCs|r|gS|gS)z attempt to coerce any object types to better types return a copy of the block (if copy = True) by definition we are not an ObjectBlock here! r)rXrrrrr\r\r]rs z Block.convertrcC|jjSrfrcrhrjr\r\r]rhz Block.dtyperaiserherrorsrc Csl|j}t||||d}t|}||}|j|jkr4td|d|jjd|jd|jjd|jd |S)a Coerce to the new dtype. Parameters ---------- dtype : np.dtype or ExtensionDtype copy : bool, default False copy if indicated errors : str, {'raise', 'ignore'}, default 'raise' - ``raise`` : allow exceptions to be raised - ``ignore`` : suppress exceptions. On error return original object Returns ------- Block )rrzcannot set astype for copy = [z ] for dtype (z [z]) to different shape (z]))rcrmaybe_coerce_valuesrrVrrhri)rXrhrrrcrnewbr\r\r]rs"  z Block.astypenancKs"t|jf||d|}||S)"convert to our native types format)na_repquoting)to_native_typesrcr)rXrrrZrr\r\r]rs zBlock.to_native_typesdeepcCs(|j}|r |}t|||j|jdS)zcopy constructorr)rcrrrrU)rXrrcr\r\r]r sz Block.copyinplacemasknpt.NDArray[np.bool_] | Nonec Csn|j}t|tr|r |n|}|jj||dd|gS||s+|r&|gS|gS|dur5t||}|sC|r>|gS|gS||rl|rL|n|}t |j|||j r^|dusg|j ddd}|S|g}|S|j dksx|j ddkr|dur|tt}n||}|j||d|dSg}t|D]\}} |t|j| ||d|||ddq|S) z replace the to_replace value with value, possible to create new blocks here this is just a call to putmask. T) to_replacerrNFrrrTrrrrr)rcrprAr_replacermissing mask_missinganyr8 is_objectrrUrVrrqrhrPrreplacerrrr) rXrrrrrcrrrnrr\r\r]r+sV       z Block.replacerc Csb||s|r |gS|gSt|}|r|jn|j}t||||||}|jdddS)aP Replace elements by the given value. Parameters ---------- to_replace : object or pattern Scalar to replace or regular expression to match. value : object Replacement object. inplace : bool, default False Perform inplace modification. convert : bool, default True If true, try to coerce any object types to better types. mask : array-like of bool, optional True indicate corresponding element is ignored. Returns ------- List[Block] Fr)rrrecompilercr>rr) rXrrrrrrxrrr\r\r]_replace_regex|s   zBlock._replace_regexsrc_list Iterable[Any] dest_list Sequence[Any]regexc shjfddt||D}t|s|rgSgSt|d}tjr9tfdd|D}n fdd|D}dd|D}|rMng}t|D][\} \} } | |k} g} t|D]H\}}t|dkru|| }n|| }t|t rJ|||d}|j | | ||d}| r|j rt dd |Dst d d|D}| |qf| }qV|S) z: See BlockManager.replace_list docstring. cs"g|] \}}|r||fqSr\)r)rxyrjr\r]rs z&Block.replace_list..rTcs g|] }t|ddqS)r)rr)r=r)rrrcr\r]rscsg|] }t|dqSr)rrrrcr\r]rcSrr\)r7rr r\r\r]rr)rrrrrcss|]}|duVqdSrfr\rr\r\r] sz%Block.replace_list..cSr)FTrrrr\r\r]rr)rcziprrr*rhr5rrprl_replace_coercerallrr)rXrrrrpairssrc_lenmasksrbrnsrcdestrnew_rbblk_numrrmibrr\)rrrXrcr] replace_listsL        zBlock.replace_listnpt.NDArray[np.bool_]cCst||r|j|||d|dS|dur?|r5|jttdd}||ur+|s+|}t|j |||gS|r:|gS|gS|j ||||dS)ai Replace value corresponding to the given boolean array with another value. Parameters ---------- to_replace : object or pattern Scalar to replace or regular expression to match. value : object Replacement object. mask : np.ndarray[bool] True indicate corresponding element is ignored. inplace : bool, default True Perform inplace modification. regex : bool, default False If true, perform regular expression substitution. Returns ------- List[Block] F)rrrNrr) r?rrrrqrhrPrr8rcr)rXrrrrrrr\r\r]rs&  zBlock._replace_coercearg np.ndarraycC|SzA For compatibility with 1D-only ExtensionArrays. r\rXrr\r\r]_maybe_squeeze_arg)zBlock._maybe_squeeze_argcCr r!r\)rXrr\r\r]_unwrap_setitem_indexer/r$zBlock._unwrap_setitem_indexerrcCrrf)rcrVrjr\r\r]rV7rz Block.shapern)int | tuple[int, int] | tuple[slice, int]cC |j|Srfr )rXrnr\r\r]iget;s z Block.iget4slice | npt.NDArray[np.bool_] | npt.NDArray[np.intp]cCr')zreturn a slice of my valuesr )rXrr\r\r]rDs z Block._slicecCs|r|j|_||j|<dS)a Modify block values in-place with new item value. If copy=True, first copy the underlying values in place before modifying (for Copy-on-Write). Notes ----- `set_inplace` never creates a new array or new Block, whereas `setitem` _may_ create a new array and always creates a new Block. Caller is responsible for checking values.dtype == self.dtype. NrcrrXlocsrcrr\r\r] set_inplaceKs zBlock.set_inplacernpt.NDArray[np.intp]axiscCs||j}|tjur|j}d}nd}tj|||||d}|dkr$|dur$J|dur+|j}t|j|js8| ||S| ||S)N Take values according to indexer and return them as a block. FT)r/ allow_fillrrN) rcr no_defaultralgostake_ndrr&rhrr)rXrr/rrrcr1rr\r\r]r4]s    z Block.take_nd new_placement needs_maskingc CsP|j|jj|d\}}|d}|j|}||}t|}t||dg}||fS)a  Return a list of unstacked blocks of self Parameters ---------- unstacker : reshape._Unstacker fill_value : int Only used in ExtensionBlock._unstack new_placement : np.ndarray[np.intp] allow_fill : bool needs_masking : np.ndarray[bool] Returns ------- blocks : list of Block New blocks of unstacked values. mask : array-like of bool The mask of columns of `blocks` we should keep. rrr)get_new_valuesrcTrr new_block_2d) rX unstackerrr5r6rrrrr\r\r]_unstacks  zBlock._unstackcCs||}ttj|j}|jdkr|j}t|||t|dd}zt |j |}Wnt y<| |}| ||YSw|j tkrS||}t|rSt|t||}|||<|S)a Attempt self.values[indexer] = value, possibly creating a new array. Parameters ---------- indexer : tuple, list-like, array-like, slice, int The subset of self.values to set value : object The value being set Returns ------- Block Notes ----- `indexer` is a direct slice/positional indexer. `value` must be a compatible shape. rTr)rr rqndarrayrcrUr:rLrKr!rhrrsetitemrr r(r:r)rXrrrccastedrvir\r\r]r?s$        z Block.setitemc Cst|}ttj|j}t|j|\}}t|ttt frJ|t j ur#|j }| |}t|dd}|r3|gSzt|j|}t|j|||gWSty|jdksW|jddkryt|sf||||YS|d}||||}|gYSt|tj} g} |} t| D]+\} }|} | r|dd| | df} |dd| | df}||| }| |q| YSw)aV putmask the data to the block; it is possible that we may create a new dtype of block Return the resulting block(s). Parameters ---------- mask : np.ndarray[bool], SparseArray[bool], or BooleanArray new : a ndarray/object Returns ------- List[Block] TrrTrN)r rqr>rcr;r:rpr0r2r/r r2rrrKr!rhr9rrUrVr(rputmasknonzeror?rrr)rXrnew orig_maskrcnoopr@rris_arrayrrrnnsubmaskrr\r\r]rBsB          z Block.putmaskinferc CsB|j|jksJt|tttfrJ|jdk}t|}ttj|j }|}|r)|j }t ||\}}|r8| gS|t jur@|j}||}zt|j|} Wnntttfy|jdksc|jddkrw||} | ||} |j| |dYSt|tjtf} g} |}t|D]-\}}|}| r|dd||df}|dd||df}|j|||d}| |q| YSw| }t|||}||urt |rt!|t!|krt|||t"d| }t#|||n't |r t|tjs t!||jdkr t$|%|j}t&|||}|r|j }|'|gS) a evaluate the block; return result block(s) from the result Parameters ---------- other : a ndarray/object cond : np.ndarray[bool], SparseArray[bool], or BooleanArray _downcast : str or None, default "infer" Private because we only specify it when calling from fillna. Returns ------- List[Block] rrTrrN _downcastzThis should not be reached; call to np.where above is expected to raise ValueError. Please report a bug at github.com/pandas-dev/pandasr)(rUrpr0r2r/r7r rqr>rcr:r;rr r2rrr!rhrrrrVrwhererrCrrrr:sumr(rrrBrr expressionsr)rXrcondrL transposerc orig_othericondrFr@rrrGrrrnrothrIraltrr\r\r]rMsj         z Block.wherelimit int | Nonec st|d}|js d}n t|j}t|j|\}}|r-|r|gS|}|j|gd}|S|dur=d|||jd|k<|rG| |j |}n |j ||j dd}t fdd |DS) zs fillna on the block with the value. If we fail, then convert to ObjectBlock and try again rTrNFrTrKcsg|] }|j|gdqS)r)rrrr\r]rr z Block.fillna..) rrsr5rcr;rrcumsumrUrBr:rMr) rXrrVrrrFrrrr\rr]fillnas&  z Block.fillnapadrforwardmethodindex Index | Nonelimit_direction limit_area str | Noner Any | Nonerc  Kst|d}|js|r |gS|gSzt|} Wn ty$d} Ynw| dur9|jjdkr9|r4|gS|gS|jra|j dkra|j ddkra|dkra|j t |j ||||||||| f i| S|rf|jn|j} ttj| } tj| f|||||||d| || } | | g| S)NrfrrrT)r\r/r]rVr_r`r)rrsrrclean_fill_methodrrhrrrrUrVrWr interpolatercr rqr>interpolate_array_2drr)rXr\r/r]rrVr_r`rrrZrdatarr\r\r]resT  &    zBlock.interpolaterTrHcCs tj|j||d}|j|dgS)z'return block for the diff of the valuesr/r )r3diffrcr)rXrHr/rr\r\r]risz Block.diffperiodscCst|s|jtkrtd||}zt|j|}Wnty1||}|j |||dYSwt t j |j }t ||||}||gS)z+shift the block by periods, possibly upcastzfill_value must be a scalar)r/r)r is_scalarrhrrrr!rrr@r rqr>rcr)rXrjr/rr@rrcrr\r\r]r@s     z Block.shiftlinearqsrMcCsV|jdksJ|dks Jt|sJt|jt|j|}t|dd}t||j dS)a\ compute the quantiles of the Parameters ---------- qs : Float64Index List of the quantiles to be computed. interpolation : str, default 'linear' Type of interpolation. axis : int, default 0 Axis to compute. Returns ------- Block rrTrr8) rUr(r<rcrqasarray_valuesrr;r)rXrm interpolationr/rr\r\r]quantiles    zBlock.quantilecCt|)zC Return a new Block with the given loc(s) deleted. r)rXrr\r\r]delete@sz Block.deletecCrr)(return a boolean if I am possibly a viewrrjr\r\r]is_viewFsz Block.is_viewrCcCrr)zP The array that Series.array returns. Always an ExtensionArray. rrjr\r\r] array_valuesKzBlock.array_valuesDtypeObj | NonecCrr)z return an internal format, currently just the ndarray this is often overridden to handle to_dense like operations rrtr\r\r] get_valuesRrwzBlock.get_valuescCrrrfrrjr\r\r]values_for_jsonYzBlock.values_for_jsonrRrl)rRr)rrrRrrfrRra)rrrRra)rRr)rRrd)rrrRra)rrrrrRra)rrrRrl)rrrRrlr_FrrlrRrS)rrrRrS)rrSrRrSTTTT rrlrrlrrlrrlrRrSrRr)Fr)rhrrrlrrrRra)rN)T)rrlrRra)FN)rrlrrrRrS)FTN)rrlrrlrRrS)FF) rrrrrrlrrlrRrS)TF)rrrrlrrlrRrS)rrrRrrRr)rnr&rRr)rr)rRrrcrrrlrRrrr.r/rdrrrRrar5r.r6rrJNFNrVrWrrlrRrS) rZrNFNr[NNN)r\rr/rdr]r^rrlrVrWr_rr`rarrbrrarRrSrTrHrdr/rdrRrSrNrjrdr/rdrrrRrS)rlr)rmrMr/rdrRrarRrCrhrxrRrrRr)Hr __module__ __qualname____doc____annotations__ __slots__ is_numericrrrg_validate_ndimr rrkrsrzpropertyr|r}rrrsetterrrrrrrrrrrrrrWrrr`rrrhrrrrrrrr#r%rVr(rr-r r2r4r=r?rBrMrYrerir@rqrsrurvryrzr\r\r\r]ras                         ! P)J 7    " . 0 ?p 0 @   !   racseZdZUdZded<ddZd%d&d d Zd&d d Z d'd(fdd Zd)ddZ e d*ddZ d+d,ddZ d-dd Z d.d#d$ZZS)/ EABackedBlockz> Mixin for Block subclasses backed by ExtensionArray. rCrcc Cs|}|}||}||}|j}|jdkr|j}t|||z|||<W|Sttfye}z1t|t |j rJ| |}| ||WYd}~St |tr`| |}| ||WYd}~Sd}~ww)a7 Attempt self.values[indexer] = value, possibly creating a new array. This differs from Block.setitem by not allowing setitem to change the dtype of the Block. Parameters ---------- indexer : tuple, list-like, array-like, slice, int The subset of self.values to set value : object The value being set Returns ------- Block Notes ----- `indexer` is a direct slice/positional indexer. `value` must be a compatible shape. rN)r%r#rcrUr:rLrr_catch_deprecated_value_errorr'rhrr?rpNDArrayBackedExtensionBlock)rXrr orig_indexer orig_valuercerrrr\r\r]r?ds,         zEABackedBlock.setitemrJrRrSc Cs|jj}t|}|}|}||}||}|tjur|j}t||\}}|r-|gSz | ||j} Wnt t fy} zt | |j dksP|jddkrt|jrm||} | ||} |j| |dWYd} ~ St|tr||} | ||} |j| |dWYd} ~ St|tjtf} g}|} t| D]+\}}|}| r|dd||df}|dd||df}|||}||q|WYd} ~ Sd} ~ ww|| }|gS)NrTrr)rcr:r7r#r r2rr;r_whererrrrUrVr'rhrrMrrprrqr>rCrrrr)rXrrPrLarrrR orig_condrSrFrrrrrGrrnrrHrIrr\r\r]rMsP             &zEABackedBlock.wherec Cst|}|j}|jdkr|j}|}|}||}||}|s$|gSz |||W|gSttfy}zt ||jdksH|j ddkrut |j r^| |}|||WYd}~St|trt| |}|||WYd}~St|tjtf}g} |} t| D]+\} } |} |r|dd| | df} |dd| | df}| || }| |q| WYd}~Sd}~ww)z+ See Block.putmask.__doc__ rrTrN)r7rcrUr:r#r_putmaskrrrrVr'rhrrBrprrqr>rCrrr)rXrrDrcorig_newrErrrGrrrnrrHrIrr\r\r]rBsH   &      zEABackedBlock.putmaskNFrVrWrrlc sx|jjdkr2z |jj||d}Wnttfy)tjdt|dt t dw| |}|gSt j||||dS)Nr)rVzMThe behavior of fillna with timedelta64[ns] dtype and an incompatible value (z) is deprecated. In a future version, this will cast to a common dtype (usually object) instead of raising, matching the behavior of other dtypes.ru)rVrr) rhrrrcrYrrrwrxr FutureWarningrrsuper)rXrrVrrrres_blk __class__r\r]rYs   zEABackedBlock.fillnaracCs,|j|}|j|}t||||jdS)Nr)rcrsrrrUrXrrcrr\r\r]rs4s  zEABackedBlock.deletecCrrfr rjr\r\r]rv:rzEABackedBlock.array_valuesrhrxrcCs*|j}|tkr |t}t||jS)zS return object dtype as boxed values, such as Timestamps/Timedelta )rcrrrPrqrnrrV)rXrhrcr\r\r]ry>s zEABackedBlock.get_valuescCs t|jSrf)rqrnrcrjr\r\r]rzHs zEABackedBlock.values_for_jsonrZrc KsH|j}|jdkr|dkr|jj|||dj}n|j|||d}||S)Nrr)rr\rV)rcrUr:rYr) rXr\r/rrVrrZrcrr\r\r]reKs  zEABackedBlock.interpolaterr_rrr}rrfrr)rZrFNN)rrrrrr?rMrBrYrsrrvryrzre __classcell__r\r\rr]r]s  8 ?=    rcseZdZUdZdZdZdZded<ed=dd Z d>d d Z d?d@ddZ ddZ ddZ edAddZeddZddejfdBd%d&ZdCd)d*ZedDd,d-ZdEdFfd1d2 ZdGdHd6d7ZdId;d<ZZS)JExtensionBlocka Block for holding extension types. Notes ----- This holds all 3rd-party extension array types. It's also the immediate parent class for our internal extension types' blocks, CategoricalBlock. ExtensionArrays are limited to 1-D. FTrCrcrRrcCs*|jdkr t|jfSt|jt|jfS)NrT)rUrrcrrjr\r\r]rVis  zExtensionBlock.shapernr&cCst|tr7|\}}t|s|dkrt|dt|tr2|dkr)|t|j7}|j||dS|j|S|dkrBt|d|jS)Nrz only contains one itemrT)rptuplecom is_null_slice IndexErrorrrrc)rXrncolrr\r\r]r(ps   zExtensionBlock.igetrrrlrcCs"|r|j|_||jdd<dSrfr*r+r\r\r]r-s zExtensionBlock.set_inplacecCsxt|tjtfr$|j|jjdkr$|jddksJ|dddf}|St|tr:|jddks2J|jdddj }|S)z@ If necessary, squeeze a (N, 1) ndarray to (N,) rTNrrh) rprqr>rCrUrcrVr/_ixsror"r\r\r]r#s z!ExtensionBlock._maybe_squeeze_argcCst|trpt|dkrptdd|Dr8|\}}|jdkr*|dkr*|jddks.td|dddf}|St|drK|ddkrK|d}|St |drX|d}|St |drl|dddkrl|d}|Std|S)zw Adapt a 2D-indexer to our 1D values. This is intended for 'setitem', not 'iget' or '_slice'. rcss&|]}t|tjo|jdkVqdS)rN)rprqr>rUrr\r\r]rs$z9ExtensionBlock._unwrap_setitem_indexer..rTrzPThis should not be reached. Please report a bug at github.com/pandas-dev/pandas/N) rprrrsizerVrr is_integerrrr()rXrfirstsecondr\r\r]r%s.  $  z&ExtensionBlock._unwrap_setitem_indexercCsdS)z,Extension arrays are never treated as views.Fr\rjr\r\r]ruszExtensionBlock.is_viewcCs |jjjSrf)rcrh _is_numericrjr\r\r]rr~zExtensionBlock.is_numericrNrr.r/rdrrracCsP|tjurd}|jj||dd}|jdkr|durJ|dur"|j}|||S)r0NT)rr1rT)r r2rctakerUrr)rXrr/rrrr\r\r]r4s  zExtensionBlock.take_ndrr)cCsN|jdkr"t|tstd|td|}t|std|td}|j|S)z Return a slice of my values. Parameters ---------- slicer : slice, ndarray[int], or ndarray[bool] Valid (non-reducing) indexer for self.values. Returns ------- ExtensionArray rz+invalid slicing for a 1-ndim ExtensionArrayrTN)rUrprAssertionErrorrangerrc)rXrnew_locsr\r\r]rs    zExtensionBlock._slicercCs |j|}t|||j|jdS)zN Perform __getitem__-like specialized to slicing along index. r)rcrrrU)rXrrr\r\r]getitem_block_index!s z"ExtensionBlock.getitem_block_indexrTrHrScs@|dkr|dkrtjt|jddS|dkrd}t||S)NrrhrT)rrirrc)rXrHr/rr\r]ri+s zExtensionBlock.diffrjrrcCs|jj||d}||gS)z Shift the block by `periods`. Dispatches to underlying ExtensionArray and re-boxes in an ExtensionBlock. )rjrrcr@r)rXrjr/rrr\r\r]r@8s zExtensionBlock.shiftr5r6rcsD|j\}}|j|}||}fddtt||D}||fS)Ncs<g|]\}\}}tjj||dt|ddqS))r1rrr)rrcrr)rrnindicesplacerr6rXr\r]r^s  z+ExtensionBlock._unstack..) arange_resultr:rr)rXr<rr5r6rrrr\rr]r=Bs    zExtensionBlock._unstackr)rnr&r~rr|r)rr)rRrC)rrrRrrrrrr)rrrrrgrrrrrVr(r-r#r%rrurr r2r4rr rrir@r=rr\r\rr]rWs4     ,   (   rc@sReZdZUded<edddZeddd Zddd dZdddZdddZ d S) NumpyBlockrrcrRrlcCs |jjduSrtN)rcbaserjr\r\r]ruos zNumpyBlock.is_viewrCcCr{rf)rErcrjr\r\r]rvtr~zNumpyBlock.array_valuesNrhrxcCs|tkr |jtS|jSrf)rrcrrtr\r\r]ryxs zNumpyBlock.get_valuescCrrfr rjr\r\r]rz}szNumpyBlock.values_for_jsonracCs0t|j|d}|j|}t||||jdS)Nrr)rqrsrcrrrUrr\r\r]rss zNumpyBlock.deleter|rrfrrr}) rrrrrrurvryrzrsr\r\r\r]rls     rc@seZdZdZdZdS) NumericBlockr\TN)rrrrrr\r\r\r]rsrc@sNeZdZUdZded<edddZeddd ZddddZ ddddZ dS)rz8 Block backed by an NDArrayBackedExtensionArray rOrcrRrlcCst|jtj Srf)rprhrqrjr\r\r]rsz(NDArrayBackedExtensionBlock.is_extensioncCs|jjjduSr)rc_ndarrayrrjr\r\r]rurz#NDArrayBackedExtensionBlock.is_viewrrHrdr/rScCs$|j}||j||d}||gS)a 1st discrete difference. Parameters ---------- n : int Number of periods to diff. axis : int, default 0 Axis to diff upon. Returns ------- A list with a new Block. Notes ----- The arguments here are mimicking shift so they are called correctly by apply. rh)rcr@r)rXrHr/rcrr\r\r]ris z NDArrayBackedExtensionBlock.diffNrjrrcCs"|j}|j|||d}||gS)N)rr/r)rXrjr/rrcrr\r\r]r@s z!NDArrayBackedExtensionBlock.shiftr|r rrr) rrrrrrrrrurir@r\r\r\r]rs    rr ExceptionrcCs>t|trt|tr dSdt|vrdSdt|vrdSdS)z We catch ValueError for now, but only a specific one raised by DatetimeArray which will no longer be raised in version.2.0. z'value.closed' iszTimezones don't matchN)rprrr)rr\r\r]rs    rc@s,eZdZUdZdZdZded<d dd Zd S) DatetimeLikeBlockz*Block for datetime64[ns], timedelta64[ns].r\FzDatetimeArray | TimedeltaArrayrcrRrcCrrf)rcrrjr\r\r]rzr{z!DatetimeLikeBlock.values_for_jsonNr)rrrrrrrrzr\r\r\r]rs rc@s0eZdZUdZded<dZdZdZdZe j Z dS)DatetimeTZBlockz0implement a datetime64 block with a tz attributerBrcr\TFN) rrrrrrrrrgrrzr\r\r\r]rs  rc@s<eZdZdZdZedddd Ze    ddddZdS) ObjectBlockr\TFrrlrRrScCsp|jdksJz||j}Wnty|sgYSwt|tjs%J|jdks,J|dd}||gS)z; For object-dtype, we operate column-wise. rrTr)rUrcrrprqr>rr)rXrrresr\r\r]rs   zObjectBlock.reducerrrrcCsB|j}|jdkr |d}t|||||d}t||j}||gS)z attempt to cast any object types to better types return a copy of the block (if copy = True) by definition we ARE an ObjectBlock!!!!! rr)rrrr)rcrUr"rr)rXrrrrrcrr\r\r]rs   zObjectBlock.convertNr~rrr)rrrrrr`rrr\r\r\r]rsrc@seZdZdZedddZdS)CategoricalBlockr\rRrcCrrfrrjr\r\r]rh"rzCategoricalBlock.dtypeNr)rrrrrrhr\r\r\r]rsrrcrcCsVt|tjrt|}t|jjtrtj|t d}t|t t fr)|j dur)| d}|S)a: Input validation for values passed to __init__. Ensure that any datetime64/timedelta64 dtypes are in nanoseconds. Ensure that we do not have string dtypes. Parameters ---------- values : np.ndarray or ExtensionArray Returns ------- values : np.ndarray or ExtensionArray rN)rprqr>rJ issubclassrhrrrrPrBrGfreq _with_freqr r\r\r]r+s  rrhrcCs|j}|j}t|trt}|St|trt}|S|tur t}|St|t r)t }|St|t r2t}|S|dvr:t }|S|dvrBt }|St}|S)z Find the appropriate Block subclass to use for the given values and dtype. Parameters ---------- dtype : numpy or pandas dtype Returns ------- cls : class, subclass of Block )rr)rccrnrorm)rrrrprHrr+rr rr.rr,rrr)rhvtyperrclsr\r\r]get_block_typeHs2    rrrcCs t|j}t|}||d|dS)NrrUr)rrhr)rcrklassr\r\r]r;qs r;rUrdcCs>t|ts t|}t|||t|j}t|}||||dS)Nr)rpr check_ndimrrhr)rcrrUrr\r\r]r|s   rcCs|j|krtd|jd|dt|js?|j|kr'td|jd|dt|t|kr=tdt|dt|d S|dkrMt|d krOtd d Sd S) aV ndim inference and validation. Validates that values.ndim and ndim are consistent. Validates that len(values) and len(placement) are consistent. Parameters ---------- values : array-like placement : BlockPlacement ndim : int Raises ------ ValueError : the number of dimensions do not match z0Wrong number of dimensions. values.ndim > ndim [z > ]z1Wrong number of dimensions. values.ndim != ndim [z != zWrong number of items passed z, placement implies rrTz need to splitN)rUrr$rhr)rcrrUr\r\r]rs6    rrbrx3tuple[np.ndarray | ExtensionArray, DtypeObj | None]cCs@t|tr|}|r|dkrt|}t|tr|j}||fS)zL Ensure that we don't allow PandasArray / PandasDtype in internals. rT)rpr1to_numpyrq atleast_2dr- numpy_dtype)rcrhrUr\r\r]extract_pandas_arrays    rrScCsh|durg}t|tr"|D]}t|tr||q ||q |St|ts-Jt||||S)z.return a new extended blocks, given the resultN)rplistrrrar)rrrr\r\r]rs     rrTcCs.|j|krt|jstd|}|dd}|S)z: Reshape if possible to have values.ndim == ndim. z+np.ndarray | DatetimeArray | TimedeltaArrayrTr)rUr$rhr r)rcrUr\r\r]rs    rr.)rr float_formatdecimalrcKst|tr|jjjdvrtj|jjt|j |d}t |}t|t t frf|j dkr<|jdd|i|}|jtdd}|Sg}tt|D]}||ddfjdd|i|}||jtddqDt|S|jjdkrt|s|dur|d krt|} |s|t}ntj|d d }||| <|jtdd}|Sd d lm} | |||||dd} | } | jtdd} | St|trt|} t|t} || | <| St|} t |}|jt!kr|s|r|t}|jj"tdj"|kr|d|}ntj|d d }||| <|jtdd}|S)rMmr7rTrFrNrcrrPrr)FloatArrayFormatter)rrrr fixed_widthU1zr?"pandas.core.array_algos.transformsr@pandas.core.arraysrArBrCrDrErFrGpandas.core.arrays.sparserHpandas.core.baserIpandas.core.commoncommonr#pandas.core.computation.expressions computationrOpandas.core.constructionrJrKpandas.core.indexersrLpandas.core.missingrpandasrMrNpandas.core.arrays._mixinsrOrhrr`rarrrrNDArrayBackedBlockrrrrrrrrr;rrrrrrr}r\r\r\r]s $          (    $     Y{ 2 4   )  *  X