U MZfV@sddlmZddlmZddlZddlmZmZmZm Z m Z m Z m Z ddl ZddlmZddlmZmZmZddlmZmZddlmZdd lmZdd lmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&dd l'm(Z(dd l)m*Z*dd l+m,Z,ddl-m.Z.m/Z/ddl0m1Z1m2Z2m3Z3m4Z4m5Z5ddl6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>ddl?m@Z@mAZAmBZBmCZCddlDmEZEmFZFmGZGmHZHddlImJZJmKZKmLZLddlMmNZNddlOmPmQZRddlSmTZTmUZUmVZVmWZWmXZXddlYmZZZddl[m\Z\m]Z]m^Z^ddl_m`Z`ddlambZbmcZcmdZdmeZemfZfmgZgmhZhddlimjZjddlkmlZlddlmmPmnZoddlpmqZqddlrmsZsmtZtddlumvZvervddlwmxZxdd lymzZze{d!Z|d"d"d#d$d%Z}Gd&d'd'elZ~Gd(d)d)e~ZGd*d+d+ej~eZGd,d-d-eje~ZGd.d/d/eZGd0d1d1ejeZd2d3d4d5d6ZGd7d8d8eZGd9d:d:eZGd;d<dd?d@ZdAdBdCdDZdjd=dEdFdGdHdIZddJdKdFd'dLdMdNZdEdKd3dOdPdQZdRdSdKdTdUdVdWZdkdXdYdZd[Zdld=dKd=d]d^d_Zd`dddadbd=dcdcdddedfdgZd=d=d>dhdiZdS)m) annotations)wrapsN) TYPE_CHECKINGAnyCallableIterableSequencecastfinal)using_copy_on_write) internalslibwriters)BlockPlacementBlockValuesRefs)NA)IncompatibleFrequency) ArrayLikeAxisIntDtypeObjF FillnaOptions IgnoreRaiseQuantileInterpolationShapenptAbstractMethodError)cache_readonly)validate_bool_kwarg)astype_array_safeastype_is_view)LossySetitemErrorcan_hold_elementfind_result_typemaybe_downcast_to_dtypenp_can_hold_element)ensure_platform_intis_1d_only_ea_dtypeis_1d_only_ea_objis_dtype_equalis_interval_dtype is_list_like is_sparseis_string_dtype)DatetimeTZDtypeExtensionDtype PandasDtype PeriodDtype) ABCDataFrameABCIndexABCPandasArray ABCSeries)is_valid_na_for_dtypeisnana_value_for_dtype)missing)extract_bool_arrayputmask_inplaceputmask_without_repeatsetitem_datetimelike_compatvalidate_putmask)quantile_compat)compare_or_regex_search replace_regexshould_use_regex)shift) Categorical DatetimeArrayExtensionArray IntervalArray PandasArray PeriodArrayTimedeltaArray) SparseDtype) PandasObject) expressions)ensure_wrapped_if_datetimelike extract_array)check_setitem_lengths)Index)NDArrayBackedExtensionArrayobjectr)methreturncs$tddfdd }tt|S)zp If we have a multi-column block, split and operate block-wise. Otherwise use the original method. list[Block]rVcs>|jdks|jddkr(|f||S|jf||SdS)Nr)ndimshapesplit_and_operate)selfargskwargsrU@/tmp/pip-unpacked-wheel-nbcvw55c/pandas/core/internals/blocks.pynewfuncszmaybe_split..newfunc)rr r)rUrcrar`rb maybe_splitsrdc @seZdZUdZded<ded<ded<ded <d Zd Zd Zd Zd Z d Z e e d dZ e e ddddZe eddddZe ddZe e ddZe ddZeddddZejdddd dZe dd"dd#d$d%Ze dd&d"dd'd(d)Ze d*dd+d,Ze ddd-d.Ze d/dd0d1d2Ze d3ddd4d5d6Ze d7dd8d9d:Ze d;dd<d=d>Ze d?dd@dAZe d?ddBdCZe d;d?dDdEdFZ e d?ddGdHZ!e d?ddIdJZ"e dddKdLZ#e dd?dd?dMdNdOZ$e e%ddd?dPdQdRZ&d d dSddd?dTdUdVZ'e dWddXdYZ(e ddWdd[ddd\d]d^Z)e dd*dd`dadbZ*e ddddcdddeZ+e dddfdd?dgdhdiZ,e dddd?djdkdlZ-e ddmdndddd?dodpdqZ.e ddrdddd?dsdtduZ/dvdvdwdxdyZ0dzd{Z1ed|dd}d~Z2ddvdddZ3dd;d0ddZ4dd;dddddZ5d!e6j7fddd&ddddZ8ddrdddZ9ddddPddZ:ddd?dPddZ;dddd?dddZdddd?dddZ?dddd7d?dddZ@e ddddddddZAdddddddZBd?dddZCeddddZDeddddZEdddvdddÄZFdvdddń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 | ExtensionArrayvaluesintrZrrefsr__init__raFTcCs|j|jjfSN)_can_consolidatedtypenamer]rararb_consolidate_keyszBlock._consolidate_keyboolrXcCs"|j}t|tjr|jdkS|jS)z7 Can we store NA values in this Block? )biu)rm isinstancenpkind _can_hold_nar]rmrararbrxs  zBlock._can_hold_nacCs|jjttkS)z^ We can be bool if a) we are bool dtype or b) object dtype with bool objects. )rgrmrvrqrorararbis_boolsz Block.is_boolcCs t|jSrk)external_valuesrgrorararbr{szBlock.external_valuescCst|jddS)NF)compat)r9rmrorararb fill_valueszBlock.fill_valuecCs |jtkrt||jr|j}|Srk)rm _dtype_objr7r}r]valuerararb_standardize_fill_valueszBlock._standardize_fill_valuercCs|jSrk _mgr_locsrorararbmgr_locsszBlock.mgr_locsNone) new_mgr_locsrVcCs ||_dSrkr)r]rrararbrsNBlockValuesRefs | None)rirVcCs4|dkr|j}|jr"t||jd}t|||j|dS)zm Create a new block, with type inference propagate any values that are not specified NrZ placementrZri)r is_extensionensure_block_shaperZ new_blockr]rgrrirararb make_blocks zBlock.make_blockzBlockPlacement | None)rrirVcCs$|dkr|j}t||||j|dS)z2Wrap given values in a block of same type as self.Nr)rtyperZrrararbmake_block_same_classs zBlock.make_block_same_classstrcCsjt|j}|jdkr0|dt|d|j}n6ddd|jD}|d|jjd|d|j}|S) NrYz: z dtype: z x cSsg|] }t|qSra)r.0srararb sz"Block.__repr__..z, z , dtype: ) r__name__rZlenrmjoinr[rindexer)r]rnresultr[rararb__repr__s    zBlock.__repr__cCs t|jSrk)rrgrorararb__len__sz Block.__len__zslice | npt.NDArray[np.intp]slicerrVcCs>|j|}||}t|tr$|jnd}t||||j|dS) Perform __getitem__-like, return result as block. Only supports slices that preserve dimensionality. Nri)r_sliceruslicerirrZ)r]rr new_valuesrirararb getitem_blocks  zBlock.getitem_blockr)rrrVcCs8||}|j|jjkr tdt||||j|jdS)rz Only same dim slicing is allowedr)rrZrg ValueErrorrri)r]rrrrararbgetitem_block_columnss zBlock.getitem_block_columnsr)elementrVcCst|dd}t|j|S)z#require the same dtype as ourselvesTZ extract_numpy)rPr#rg)r]rrararb_can_hold_element's zBlock._can_hold_elementr)rrVcCs*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)rm TypeErrorrrararb should_store-szBlock.should_storerWcKs||jf|}||S)z[ apply the function to my values; return a block if we are not one )rg_split_op_result)r]funcr_rrararbapplyCsz Block.applycCsP|jdkst||j}|jjdkr4t|gg}n |dd}||}|gS)NrY)rZAssertionErrorrgrvarrayreshaper)r]rr res_valuesnbrararbreduceMs    z Block.reduce)rrVcCs||jdkrlt|jtrlg}t|jD]B\}}t|sF|||d}n||}|j||d}||q$|S||}|gS)NrY)rgr) rZrurmr0 enumeraterr)rappend)r]rnbsrslocvalsblockrrararbr^s  zBlock._split_op_resultcCsf|jdkstg}t|jD]D\}}|jt||d}t|}t|||d|jd}| |q|S)zD Split a block into a list of single-column blocks. rrYr) rZrrrrgrrrrir)r] new_blocksrsZref_locrbprrararb_splitss z Block._splitcOsL|jdkr|jddkstg}|D]}||f||}||q(|S)z Split the block and apply func column-by-column. Parameters ---------- func : Block method *args **kwargs Returns ------- List[Block] rrrY)rZr[rrextend)r]rr^r_ res_blocksrrbsrararbr\s   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)r$rgastype)r]otherZ new_dtyperararbcoerce_to_target_dtypes zBlock.coerce_to_target_dtype)blocks using_cowrVcsPdkr |S|jtkr,tfdd|DSdkr8|Stfdd|DS)NFcsg|]}|j dqS))rrconvertrblkrrarbrsz)Block._maybe_downcast..csg|]}|qSra) _downcast_2drrrdowncastrrarbrs)rmr~ extend_blocks)r]rrrrarrb_maybe_downcasts zBlock._maybe_downcastrrVcCs6t|j|d}|r"||jkr"|jnd}|j||dgS)zs downcast specialized to 2D case post-validation. Refactored to allow use of maybe_split. rmNr)r%rgrir)r]rmrrrirararbrszBlock._downcast_2drrrrrVcCs*|s|r|jddgS|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! Fdeepr)r]rrrararbrs z Block.convertrcCs|jjSrk)rgrmrorararbrmsz Block.dtyperaiser)rmrerrorsrrVc Cs|j}t||||d}t|}d}|r:t|j|jr:|j}|j||d}|j|jkrtd|d|jj d|jd|jj d|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 using_cow: bool, default False Signaling if copy on write copy logic is used. Returns ------- Block )rrNrzcannot set astype for copy = [z ] for dtype (z [z]) to different shape (z])) rgr maybe_coerce_valuesr!rmrirr[rrn) r]rmrrrrgrriZnewbrararbrs .z Block.astypenan)na_reprVcKs"t|jf||d|}||S)"convert to our native types format)rquoting)to_native_typesrgr)r]rrr_rrararbrszBlock.to_native_types)rrVcCs6|j}|r|}d}n|j}t|||j|j|dS)zcopy constructorNr)rgrrirrrZ)r]rrgrirararbrs z Block.copyznpt.NDArray[np.bool_] | None)inplacemaskrrVc Cs|j}t|trp|r,|js"|s,|}n"|r>|jdd}n|rF|n|}tt|j}|j||dd|gS||s|r|jddgS|r|gS|gS|dkrt ||}| s|r|jddgS|r|gS|gSn,||rh|r|r|j|jd}n|}n|r&|n|}t |j|||j rN|dks^|jd|d}n|g}|S|jdks|jddkr|dks|tkr|tt}n ||}|j||d|d Sg}t|D]6\} } |t|j| ||d|| | d|d q|SdS) z replace the to_replace value with value, possible to create new blocks here this is just a call to putmask. FrT to_replacerrNrrYr)rrrrrrrrr)rgrurEri has_referencerr _replacerr: mask_missinganyr< is_objectrrZr[rrrvrmrTrreplacerrrr) r]rrrrrrgrrrsrrararbr%sl          z Block.replace)rrrVc Cs||s0|r|jddgS|r&|gS|gSt|}|rj|rZ|jsZ|j}|j}qd}|j}nd}|rx|jn|j}t|||||j||d} | j d|dS)aA 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. mask : array-like of bool, optional True indicate corresponding element is ignored. using_cow: bool, default False Specifying if copy on write is enabled. Returns ------- List[Block] FrNrr) rrrecompilerirrgrBrr) r]rrrrrrxrirrrararb_replace_regexs    zBlock._replace_regexz Iterable[Any]z Sequence[Any])src_list dest_listrregexrrVc sjttr^r,|r,jjd}n|r4n}tt|jj||dd|gSfddt||D}t |srjddgS|rgSgSt |d}t j rt fdd |D} nfd d |D} |rt | } r|rg} n|rng} tt|| D]\} \\} } }| |k}g}t| D]\}}t | dkrp|}n$|}t|trt|||d}|j| | ||d }|r|jrtd d |Dstfd d|D}||qT|} q0| S)z: See BlockManager.replace_list docstring. rTrcs"g|]\}}|r||fqSra)r)rxyrorarbrs z&Block.replace_list..FrYc 3s,|]$}tttt|ddVqdS)r)rrN)r;r rrAr)na_maskrrgrarb s z%Block.replace_list..c3s|]}t|dVqdS)rN)r:rrrgrarbrs)rrrrrrcss|]}|dkVqdSrkrarrrararbrscs g|]}|jdo dqS)Trrrrrarbrs)rgrurErrirr rziprr.rmr8listrrqr_replace_coercerallrr)r]rrrrrrpairsZsrc_lenmasksrbrssrcdestrrZnew_rbZblk_nummZmibrra)rrr]rrgrb replace_listsj          " zBlock.replace_listnpt.NDArray[np.bool_])rrrrrVc Cst||r|j||||dS|dkr|r|j}|jttd|d}||ksX|rf|sf| }n|r|r|jr| }t |j |||gS|r|j ddgS|r|gS| 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] )rrNFrrr) rCrrrirrrvrmrTrr<rgr) r]rrrrrrZhas_refrrararbr(s6   zBlock._replace_coerce np.ndarray)argrVcCs|SzA For compatibility with 1D-only ExtensionArrays. rar]r rararb_maybe_squeeze_argjszBlock._maybe_squeeze_argcCs|Sr ra)r]rrararb_unwrap_setitem_indexerpszBlock._unwrap_setitem_indexerrcCs|jjSrk)rgr[rorararbr[xsz Block.shape)int | tuple[int, int] | tuple[slice, int])rsrVcCs |j|Srkr)r]rsrararbiget|sz Block.iget4slice | npt.NDArray[np.bool_] | npt.NDArray[np.intp]cCs |j|S)zreturn a slice of my valuesr)r]rrararbrsz Block._slicergrrVcCs|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. Nrgrr]locsrgrrararb set_inplaces zBlock.set_inplacenpt.NDArray[np.intp]r)raxisrrVcCs|j}|tjkr|j}d}nd}tj|||||d}t|trT|jdkrT|dkrTt |dkrh|dkrht |dkrv|j }t |j |j s| ||S|||SdS)zN Take values according to indexer and return them as a block. FT)r allow_fillr}rYNr)rgr no_defaultr}algostake_ndruExtensionBlockrZrrr*rmrr)r]rrrr}rgrrrararbrs(    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. r}rr)Zget_new_valuesrgTrr new_block_2d) r] unstackerr}rrrrrrrararb_unstacks   zBlock._unstackcCs||}ttj|j}|jdkr(|j}t|||t|dd}zt |j |}Wn*t k rz| |}| ||YSX|j tkr||}t|rt|t||}|r|jr|}||jdkr|jn|}t|tjr|jdkrt|dkr|d}|||<|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 using_cow: bool, default False Signaling if CoW is used. Returns ------- Block Notes ----- `indexer` is a direct slice/positional indexer. `value` must be a compatible shape. rTrrY)r.)rr rvndarrayrgrZr"rQrPr&rmr"rsetitemr~r r,r>rrirrrru)r]rrrrgcastedrvirararbr's0       (z Block.setitemc Cs|}ttj|j}t|j|\}}t|ttt fr6t |t j krF|j }||}t|dd}|rx|rr|jddgS|gSzVt|j|}|r|jr|}||}t|j|||r|jddgWS|gWStk r|jdks|jddkrHt|s||||YS|d}|j||||d} | gYSnt|tj} g} |} t | D]^\} } |}| r|dd| | df}|dd| | df}| j|||d}| !|qh| YSYnXdS) a} 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 using_cow: bool, default False Returns ------- List[Block] TrFrrYrrN)"r rvr&rgr?r"rur4r6r3rr rr}rrPrr&rmrirrr=r"rZr[r,rputmaskZnonzeror'rrr)r]rnewr orig_maskrgnoopr(rris_arrayrrrsnsubmaskrrararbr*.sN         z Block.putmaskinfer str | bool _downcastrrVc Csp|j|jkstt|tttfr$t|jdk}t|}ttj |j }|}|rR|j }t ||\}} | r|rx|j ddgS| gS|tjkr|j}||}zt|j|} Wntttfk r|jdks|jddkr ||} | j|||d} |j| ||dYSt|tj tf} g}|}t|D]`\}}|}| rZ|dd||df}|dd||df}|j||||d }||q0|YSYnX| }t|| |}||k r t!|rt"|t"|krt|||t#d | }t$|||nNt!|rHt|tj sHt"||jd krHt%|&|j}t'|||}|rd|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] rFrrYrrrN)r4rzThis should not be reached; call to np.where above is expected to raise ValueError. Please report a bug at github.com/pandas-dev/pandasr))rZrrur4r6r3r;r rvr&rgr"r?rr rr}rr&rmrrr"r[rwhererrGrrrr>sumr,rNotImplementedErrorr*rrrNr)r]rcondr4rZ transposerg orig_othericondr-r(rrr.rrrsrZothr0rZaltrrararbr5ws        z Block.where int | NonelimitrrrVc st|d}|jsd}nt|j}t|j|\}}|rt|rPrJ|jddgS|gS|j d}|j|gd} | S|dk rd|||jd|k<|r|j |j |d} n|j ||j dd } t fd d | DS) zs fillna on the block with the value. If we fail, then convert to ObjectBlock and try again rTFrrNrYr)r4csg|]}|j|gdqS)r)rrrrarbr sz Block.fillna..) rrxr8rgr?rrZcumsumrZr*r"r5r) r]rr=rrrr-rrrrarrbfillnas.   z Block.fillnapadrZforward) methodrindexrr=limit_direction limit_arear}rrr Index | Nonez str | Nonez Any | None) r@rrArr=rBrCr}rrrVc  Ksvt|d}|js6| r"|jddgS|r,|gS|gSzt|} Wntk r\d} YnX| dkr|jjdkr| r|jddgS|r|gS|gS|jr|j dkr|j ddkr|dkr|j t |j f||||||||| d | Sd} |r | r|jr|j}n |j}|j} n |j}ttj|}tj|f|||||||d | |j|| d }||g| | S) NrFrfrrrY) r@rrArr=rBrCr}r)r@rrAr=rBrCr}r)rrxrr:Zclean_fill_methodrrmrwrrZr[r\r interpolaterirrgr rvr&interpolate_array_2drr)r]r@rrArr=rBrCr}rrr_rridatarrararbrF&sh  &      zBlock.interpolaterYr/rrVcCs tj|j||d}|j|dgS)z'return block for the diff of the valuesrrrdiffrgrr]r/rrrararbrLssz Block.diffperiodsrr}rVcCst|s|jtkrtd||}zt|j|}Wn.tk rd||}|j |||dYSXt t j |j }t ||||}||gSdS)z+shift the block by periods, possibly upcastzfill_value must be a scalar)rr}N)r Z is_scalarrmr~rrr&r"rrDr rvr&rgr)r]rOrr}r(rrgrrararbrDys   z Block.shiftlinearrRr)qs interpolationrrVcCsV|jdkst|dkstt|s&tt|jt|j|}t|dd}t ||j dS)aX compute the quantiles of the Parameters ---------- qs : Index The quantiles to be computed in float64. interpolation : str, default 'linear' Type of interpolation. axis : int, default 0 Axis to compute. Returns ------- Block rrYrr!) rZrr,r@rgrvasarray_valuesrr#r)r]rQrRrrrararbquantiles    zBlock.quantile)decimalsrrVcCsT|jr |jr|j| dSd}|j|}||jkrF|j}|sF|}|j||dS)a Rounds the values. If the block is not of an integer or float dtype, nothing happens. This is consistent with DataFrame.round behavivor. (Note: Series.round would raise) Parameters ---------- decimals: int, Number of decimal places to round to. Caller is responsible for validating this using_cow: bool, Whether Copy on Write is enabled right now rNr) is_numericrzrrgroundrir)r]rVrrirgrararbrXs   z Block.roundc Cst|s|g}|jdkrTttj|j}t||}|j|}t||||jdgSt ||jj dkrnt t ||jj dgg}|jj }g}d}|jr|jnd}|D]d}||dkrnN|j|d|ddf}||d|} t||t| |j|d} || |}q|S)aDeletes the locs from the block. We split the block to avoid copying the underlying data. We create new blocks for every connected segment of the initial block that is not deleted. The new blocks point to the initial array. rYrrZrrNr)r,rZr rvr&rgdeleterrmaxr[ IndexErrorZ concatenateZas_arrayrirrr) r]rrgrZ mgr_locs_arrrZ previous_locriidxrrrararbrZs8     z Block.deletecCs t|dSz(return a boolean if I am possibly a viewNrrorararbis_viewsz Block.is_viewrGcCs t|dS)zP The array that Series.array returns. Always an ExtensionArray. Nrrorararb array_valuesszBlock.array_valuesDtypeObj | NonermrVcCs t|dS)z return an internal format, currently just the ndarray this is often overridden to handle to_dense like operations Nrryrararb get_valuesszBlock.get_valuescCs t|dSrkrrorararbvalues_for_json$szBlock.values_for_json)NN)NN)NF)F)FrF)rN)T)FNF)FNF)FFF)TFF)F)F)F)r1F)NFNF)rY)rN)rPr)F)N)Hr __module__ __qualname____doc____annotations__ __slots__rWrrrl_validate_ndimr rrprxpropertyrzr{r}rrsetterrrrrrrrrrrrrr\rrrdrrrmrrrrrrrr r r[rrrr rrr%r'r*r5r>rFrLrDrUrXrZr_r`rcrdrarararbres0          ,c5hA '.;Jz;&M"!$0recseZdZUdZded<d(ddddZd)d dd d d dZd*dd dddZd dfdd Ze ddddZ d+dddddZ ddddZ dd ddddd!d"d#dd$dd%d&d'Z ZS), EABackedBlockz> Mixin for Block subclasses backed by ExtensionArray. rGrgFrqrc Cs|}|}||}||}|j}|jdkr2|j}t|||z |||<Wnttfk r}z^t|t |j r| |}| ||WY0St |tr| |}| ||WYSW5d}~XYnX|SdS)a 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 using_cow: bool, default False Signaling if CoW is used. Returns ------- Block Notes ----- `indexer` is a direct slice/positional indexer. `value` must be a compatible shape. rN)r r rgrZr"rQrr_catch_deprecated_value_errorr+rmrr'ruNDArrayBackedExtensionBlock) r]rrrZ orig_indexerZ orig_valuergerrrrararbr'/s(         zEABackedBlock.setitemr1r2rWr3c Cs|jj}t|}|}|}||}||}|tjkr<|j}t||\}} | rl|rb|jddgS|gSz| ||j} WnZt t fk r} z4t | |j dks|jddkr:t|jr||} | j|||d} |j| ||dWYSt|tr6||} | j|||d} |j| ||dWYSnt|tjtf}g}|} t| D]^\}}|}|r|dd||df}|dd||df}|j|||d}||q^|WYSW5d} ~ XYnX|| }|gS)NFrrYrrr)rgr"r;r r rr}r?rZ_whererrrnrZr[r+rmrr5rrurorvr&rGrrrr)r]rr8r4rZarrr9Z orig_condr:r-rrprrr.rrsrr/r0rrararbr5is`         zEABackedBlock.whererc Cst|}|tjkr|j}|j}|jdkr.|j}|}|}||}||}|sj|rd|j ddgS|gS|r|j r| }| |jdkr|jn|}z| ||Wn0ttfk r}z t||jdks|jddkr@t|jr||}|||WYSt|tr<||}|||WYSnt|tjtf} g} |} t| D]Z\} } |}| r|dd| | df}|dd| | df}| ||}| |qd| WYSW5d}~XYnX|gS)z+ See Block.putmask.__doc__ rFrrYrN)r;r rr}rgrZr"r rrrirrZ_putmaskrrrnr[r+rmrr*rurorvr&rGrrr)r]rr+rrgZorig_newr,rprr.rrrsrr/r0rrararbr*sV         zEABackedBlock.putmaskrXcsT|jdkr8|j|}|j|}t||||jdgS|jjdkrHgSt|S)NrYrY)rZrgrZrrsuper)r]rrgr __class__rarbrZs    zEABackedBlock.deletecCs|jSrkrrorararbr`szEABackedBlock.array_valuesNrarrbcCs*|j}|tkr|t}t||jS)zS return object dtype as boxed values, such as Timestamps/Timedelta )rgr~rrTrvrSrr[)r]rmrgrararbrcs zEABackedBlock.get_valuescCs t|jSrk)rvrSrgrorararbrd szEABackedBlock.values_for_jsonr?r)r@rrr=r}rrrhr;)r@rrr=rc KsH|j}|jdkr.|dkr.|jj|||dj} n|j|||d} || S)Nrrrr@r=)rgrZr"r>r) r]r@rrr=r}rr_rgrrararbrFs zEABackedBlock.interpolate)F)r1F)F)N)rrerfrgrhr'r5r*rZrr`rcrdrF __classcell__rararrrbrm(s& ;FE  rmcseZdZUdZdZdZdZded<d9dddd d fd d Ze d dddZ ddddZ d:ddddddZ ddZ ddZeddddZe d d!Zd"dd#d$d%Zed&dd#d'd(Zd;d*d+d d,d-d.ZdrxrgZ_hasnarirr) r]rr=rrrrirrrrrarbr>6s zExtensionBlock.fillnarrXcCs*|jdkrt|jfSt|jt|jfS)NrY)rZrrgrrorararbr[Ps  zExtensionBlock.shaper)rscCst|trn|\}}t|s2|dkr2t|dt|trd|dkrR|t|j7}|j||dS|j|S|dkrt|d|jSdS)Nrz only contains one itemrY)rutuplecom is_null_slicer\rrrg)r]rscolrrararbrWs   zExtensionBlock.igetrrrcCs"|r|j|_||jdd<dSrkrrrararbrss zExtensionBlock.set_inplacecCsvt|tjtfrF|j|jjdkrF|jddks4t|dddf}n,t|trr|jddksbt|j dddj }|S)z@ If necessary, squeeze a (N, 1) ndarray to (N,) rYNrrJ) rurvr&rGrZrgr[rr3Z_ixsrTr rararbr zs z!ExtensionBlock._maybe_squeeze_argcCst|trt|dkrtdd|Drn|\}}|jdkrT|dkrT|jddks\td|dddf}njt|dr|ddkr|d}nFt |dr|d}n.t |dr|dddkr|d}ntd|S)zw Adapt a 2D-indexer to our 1D values. This is intended for 'setitem', not 'iget' or '_slice'. rcss$|]}t|tjo|jdkVqdS)rN)rurvr&rZrrararbrsz9ExtensionBlock._unwrap_setitem_indexer..rYrzPThis should not be reached. Please report a bug at github.com/pandas-dev/pandas/N) rurvrrsizer[r7r is_integerrwrxr,)r]rfirstsecondrararbr s.     z&ExtensionBlock._unwrap_setitem_indexercCsdS)z,Extension arrays are never treated as views.Frarorararbr_szExtensionBlock.is_viewcCs |jjjSrk)rgrmZ _is_numericrorararbrWszExtensionBlock.is_numericrrcCsN|jdkrDt|tstd|td|}t|s.)Z arange_resultr"rr)r]r$r}rrrrrrarrbr%s    zExtensionBlock._unstack)NFNF)F)rY)rN)rrerfrgrlrjrrhr>rr[rrr r rkr_rWrr rrLrDr%rurararrrbr$s8  * (  rc@sZeZdZUded<eddddZedddd Zdd dd d dZddddZd S) NumpyBlockrrgrqrXcCs |jjdk Sr^)rgbaserorararbr_4szNumpyBlock.is_viewrGcCs t|jSrk)rIrgrorararbr`9szNumpyBlock.array_valuesNrarbcCs|tkr|jtS|jSrk)r~rgrryrararbrc=s zNumpyBlock.get_valuescCs|jSrkrrorararbrdBszNumpyBlock.values_for_json)N) rrerfrhrkr_r`rcrdrarararbr1s rc@seZdZdZdZdS) NumericBlockraTN)rrerfrirWrarararbrFsrc@sheZdZUdZded<eddddZedddd Zdd d d dddZ dd d dd dddZ dS)roz8 Block backed by an NDArrayBackedExtensionArray rSrgrqrXcCst|jtj Srk)rurmrvrorararbrSsz(NDArrayBackedExtensionBlock.is_extensioncCs|jjjdk Sr^)rg_ndarrayrrorararbr_Xsz#NDArrayBackedExtensionBlock.is_viewrrhrrWrIcCs$|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. rJ)rgrDr)r]r/rrgrrararbrL^sz NDArrayBackedExtensionBlock.diffNrrNcCs"|j}|j|||d}||gS)N)r}rr)r]rOrr}rgrrararbrDxsz!NDArrayBackedExtensionBlock.shift)r)rN) rrerfrgrhrrrkr_rLrDrarararbroKs ro Exceptionr)rprVcCs&t|tr"t|trn dt|kr"dS)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' isN)rurrr)rprararbrns    rnc@sZeZdZUdZdZdZded<dddd Zd d d dd d dd dddddddddZd S)DatetimeLikeBlockz*Block for datetime64[ns], timedelta64[ns].raFzDatetimeArray | TimedeltaArrayrgrrXcCs|jjSrk)rgrrorararbrdsz!DatetimeLikeBlock.values_for_jsonr?Nr)r@rArrr=r}rrrDrhrqr;)r@rArrr=rc Ks|j} |dkrd} |r>|r2|js2| j} |j} qR| j} n|rH| jn| j} tj| ||||dt| j| | j d} |j | | dS| j dkr|dkr| j j |||dj } n| j |||d} | | S)NrP)r@r=rArrrrrrt)rgrirrrr:rGrZ _simple_newrmrrZr"r>) r]r@rArrr=r}rr_rgriZdata_outrrararbrFs,  zDatetimeLikeBlock.interpolate) rrerfrgrirWrhrdrFrarararbrs rc@s0eZdZUdZded<dZdZdZdZe j Z dS)DatetimeTZBlockz0implement a datetime64 block with a tz attributerFrgraTFN) rrerfrgrhrirrjrlrordrarararbrs rc@s2eZdZdZdZeddddddddd Zd S) ObjectBlockraTFrrqrWrcCs|jtkr"|r|jddgS|gS|j}|jdkr:|d}tj|ddddd}d}|rh||krh|}n||krz|rz|j}t||j}|j ||dgS) 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!!!!! FrrrT)Zconvert_datetimeZconvert_timedeltaZconvert_periodZconvert_intervalNr) rmr~rrgrZr Zmaybe_convert_objectsrirr)r]rrrgrrirararbrs*      zObjectBlock.convertN)rrerfrirrdrrarararbrs rr)rgrVcCsVt|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)rurvr&rO issubclassrmrrrrTrFrKfreqZ _with_freqrrararbr s  rrrcCsj|j}t|trt}nPt|tr&t}n@t|tr6t}n0t|trFt}n |dkrTt }n|dkrbt }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 )Mr)rEcrsrtrr) rwrurLrr/rr2ror0rrr)rmrwclsrararbget_block_type s    rrr)rgrricCs"t|j}t|}||d||dS)NrrZrri)rrmr)rgrriklassrararbr#D s r#rrh)rZrirVcCs@t|tst|}t|||t|j}t|}|||||dS)Nr)rur check_ndimrrmr)rgrrZrirrararbrQ s    r)rrZrVcCs|j|kr"td|jd|dt|js||j|krNtd|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 rrYz need to splitN)rZrr(rmr)rgrrZrararbra s   rrfraz3tuple[np.ndarray | ExtensionArray, DtypeObj | None])rgrmrZrVcCs@t|tr(|}|r(|dkr(t|}t|tr8|j}||fS)zL Ensure that we don't allow PandasArray / PandasDtype in internals. rY)rur5Zto_numpyrvZ atleast_2dr1Z numpy_dtype)rgrmrZrararbextract_pandas_array s    rrWrXcCsf|dkr g}t|trB|D]$}t|tr4||q||qn t|tsXtt||||S)z.return a new extended blocks, given the resultN)rurrrrerr)rrrrararbr s    rrY)rgrZrVcCs.|j|kr*t|js*td|}|dd}|S)z: Reshape if possible to have values.ndim == ndim. z+np.ndarray | DatetimeArray | TimedeltaArrayrYr)rZr(rmr r)rgrZrararbr s     rr.)rr float_formatdecimalrr)rgrrrVcKs0t|tr2|jjjdkr2tj|jjt|j |d}t |}t|t t fr|j dkrx|jfd|i|}|jtdd}|Sg}tt|D]8}||ddfjfd|i|}||jtddqt|S|jjdkrtt|st|dkr:|d kr:t|} |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}|SdS)rZMmr rYrFrNrErrTrr)FloatArrayFormatter)rrrrZ fixed_widthZU1zr?Z pandas.core.array_algos.quantiler@Zpandas.core.array_algos.replacerArBrCZ"pandas.core.array_algos.transformsrDZpandas.core.arraysrErFrGrHrIrJrKZpandas.core.arrays.sparserLZpandas.core.baserMZpandas.core.commoncommonrwZpandas.core.computationrNZpandas.core.constructionrOrPZpandas.core.indexersrQZpandas.core.apirRZpandas.core.arrays._mixinsrSrmr~rdrermrrrZNDArrayBackedBlockrornrrrrrr#rrrrrrr{rarararbs  $    ,   (    $       #}5 41'*W