U MfL@sddlmZddlmZddlZddlmZmZmZm Z m Z m Z m Z ddl Z ddlZddlmZmZmZmZmZddlmZddlmZmZmZmZmZddl m!Z!dd l"m#Z#dd l$m%Z%dd l&m'Z'dd l(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0dd l1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9ddl:m;Z;mZ>ddl?m@Z@mAZAmBZBmCZCddlDmEZEddlFmGZGmHZHmIZIddlJmKmLZddlMmNZNmOZOmPZPmQZQmRZRmSZSddlTmUZUddlVmWZWmXZXmYZYddlZm[Z[ddl\m]Z]ddl^m_Z_m`Z`maZambZbmcZcmdZdmeZeddlfmgZgddlhmiZiddljmkZkddllmKmmZnddlomKmpmqZqddlrmsZsmtZtddlumvZvmwZwmxZxddlymKmzZzerddl{m|Z|m}Z}e~dZddd d!d"ZGd#d$d$ekZGd%d&d&eZGd'd(d(ejeZGd)d*d*ejeZGd+d,d,eZGd-d.d.ejeZd/d0d1d2d3ZGd4d5d5eZGd6d7d7eZGd8d9d9eZGd:d;d;eZdd?Zd@dAdBdCZd|jdks|jddkr(|f||S|jf||SdS)Nr)ndimshapesplit_and_operate)selfargskwargsrT@/tmp/pip-unpacked-wheel-eb6vo0j3/pandas/core/internals/blocks.pynewfuncszmaybe_split..newfunc)rr r)rTrbr`r_ra maybe_splitsrcc @s>eZdZUdZded<ded<ded<dZd Zd Zd Zd Z d Z e e d d Z ed dddZe e d dddZe e d dddZe ed dddZe ddZeddddZddddd d!Zddd"d#Ze e d$d%Zed&dd'd(Zejd&d)d*d(Ze dddd+d,Ze dd-dd.d/d0Ze d1dd2d3Ze ddd4d5Zd6dd7d8Ze d9dd:d;d<Ze d=d&dd>d?d@Z edAddBdCZ!e dDddEdFZ"dGdHdIdJZ#dKddLdMZ$dKddNdOZ%e dPddQdRZ&dd dPdSdTdUZ'e d6dPdVdWdXZ(dd dPdYdZd[Z)e dPdd\d]Z*e dPdd^d_Z+e ddPdPd`dadbZ,e e-dPddcddZ.e ddDd d1dfdgdhZ/dd d d d dPdidjdkZ0e dld dmdndoZ1e d6d dpdqdrZ2e ddtduZ3e dd dvdwdxZ4e dd dydPdzd{d|Z5e dd d dPd}d~dZ6e dddd d dPdddZ7e ddd d dPdddZ8dddddZ9ddZ:dPdddZ;e ddddZj?fdd-ddddZ@ddddPdddZAddddldPdddZBdPdddZCdddddZDe dddddddZEdS)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 | ExtensionArrayvaluesintrYr__init__r`FTcCs|j|jjfSN)_can_consolidatedtypenamer\r`r`ra_consolidate_keyszBlock._consolidate_keyboolrWcCs|j}ttj|}|jdk Sz(return a boolean if I am possibly a viewN)rfr npndarraybase)r\rfr`r`rais_views z Block.is_viewcCs"|j}t|tjr|jdkS|jS)z7 Can we store NA values in this Block? )biu)rk isinstancerqkind _can_hold_nar\rkr`r`rarzs  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)warningswarnDeprecationWarningrrxrfrBrmr`r`rais_categoricals zBlock.is_categoricalcCs t|jS)z^ We can be bool if a) we are bool dtype or b) object dtype with bool objects. )r2rfrmr`r`rais_boolsz Block.is_boolcCs t|jSri)external_valuesrfrmr`r`rarszBlock.external_valuesrDcCs t|jS)zP The array that Series.array returns. Always an ExtensionArray. )rFrfrmr`r`ra array_valuesszBlock.array_valuesNDtypeObj | None np.ndarrayrkrUcCs|tkr|jtS|jS)z return an internal format, currently just the ndarray this is often overridden to handle to_dense like operations ) _dtype_objrfastyper{r`r`ra get_valuess zBlock.get_valuescCs|jSrirfrmr`r`ravalues_for_jsonszBlock.values_for_jsoncCst|jddS)NF)compat)r5rkrmr`r`ra fill_valueszBlock.fill_valuercCs|jSri _mgr_locsrmr`r`ramgr_locsszBlock.mgr_locs) new_mgr_locscCs ||_dSrir)r\rr`r`rarscCs2|dkr|j}|jr"t||jd}t|||jdS)zm Create a new block, with type inference propagate any values that are not specified NrY placementrY)r is_extensionensure_block_shaperY new_block)r\rfrr`r`ra make_blocks zBlock.make_blockBlockPlacement | None)rrUcCsT|dkr|j}|jjdkr@t|}||k r-sz"Block.__repr__..z, z , dtype: ) r__name__rYlenrkjoinrZrindexer)r\rlresultrZr`r`ra__repr__%s    zBlock.__repr__cCs t|jSri)rrfrmr`r`ra__len__2sz Block.__len__rcCs |j|S)zreturn a slice of my valuesr)r\slicerr`r`ra_slice6sz Block._slicezslice | npt.NDArray[np.intp]rrUcCsRt|tr|dn|}|j|}||}|j|jjkr@tdt||||jS) Perform __getitem__-like, return result as block. Only supports slices that preserve dimensionality. r Only same dim slicing is allowed)rxtuplerrrYrf ValueErrorr)r\rZ axis0_slicerrrr`r`ra getitem_block;s   zBlock.getitem_blockslice)rrrUcCs2||}|j|jjkr tdt||||jS)rr)rrYrfrr)r\rrrr`r`ragetitem_block_columnsLs zBlock.getitem_block_columnsrcCs|jjSri)rfrZrmr`r`rarZ^sz Block.shapercCs|jjSrirfrkrmr`r`rarkbsz Block.dtype)int | tuple[int, int] | tuple[slice, int]rvcCs |j|Srir)r\rvr`r`raigetfsz Block.igetNonecCs||j|<dS)z Modify block values in-place with new item value. Notes ----- `set` never creates a new array or new Block, whereas `setitem` _may_ create a new array and always creates a new Block. Nrr\Zlocsrfr`r`ra set_inplaceos zBlock.set_inplacecCsHt|j|d|_|j||_z|jWntk rBYnXdS); Delete given loc(-s) from block in-place. rN)rqdeleterfrr_cacheclearAttributeErrorr\locr`r`rarzs z Block.deleterVcKs||jf|}||S)z[ apply the function to my values; return a block if we are not one )rf_split_op_result)r\funcr^rr`r`raapplysz Block.applyignore_failuresrUc Cs||jdkstz||j}Wn&ttfk rB|r.csg|]}|qSr`) _downcast_2drrurr`rar#s)rkr extend_blocks)r\rrr`rrars  zBlock._maybe_downcastcCst|j|d}||gS)zs downcast specialized to 2D case post-validation. Refactored to allow use of maybe_split. rk)rrfr)r\rkrr`r`rar%szBlock._downcast_2draise)rkrerrorsc Csl|j}t||||d}t|}||}|j|jkrhtd|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]))rfrmaybe_coerce_valuesrrZrrkrl)r\rkrrrfrZnewbr`r`rar0s  .z Block.astyperrr timedeltarUcCs|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)r\rrrrr`r`rarPs z Block.convertr)elementrUcCst|dd}t|j|S)z#require the same dtype as ourselvesT)Z extract_numpy)rMrrf)r\rr`r`rar^s zBlock._can_hold_element)rrUcCs*z|j|jkWStk r$YdSXdS)z Should we set self.values[indexer] = value inplace or do we need to cast? Parameters ---------- value : np.ndarray or ExtensionArray Returns ------- bool FN)rkr)r\rr`r`ra should_storedszBlock.should_storenancKs"t|jf||d|}||S)"convert to our native types format)na_repquoting)to_native_typesrfr)r\rrr^rr`r`rarwszBlock.to_native_types)deepcCs(|j}|r|}t|||j|jdS)zcopy constructorr)rfrrrrY)r\rrfr`r`rar~sz Block.copyznpt.NDArray[np.bool_] | None)rrrUc CsZ|j}t|tr8|r|n|}|jj||dd|gS||sV|rL|gS|gS|dkrjt||}|s|r||gS|gS||r|r|n|}t |j|||j r|dks|j ddd}n|g}|S|j dks|j ddkr ||}|j||d|dSg}t|D]4\}} |t|j| ||d|||ddq|SdS) z replace the to_replace value with value, possible to create new blocks here this is just a call to putmask. T) to_replacerrNFrrrXrrrrr)rfrxrBr_replacermissing mask_missinganyr7 is_objectrrYrZrreplacerrrr) r\rrrrrfrrrvrr`r`rar sL       z Block.replace)rrrUc Csb||s|r|gS|gSt|}|r2|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)rrrecompilerfr>rr) r\rrrrrrxrrr`r`ra_replace_regexs   zBlock._replace_regexz Iterable[Any]z Sequence[Any])src_list dest_listrregexrUc spjfddt||D}t|s:|r0gSgSt|d}tjrrtfdd|D}nfdd|D}dd|D}|rng}t|D]\} \} } | |k} g} t|D]\}}t|dkr|| }n(|| }t|t rt |||d}|j | | ||d}| rZ|j rZt dd |DsZtd d|D}| |q| }q|S) z: See BlockManager.replace_list docstring. cs"g|]\}}|r||fqSr`)r)rxyrmr`rar s z&Block.replace_list..rXcs g|]}t|ddqS)r)rr)r=r)rrrfr`rarscsg|]}t|dqS)r)r r rrr`rarscSsg|] }t|qSr`)r6rrr`r`rar$s)rrrrrcss|]}|dkVqdSrir`rr`r`ra =sz%Block.replace_list..cSsg|]}|jdddqS)FTrrrr`r`rar@s)rfziprrr)rkr4rrxror_replace_coercer allrr)r\rrrrpairsZsrc_lenmasksrbrvsrcdestrZnew_rbZblk_numrrZmibrr`)rrr\rfra replace_listsL       "  zBlock.replace_list)rrrrUcCsxt||r|j|||d|dS|dkrb|jttdd}||krN|sN|}t|j|||gS|j ||||dSdS)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?rrrqrkrSrr7rfr )r\rrrrrrr`r`rarFs(  zBlock._replace_coerce)argrUcCs|S)zA For compatibility with 1D-only ExtensionArrays. r`r\r"r`r`ra_maybe_squeeze_argzszBlock._maybe_squeeze_argcCs|jdk}t|tjr2|j|jkr2td|j|dkrF|jrFtj}ttj|j}| |sp| | ||St t |ddr|}n t|}|r|j}t|||t||rn2t||jr|||<nt|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. rzCannot set values with ndim > Nrk)rYrxrqrrr is_numericrr rfrrsetitemr&getattrasarrayTrNrOrPr:r)r\rr transposerfZ arr_valuer`r`rar&s,       z Block.setitemcCs~|}ttj|j}t|j|\}}t|ttt fr6t |t j krF|j }|js^t||jr^|j }||r|t|j|||gStrt|djdkr|||S|r|gS|jdks|jddkrt|s||||St|j||j}||gSt|tj}g}|} t| D]Z\} } |} |rD|dd| | df} |dd| | df} | | | }| |q|SdS)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] rrrXN)!r rqrrrfr;r)rxr/r1r.rr no_defaultrr r3rkrr9rrrywhererYrZr(rputmaskr8rrrr)r\rnewZ orig_maskrfrnvZis_arrayrrrvrnZsubmaskrr`r`rar-s>     z Block.putmaskcCs,t|dd\}}t|j|g}|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 T)Z pandas_dtypeFr)rrrkr)r\otherrk_Z new_dtyper`r`rars zBlock.coerce_to_target_dtypepadrforwardz Index | Nonez int | Nonez str | Nonez Any | None) methodaxisindexrrlimit_direction limit_arearcoercerrUc  Kst|d}|js$|r|gS|gS|jrr|jdkrr|jddkrr|dkrr|jt|j||||||||| | f | Szt |} Wnt k rd} YnX| dkr|j j dkr|gS|r|jn|j} ttj| } t j| f|||||||d| || }||g| S)NrrrrXf)r5r6r7rr8r9r)rrzrr rYrZr[r interpolater Zclean_fill_methodrrkryrfr rqrrZinterpolate_array_2drr)r\r5r6r7rrr8r9rr:rr^rdatarr`r`rar<sT &     zBlock.interpolater6rrUcCs|j}|tjkr|j}d}nd}tj|||||d}|dkrH|dkrHt|dkrV|j}t|j |j sp| ||S| ||SdS)zQ Take values according to indexer and return them as a block.bb FT)r6 allow_fillrrN) rfrr+rr r@rrr%rkrr)r\rr6rrrfr?rr`r`rar@Zs$  z Block.take_ndrXr0r6rUcCs tj|j||d}|j|dgS)z'return block for the diff of the valuesr6r)r diffrfr)r\r0r6rr`r`rarBsz Block.diffperiodsr6rrUcCs6ttj|j}t||\}}t||||}||gS)z+shift the block by periods, possibly upcast)r rqrrrfr rArr\rDr6rrfrr`r`rarAsz Block.shiftcCsL|j|jkstt|tttfr$t|jdk}ttj|j }|}|rJ|j }t ||\}}|rf| S|t jkrv|j}t||jr|jtkr|j}||s||}|||} || dSt|||} | |k r$t|r t|t|kr t|||td| } t| || nNt|rbt|tjsbt||jdkrbt||j}t |||} |j!s|jdkr|r| j } |"| gS|}|jd} |#| d}|j$dd} g}| | fD]r}|%r| j&|'d| d}t(||j}|j|jkr$t)j*dt+t,d |j"|j |j-|d }|.|q|S) a  evaluate the block; return result block(s) from the result Parameters ---------- other : a ndarray/object cond : np.ndarray[bool], SparseArray[bool], or BooleanArray Returns ------- List[Block] rinferzThis should not be reached; call to np.where above is expected to raise ValueError. Please report a bug at github.com/pandas-dev/pandasrrXrrAzDowncasting integer-dtype results in .where is deprecated and will change in a future version. To retain the old behavior, explicitly cast the results to the desired dtype.r|r)/rYrrxr/r1r.r rqrrrfr)r;rrr+rr3rkrrrr,rr:sumr(rrr-rZrr expressionsrzrZswapaxesrr takeZnonzerorr~r FutureWarningrrr)r\r1condr*rfZ orig_othericondrrrZaltrr6rZ result_blocksrZtakenrrr`r`rar,sr               z Block.wherenpt.NDArray[np.intp]npt.NDArray[np.bool_] 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. rrrG)Zget_new_valuesrfr)r r new_block_2d) r\ unstackerrrRrSrrrrr`r`ra_unstacks   zBlock._unstacklinearrQ)qsr6rUcCsV|jdkst|dkstt|s&tt|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 rrXrrG) rYrr(r<rfrqr(_valuesrrUr)r\rY interpolationr6rr`r`raquantile&s    zBlock.quantile)N)N)N)F)NFN)N)Fr)TTTT)rN)T)FN)FTN)FF)TF) r3rNFNr4NNFN)rX)rN)rXr)Fr __module__ __qualname____doc____annotations__ __slots__r%r rrj_validate_ndimr rrnpropertyrtrzrrrrrrrrsetterrrrrrrrrZrkrrrrrrrrr[rrcrrrrrrrr rr!rr$r&r-rr<rr+r@rBrAr,rWr\r`r`r`rards           * !  J)G3AG$F& h,rdc@seZdZUdZded<ddddZdddd Zd dd d Zeddd dZ ddddddZ ddddZ dddZ dS) EABackedBlockz> Mixin for Block subclasses backed by ExtensionArray. rDrfrVrWc Cs|jj}t|}||}||}|tjkr4|j}t||\}}|rP|Sz| ||j}Wnt t fk r }zt |t |jr||}|jtkr|||WYJSt|trt|jtr΂||}|||} || dWYSW5d}~XYnX||} | gS)NrF)rfr)r6r$rr+rr;rZ_whererr_catch_deprecated_value_errorr'rkrrr,rxNDArrayBackedExtensionBlockr-rr) r\r1rLZarrrMrrerrrrrr`r`rar,Ms6           zEABackedBlock.wherec Cst|}|j}||}z|||Wnttfk r}zxt|t|jrz| |}|jt krf| ||WY>St |t rt |jtr| |}| ||WYSW5d}~XYnX|gS)z+ See Block.putmask.__doc__ N)r6rfr$Z_putmaskrrrfr'rkrrr-rxrgr-)r\rr.rfrhrr`r`rar-|s&       zEABackedBlock.putmaskrcCsD|j||_|j||_z|jWntk r>YnXdS)rN)rfrrrrrrrr`r`rars zEABackedBlock.deletecCs|jSrirrmr`r`rarszEABackedBlock.array_valuesNrrrcCs*|j}|tkr|t}t||jS)zS return object dtype as boxed values, such as Timestamps/Timedelta )rfrrrSrqr(rrZ)r\rkrfr`r`rars zEABackedBlock.get_valuescCs t|jSri)rqr(rfrmr`r`rarszEABackedBlock.values_for_jsonr3rFc KsH|j}|jdkr.|dkr.|jj|||dj}n|j|||d}||S)Nrr)rr5r)rfrYr)rr) r\r5r6rrrr^rfrr`r`rar<s zEABackedBlock.interpolate)N)r3rFNN) rr]r^r_r`r,r-rrrrrr<r`r`r`rareFs /(  recseZdZUdZdZdZdZded<edddd Z d d d d Z ddddZ ddZ e ddddZeddZddZddejfddddd d!Zddd"d#Zed$dd%d&d'Zd9dd(d)d*d+Zd:ddd(d-fd.d/ Zd;ddd0d(d1d2d3Zd4d5d6d7d8ZZS)<ExtensionBlocka 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. FTrDrfrrWcCs*|jdkrt|jfSt|jt|jfSNrX)rYrrfrrmr`r`rarZs  zExtensionBlock.shaperrcCst|trh|\}}t|s4|dkr4t|dn*t|tr^|tdkrRt||j|gS|j|S|dkr~t|d|jSdS)Nrz only contains one item)rxrcomZ is_null_slice IndexErrorrrrf)r\rvcolrr`r`rars     zExtensionBlock.igetrcCs.||_z|jWntk r(YnXdSri)rfrrrrr`r`rars zExtensionBlock.set_inplacecCsDt|tjr@|j|jjdkr@|jddks0t|dddf}|S)z@ If necessary, squeeze a (N, 1) ndarray to (N,) rXNr)rxrqrrrYrfrZrr#r`r`rar$ sz!ExtensionBlock._maybe_squeeze_argrocCsdS)z,Extension arrays are never treated as views.Fr`rmr`r`rartszExtensionBlock.is_viewcCs |jjjSri)rfrkZ _is_numericrmr`r`rar%szExtensionBlock.is_numericcCs||s||||St|trj|d}t|tjrj|jdkrj|jddkrZt d|dddf}t|tjt fr|jdkr|jddkst |dddf}n,t|t r|jddkst |j dddj}t|||j||j|<|S)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. rrrXzPThis should not be reached. Please report a bug at github.com/pandas-dev/pandas/NrA)rrr&rxrrqrrrYrZrrDrr.Z_ixsrZrNrf)r\rrr`r`rar& s&    zExtensionBlock.setitemrNrgrrdr>cCsP|tjkrd}|jj||dd}|jdkr6|dkr6t|dkrD|j}|||S)zN Take values according to indexer and return them as a block. NT)rr?rX)rr+rfrJrYrrr)r\rr6rrrr`r`rar@Ws zExtensionBlock.take_ndcCst|ts |jdkr |tdf}t|trzt|dkrz|d}t|tsRtd|td|}t|rp|d}n td||j|S)a Return a slice of my values. Parameters ---------- slicer : slice, ndarray[int], or a tuple of these Valid (non-reducing) indexer for self.values. Returns ------- ExtensionArray rNrz+invalid slicing for a 1-ndim ExtensionArrayrX)rxrrYrrrrangerf)r\rfirstZnew_locsr`r`rarrs"    zExtensionBlock._slicerrcCs |j|}t|||j|jdS)zN Perform __getitem__-like specialized to slicing along index. r)rfrrrY)r\rrr`r`ragetitem_block_indexs z"ExtensionBlock.getitem_block_indexrVrcCs|jj||d}|j|dgS)Nrrr)rfrr)r\rrrrrfr`r`rarszExtensionBlock.fillnarXr@cs@|dkr&|dkr&tjt|jddS|dkr2d}t||S)NrrArX)superrBrrf)r\r0r6 __class__r`rarBs zExtensionBlock.diffrrCcCs|jj||d}||gS)z Shift the block by `periods`. Dispatches to underlying ExtensionArray and re-boxes in an ExtensionBlock. )rDrrfrAr)r\rDr6rrr`r`rarAszExtensionBlock.shiftrOrPrQcsD|j\}}|j|}||}fddtt||D}||fS)Ncs<g|]4\}\}}tjj||dt|ddqS))r?rrr)rrfrJr)rrvindicesZplacerrSr\r`rars z+ExtensionBlock._unstack..)Z arange_resultr)rr)r\rVrrRrSrrrr`rwrarWs    zExtensionBlock._unstack)NFN)rX)rN)rr]r^r_rjrbrr`rrZrrr$rcrtr%r&rr+r@rr rprrBrArW __classcell__r`r`rsraris:     :(   ric@seZdZUded<dS) NumpyBlockrrfN)rr]r^r`r`r`r`rarys ryc@seZdZdZdZdS) NumericBlockr`TN)rr]r^rar%r`r`r`rarzsrzc@seZdZUdZded<eddddZedddd Zd d Z dd d ddddZ dd d dddddZ ddddddZ dS)rgz8 Block backed by an NDArrayBackedExtensionArray rIrfrorWcCst|jtj Sri)rxrkrqrmr`r`rarsz(NDArrayBackedExtensionBlock.is_extensioncCs|jjjdk Srp)rf_ndarrayrsrmr`r`rartsz#NDArrayBackedExtensionBlock.is_viewcCs>||s||||S|j}|jdkr2|j}|||<|Srj)rrr&rfrYr))r\rrrfr`r`rar&s  z#NDArrayBackedExtensionBlock.setitemrrgrVr@cCs$|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. rA)rfrAr)r\r0r6rfrr`r`rarBsz NDArrayBackedExtensionBlock.diffNrrCcCs"|j}|j|||d}||gS)N)rr6rurEr`r`rarA,sz!NDArrayBackedExtensionBlock.shiftFrcCsJ||s,|jjdkr,||||||S|jj||d}|j|dgS)Nrrqr)rrkryrrrfr)r\rrrrrr`r`rar1s z"NDArrayBackedExtensionBlock.fillna)r)rN)NFN) rr]r^r_r`rrrcrtr&rBrArr`r`r`rargs  rg Exceptionr)rhrUcCst|trdt|krdS)z We catch ValueError for now, but only a specific one raised by DatetimeArray which will no longer be raised in version.2.0. zTimezones don't matchN)rxrr)rhr`r`rarfAs  rfc@s0eZdZUdZdZdZded<dddd Zd S) DatetimeLikeBlockz*Block for datetime64[ns], timedelta64[ns].r`FzDatetimeArray | TimedeltaArrayrfrrWcCs|jjSri)rfr{rmr`r`rarTsz!DatetimeLikeBlock.values_for_jsonN)rr]r^r_rar%r`rr`r`r`rar}Ms r}c@s*eZdZUdZded<dZdZdZdZdS)DatetimeTZBlockz0implement a datetime64 block with a tz attributerCrfr`TFN) rr]r^r_r`rarrbrjr`r`r`rar~Zs r~c@sFeZdZdZdZed dddddZeddddddd d d Zd S) ObjectBlockr`TFrorVrcCsr|jdkstz||j}Wntk r:|s2gYSXt|tjsLt|jdksZt|dd}||gS)z; For object-dtype, we operate column-wise. rrXr) rYrrfrrxrqrrrr)r\rrresr`r`raris  zObjectBlock.reducercCsB|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)rfrYr!rr)r\rrrrrfrr`r`rar|s   zObjectBlock.convertN)F)TTTT)rr]r^rar rcrrr`r`r`raresrc@s"eZdZdZeddddZdS)CategoricalBlockr`rrWcCs|jjSrirrmr`r`rarkszCategoricalBlock.dtypeN)rr]r^rarcrkr`r`r`rarsrr)rfrUcCsVt|tjr0t|}t|jjtr0tj|t d}t|t t frR|j dk rR| 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)rxrqrrrL issubclassrkrrrrSrCrHfreqZ _with_freqrr`r`rars  rrrcCs~|j}|j}t|trt}n^t|tr,t}nN|tkr:t}n@t|t rJt }n0t|t rZt}n |dkrht }n|dkrvt }nt}|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)r;crvrwru)rryrxrJrir*rr r~r-rgr+r}rzr)rkvtyperyclsr`r`raget_block_types$    rrrcCs t|j}t|}||d|dS)NrrYr)rrkr)rfrklassr`r`rarUs rUrg)rYrUcCs>t|tst|}t|||t|j}t|}||||dS)Nr)rxr check_ndimrrkr)rfrrYrr`r`rars    rrcCs|j|kr$td|jd|dnvt|js~|j|krPtd|jd|dt|t|krtdt|dt|n|dkrt|d krtd d 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 rrXz need to splitN)rYrr#rkr)rfrrYr`r`rars   rrerz3tuple[np.ndarray | ExtensionArray, DtypeObj | None])rfrkrYrUcCs@t|tr(|}|r(|dkr(t|}t|tr8|j}||fS)zL Ensure that we don't allow PandasArray / PandasDtype in internals. rX)rxr0Zto_numpyrqZ atleast_2dr,Z numpy_dtype)rfrkrYr`r`raextract_pandas_array1s    rrVrWcCsf|dkr g}t|trB|D]$}t|tr4||q||qn t|tsXtt||||S)z.return a new extended blocks, given the resultN)rxlistrrrdrr)rrrNr`r`rarGs    rrX)rfrYrUcCs.|j|kr*t|js*td|}|dd}|S)z: Reshape if possible to have values.ndim == ndim. z+np.ndarray | DatetimeArray | TimedeltaArrayrXr)rYr#rkr r)rfrYr`r`rarWs     rr.)rr float_formatdecimalrcKst|tr"t|jjt|j|d}t|}t|tt fr|j dkrh|j fd|i|}|j t dd}|Sg}tt|D]8}||ddfj fd|i|}||j t ddqxt|St|trt|} t| t } || | <| S|jjdkr|dkrN|dkrNt|} |s&| t}ntj|d d }||| <|j t dd}|Sd d lm} | |||||dd } | } | j t dd} | St|} t|}|jtkr|s|r| t}|jj tdj |kr| d|}ntj|d d }||| <|j t dd}|SdS)rrTrXrFrNr;rrSrr)FloatArrayFormatter)rrrrZ fixed_widthZU1zr?Zpandas.core.array_algos.taker@Z"pandas.core.array_algos.transformsrAZpandas.core.arraysrBrCrDrErFrGrHZpandas.core.arrays._mixinsrIZpandas.core.arrays.sparserJZpandas.core.baserKZpandas.core.commoncommonrkZ#pandas.core.computation.expressionsZ computationrIZpandas.core.constructionrLrMZpandas.core.indexersrNrOrPZpandas.core.missingr ZpandasrQrRrkrrcrdreriryrzZNDArrayBackedBlockrgrfr}r~rrrrrUrrrrrrrr`r`r`ras  $      ( (      $    < M   4) *X