eh>ddlmZddlmZmZddlZddlmZmZm Z m Z ddl Z ddl Z ddlmZmZddlmZmZddlmZmZddlmZdd lmZdd lmZdd lmZdd l m!Z!dd l"m#Z#m$Z$m%Z%ddl&m'Z'm(Z(ddl)m*Z*m+Z+ddl,m-Z-m.Z.ddl/m0cm1Z2ddl3m4Z4m5Z5m6Z6ddl7m8Z8ddl9m:Z:m;Z;ddlm?Z?m@Z@ddlAmBZBmCZCmDZDmEZEddlFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPddlQmRZRmSZSerddlTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[ddl\m]Z]GddeBZ^Gddeje^Z_Gdd e^eCZ` d- d.d!Za d/d"Zb d0 d1d#Zcd2d$Zdd3d%Zed4d&Zfd5d'Zgd6d(Zh d7d)Zid8d*Zj d9d+Zkd:d,Zly);) annotations)HashableSequenceN) TYPE_CHECKINGCallableLiteralcast)using_copy_on_writewarn_copy_on_write) internalslib)BlockPlacementBlockValuesRefs) Timestamp)PerformanceWarning)cache_readonly)find_stack_level)infer_dtype_from_scalar)ensure_platform_intis_1d_only_ea_dtype is_list_like)DatetimeTZDtypeExtensionDtype) ABCDataFrame ABCSeries) array_equalsisna)ArrowExtensionArrayArrowStringArray DatetimeArray)NDArrayBackedExtensionArray)ensure_wrapped_if_datetimelike extract_array)maybe_convert_indices)Index ensure_index) DataManagerSingleDataManagerensure_np_dtypeinterleaved_dtype) COW_WARNING_GENERAL_MSGCOW_WARNING_SETITEM_MSGBlock NumpyBlockensure_block_shape extend_blocksget_block_typemaybe_coerce_values new_block new_block_2d) blockwise_alloperate_blockwise) ArrayLikeAxisIntDtypeObjQuantileInterpolationSelfShapenpt)ExtensionArrayceZdZUdZdZded<ded<ded<ded <ed9d Zd ed <d ed <d:d;dZe dd?dZ d@dZeZdAdZdBdZed@dZedCdZdDdZdEdZdFdZdGdZdHdZedIdZdJdZ d> dKd ZeZd:dLd!ZdMd"ZdNdOd$ZdPd%Z d&Z!d'dd( dQd)Z"ed@d*Z#ed@d+Z$dRd,Z%d?d-Z&d?d.Z'd>dSd/Z(ed9d0Z)d:dTd1Z*d?d2Z+ dUd#d3 dVd4Z,e-j\d#fd#d#d5 dWd6Z/ dX dYd7Z0 dZ d[d8Z1y)\BaseBlockManagera Core internal data structure to implement DataFrame, Series, etc. Manage a bunch of labeled 2D mixed-type ndarrays. Essentially it's a lightweight blocked set of labeled data to be manipulated by the DataFrame public API class Attributes ---------- shape ndim axes values items Methods ------- set_axis(axis, new_labels) copy(deep=True) get_dtypes apply(func, axes, block_filter_fn) get_bool_data get_numeric_data get_slice(slice_like, axis) get(label) iget(loc) take(indexer, axis) reindex_axis(new_labels, axis) reindex_indexer(new_labels, indexer, axis) delete(label) insert(loc, label, value) set(label, value) Parameters ---------- blocks: Sequence of Block axes: Sequence of Index verify_integrity: bool, default True Notes ----- This is *not* a public API class npt.NDArray[np.intp]_blknos_blklocstuple[Block, ...]blocks list[Index]axesctNNotImplementedErrorselfs \/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/pandas/core/internals/managers.pyndimzBaseBlockManager.ndim!!bool_known_consolidated_is_consolidatedctrJrK)rNrFrHverify_integritys rO__init__zBaseBlockManager.__init__s!!rRctrJrKclsrFrHs rO from_blockszBaseBlockManager.from_blocksrQrRcR|j|j|jS)a  Suppose we want to find the array corresponding to our i'th column. blknos[i] identifies the block from self.blocks that contains this column. blklocs[i] identifies the column of interest within self.blocks[self.blknos[i]] )rC_rebuild_blknos_and_blklocsrMs rOblknoszBaseBlockManager.blknoss$ <<   , , .||rRcR|j|j|jS)z$ See blknos.__doc__ )rDr^rMs rOblklocszBaseBlockManager.blklocss$ ==  , , .}}rRNcN|tgg|jddz}|jdk(r\t|tsJ|j d}|j dd}ttdd}|j||}|g}ng}t|j||S)z9return an empty BlockManager with the items axis of len 0Nr placement) r%rHrP isinstanceSingleBlockManagerrFvaluesrslicemake_block_same_classtyper\)rNrHblkarrbpnbrFs rO make_emptyzBaseBlockManager.make_emptys <"I;12.D 99>d$67 77++a.C**Ra.Ca ,B**3"*=BTFFDz%%fd33rRcyNTrArMs rO __nonzero__zBaseBlockManager.__nonzero__srRc6|jdk(r |dk(rdnd}|S)NrrcrP)rNaxiss rO_normalize_axisz BaseBlockManager._normalize_axiss 99> 1qD rRcF|j||||j|<yrJ)_validate_set_axisrH)rNrw new_labelss rOset_axiszBaseBlockManager.set_axiss j1$ $rRc2t|jdk(SNrclenrFrMs rOis_single_blockz BaseBlockManager.is_single_blocks4;;1$$rRc |jdSNrrHrMs rOitemszBaseBlockManager.itemsyy|rRcB|j|}|j|S) Check for column `i` if it has references. (whether it references another array or is itself being referenced) Returns True if the column has no references. )r__has_no_reference_block)rNiblknos rO_has_no_referencez"BaseBlockManager._has_no_references"  A++E22rRcR|j|jj S)z Check for block `i` if it has references. (whether it references another array or is itself being referenced) Returns True if the block has no references. rFrefs has_reference)rNrs rOrz(BaseBlockManager._has_no_reference_blocks% ;;u%**88:::rRct|jt|jk7ryt|jD]>\}}|j|j|_|jj |@y)z Adds the references from one manager to another. We assume that both managers have the same block structure. N)rrF enumerater add_reference)rNmgrrrls rOadd_referenceszBaseBlockManager.add_references sc t{{ s3:: .  , (FAszz!}))CH HH " "3 ' (rRc|j|tfd|j|jjDS)zv Checks if two blocks from two different block managers reference the same underlying values. c30K|] }|uywrJrA).0refrls rO z:BaseBlockManager.references_same_values..sTC3#%<Ts)rFanyrreferenced_blocks)rNrrrls @rOreferences_same_valuesz'BaseBlockManager.references_same_valuess9 kk% T3::e+<+A+A+S+STTTrRctj|jDcgc]}|jc}t}|j |j Scc}wNdtype)nparrayrFrobjecttaker_rNrldtypess rO get_dtypeszBaseBlockManager.get_dtypess= <399 /:s Ect|tjr1|j|jkDrt d|j|rEt r;|j ds*tjtttnAtr6|j ds$|jdk(rt|tr|j|d}t|r'|jdk(rtj |d}nt|s|g}t#|dk(r|j%dS|j&dj(}|jdk(rZ||}|j+d|||j&dj-|dtj.t#|f||S|j%}|j1d || S) zi Set values with indexer. For SingleBlockManager, this backs s[indexer] = value zCannot set values with ndim > r stacklevelrurcrwFdeepsetitem)rvalue)rfrndarrayrP ValueErrorr rwarningswarnr+ FutureWarningrr tuplerarsqueezercopyrFrh_iset_split_blockraranger)rNrrrblk_locrhs rOrzBaseBlockManager.setitemts grzz *w||dii/G=dii[IJ J &(1G1G1J MM'+-  ! "4+A+A!+DyyA~*We"<,,wqz2(W\\Q-> jjq9G%g.&iGw<1$99%900Q..;;!##G_F**7FKKN**GAJ #g,8O+PRWXK99;Dzz)WEzBBrRc(|jd|S)Ndiff)nr)rNrs rOrzBaseBlockManager.diffszz&Az&&rRFcz|trd}nd}n trd}|jd|||tS)NFTastype)rrerrors using_cowr r)rNrrrs rOrzBaseBlockManager.astypesJ <"$ "Dzz )+   rRcv|trd}nd}n trd}|jd|tS)NFTconvertrrr)rNrs rOrzBaseBlockManager.converts; <"$ "Dzz)$:M:OzPPrRc \trd}nd}|j d|td|S)NFTr)convert_dtypesr)rNrrs rOrzBaseBlockManager.convert_dtypess>  DDtzz  #'3F3H LR  rRnan)na_repquotingc0|jd|||||S)z} Convert values to native types (strings / python objects) that are used in formatting (repr / csv). get_values_for_csv)rr float_format date_formatdecimalr)rNrrrrrs rOrz#BaseBlockManager.get_values_for_csvs,zz %#   rRc:td|jDS)z>Whether any of the blocks in this manager are extension blocksc34K|]}|jywrJ is_extensionrrs rOrz7BaseBlockManager.any_extension_types..s?%5%%?s)rrFrMs rOany_extension_typesz$BaseBlockManager.any_extension_typess?4;;???rRcft|jdk(r|jdjSy)z8return a boolean if we are a single block and are a viewrcrF)rrFis_viewrMs rOrzBaseBlockManager.is_views. t{{ q ;;q>)) )rRc|jDcgc]}||js|}}|j|Scc}wrJ)rFrh_combine)rN predicaterlrFs rO_get_data_subsetz!BaseBlockManager._get_data_subsets9!%F# #**0E#FF}}V$$Gs>>cg}|jD]\}|jtk(r|j|(|js5|j }|j d|D^|j|S)zs Select blocks that are bool-dtype and columns from object-dtype blocks that are all-bool. c3:K|]}|js|ywrJ)is_boolrros rOrz1BaseBlockManager.get_bool_data..s!Abjj"!As)rFrrSappend is_object_splitextendr)rN new_blocksrlnbss rO get_bool_datazBaseBlockManager.get_bool_dataso  ;; BCyyD !!#&jjl!!!As!AA  B}}Z((rRc|jDcgc]}|js|}}t|t|jk(r|S|j|Scc}wrJ)rF is_numericrr)rNrlnumeric_blockss rOget_numeric_dataz!BaseBlockManager.get_numeric_datasO)-G##GG ~ #dkk"2 2K}}^,, Hs AAct|dk(rd|jdk(rE||jdd|g}n |jddg|jddz}|j |S|j St j t j|Dcgc]}|jjc}}tj||jd}g}|D]L}|jd}t||jj|_|j!|Nt#|j}|||d<|jj%||d<t'|j)||Scc}w)z$return a new manager with the blocksrruNrcFr)rrPrrHrprsort concatenateras_arrayr get_reverse_indexershaperrrrlistrrkr\) rNrFindexrHrr inv_indexerrros rOrzBaseBlockManager._combine sV v;! yyA~$ JJrNE2D JJrN+diim;Dt,,??$ $''"..v)N!!***=*=)NOP--gtzz!}E "$  "AU#B(R[[5H5H)IJBK   b ! " DII  DH**//'*QDz%%j$77*OsF c,t|jSrJrrMs rOnblockszBaseBlockManager.nblocks)s4;;rRctrdndr%fd}|jDcgc] }|| }}nGtr(|jDcgc]}|j}}nt|j}|j d}||_|j dkDrB|j }|4|j|_|jj|_r|j|Scc}wcc}w)aN Make deep or shallow copy of BlockManager Parameters ---------- deep : bool, string or None, default True If False or None, return a shallow copy (do not copy data) If 'all', copy data and a deep copy of the index Returns ------- BlockManager FTcRdk(r|jdS|jS)NallTr)rview)rrs rO copy_funcz(BaseBlockManager.copy..copy_funcGs%-1U]rwwDw)I IrRrrrc) r rHrrrrPrCrrD_consolidate_inplace)rNrrrnew_axesresr_s ` rOrzBaseBlockManager.copy-s <"$  J15 :" " :H:"$04 :"BGGI:: ?jjdj+ 99q=\\F!$kkm #}}113   $ $ & ';;s DDc|jr|St||j|jd}d|_|j |S)zr Join together blocks having same dtype Returns ------- y : BlockManager FrW)is_consolidatedrkrFrHrUr)rNbms rO consolidatezBaseBlockManager.consolidate_sJ    !K T$Z TYY G# ! rR) use_na_proxyc|trd}nd}|R||j|ur|s|S|j|} t|j| _|| j|<| St |t j sJ|s|j|j|||jk\r td|dk(r|j||||} n9|jD cgc]$} | j|d||n | j&} } t|j} || |<t|j| | } |dk(r>|j j| _|j$j| _| Scc} w) a? Parameters ---------- new_axis : Index indexer : ndarray[intp] or None axis : int fill_value : object, default None allow_dups : bool, default False copy : bool or None, default True If None, regard as False to get shallow copy. only_slice : bool, default False Whether to take views, not copies, along columns. use_na_proxy : bool, default False Whether to use a np.void ndarray for newly introduced columns. pandas-indexer with -1's only. FTr#Requested axis not found in managerr) fill_value only_slicer"rc)rwr%)r rHrrrfrr_validate_can_reindexrP IndexError_slice_take_blocks_ax0rFtake_ndr%rkr\r_rCrarD)rNnew_axisrrwr% allow_dupsrr&r"resultrrlrnew_mgrs rOreindex_indexerz BaseBlockManager.reindex_indexeros: <"$ ?499T?*4 YYDY)Ftyy/FK (FKK M'2::... IIdO 1 1' : 499 BC C 1944%%) 5J ;;  &0&< #..  J  ?!t*((X> 19"kk..0GO#||002G ' s%)F )r"ref_inplace_opc |tju}t||jd|\}}} |jr|j d} |dk(r0| dk(rgSt td| } | j|| gS|r|jdk(r|r| | j}|sI|rGt|D cgc]/\} } | jt| | dzt | |1}} } |St td| } | j|d| |gS|dk(r|j|}|j|}nFtj|j|d| }tj|j|d| }g}| }t!j"|| D]\}}|dk(r$|j%|j'||| 0|j |} | j(sc| j*sW|xs t- }|D]B}| j/| }t t||dz|_|j%|D||j2}t5t7||j5dz}|s t-rtj8||}t;|tr&| j||}|j%|;|rTt=||D]C\} } t| | dz}t | } | j|| }|j%|E| j|d| }|j%||Scc} } w)a Slice/take blocks along axis=0. Overloaded for SingleBlock Parameters ---------- slice_or_indexer : slice or np.ndarray[int64] fill_value : scalar, default lib.no_default only_slice : bool, default False If True, we always return views on existing arrays, never copies. This is used when called from ops.blockwise.operate_blockwise. use_na_proxy : bool, default False Whether to use a np.void ndarray for newly introduced columns. ref_inplace_op: bool, default False Don't track refs if True because we operate inplace Returns ------- new_blocks : list of Block r) allow_fillri) new_mgr_locsrc)r3r0)rwr3r%r )r%r2group)rer%r"r)rwr3)r no_default_preprocess_slice_or_indexerrrrFrrigetitem_block_columnsrPr%rr*r_raalgos libinternalsget_blkno_placementsr_make_na_block_can_consolidate_validate_ndimr rrrmaxrmaybe_indices_to_slicerfzip)rNslice_or_indexerr%r&r"r0r2sl_typeslobjsllenrlrnrmlrFr_rar5rrrmgr_locnewblktakermax_lenroslcs rOr)z'BaseBlockManager._slice_take_blocks_ax0so< s~~5 < djjm !    ++a.C'!A:I#E!UO411%b1IJJ499>*"4!$J!j&/u%5  "Ar 11!"b1f-)7):+92F"M'a8B !!")+'1 $ g [['Fll5)G]] UrjFmm ezG +@@uU0 *OE8{ ''"*#-%1(kk%(++C4F4F !+ C.A.CDD#+.!$t!4*8wRS 9T*U f-.$H$4$45E!#h-qAG!%8%: # : :5' J!%/ 66u86T b)#&)%9.EAr"'1q5/C!/!3B!$!:!:3R!:!PB"MM"- .![[QX[N b)a0 *d ks54McT|rS|Jt||jdf}tj|tj}t ||d}|S|tj }t||jdf}t|\}}t|||}t||S)Nrcrrurvrd) rrremptyvoidr.rr make_na_arrayr4) rNrer%r"rvalsror block_valuess rOr<zBaseBlockManager._make_na_blockPs % %%^TZZ]3E88E1DD)!4BI  JYA/3J?z$UE:> LI>>rRc|j|}t|||}|j|j|}|j |||ddS)ac Take items along any axis. indexer : np.ndarray[np.intp] axis : int, default 1 verify : bool, default True Check that all entries are between 0 and len(self) - 1, inclusive. Pass verify=False if this check has been done by the caller. Returns ------- BlockManager )verifyTN)r+rrwr,r)rr$rHrr/)rNrrwrSrr{s rOrzBaseBlockManager.takees_* JJt '6BYYt_))'2 ## $  rR)returnintT)rWrSrTNonerF list[Block]rHrGrTr;)rTrBrJrTr;rTrS)rwr8rTrU)rwr8r{r%rTrWrTr%rrUrTrS)rrUrTrS)rr@rTrW)rr@rrUrTrSrTznpt.NDArray[np.object_])rTlist[ArrayLike])rTstr)rzlist[str] | NonerTr;)rrSrTr;)rrUrTr;)Fraise)r bool | Nonerr`rTr;)rrbrTr;)rr`rTr;)rrrTr;)rFrYrz Index | NonerTr;)rzbool | None | Literal['all']rTr;)NFTF)r+r%rznpt.NDArray[np.intp] | Nonerwr8r,rSrrbr&rSr"rSrTr;) rBslice | np.ndarrayr&rSr"rSr0rSrTrY)NF)rerr"rSrTr-)rcT)rrBrwr8rSrSrTr;)2r __module__ __qualname____doc__ __slots____annotations__propertyrPrX classmethodr\r_rarprs__bool__rxr|rrrrrrrrrrapply_with_blockrrrrrrrrrrrrrrr!r/r r6r)r<rrArRrOr@r@ls0dI !!""   """""  4"H % %%3; (U( 3 3 (,2%2  2j+CZ' " Q DIRV =@  @@  %)$-8:  0d*   S#SS-S S  SSSS Sp>> J #$J,J J  JJ JZPU?'?HL? ?0  %      rRr@ceZdZdZdZ d$ d%dZd&dZed'dZd(dZ d$d)dZ d*dZ e d+d Z d, d-d Z d. d/d Z d0 d1dZ d2 d3dZd0d4dZd&dZd&dZd5dZd6dZd6dZd7dZd8dZdd d9dZd5dZd:dZd d ej<f d;dZd ej<f dd"Z$ed>d#Z%y )? BlockManagerz0 BaseBlockManager that holds 2D blocks. ruc|rW|D]A}|j|jk7std|jd|jd|jyy)NzNumber of Block dimensions (z) must equal number of axes ())rPAssertionError_verify_integrity)rNrFrHrWrs rOrXzBlockManager.__init__si   99 *(6uzzlC++/99+Q8   " " $ rRcb|j}td|jD}|jD]<}|jdd|ddk7st||jdd|j>t |j |k7r$tdt |j d|y)Nc3FK|]}t|jywrJ)rr)rxs rOrz1BlockManager._verify_integrity..s=AAJJ=!rczINumber of manager items must equal union of block items # manager items: z, # tot_items: )rsumrFraise_construction_errorrHrrrq)rN mgr_shape tot_itemsrs rOrrzBlockManager._verify_integritysJJ === [[ PE{{12)AB-/(EKKOTYYO P tzz?i ' 114TZZ0AB'[*  (rRc|||dS)Z Constructor for BlockManager and SingleBlockManager with same signature. FrrArZs rOr\zBlockManager.from_blockss 64%88rRct|jdk(r|jdjtd|f}t tdt|}t ||d|jdj }t||jdSt|jDcgc]}|jc}}t|}t|trtj|t}n"tj||}t!|}|jD]5}t#|j$D]\}} |j||f|| <7t|tr#|j'} | j)||}t tdt|}t ||d}t||jdScc}w)z Return the array corresponding to `frame.iloc[loc]`. Parameters ---------- loc : int Returns ------- np.ndarray or ExtensionArray rcrNrerPrrrerP)rrFigetrirr3rrgrHr*rrfrrrMrr"rrconstruct_array_type_from_sequence) rNlocr-rnrrlrrrrlr[s rOfast_xszBlockManager.fast_xss t{{ q [[^((%+s);jD }d |<t?jF|jBt>jH }|jKd t?jL|jBtz ||<||jN|_'tQfdtS|jD|_| r4t?jT| }t|}g}|rc|jWfd|Dt?jL|t|jz|jN|<d|j|<n| dj9| dd}|j9tY||t[|t|j|jN|<t?jL||j|<|xjtQ|z c_d|_.yy)z Set new item in-place. Does not consolidate. Adds new Block if not contained in the current set of items Nrcrurvz9Shape of new values must be compatible with manager shape)inplacerrlrcSrJrArers rO value_getitemz(BlockManager.iset..value_getitemcs rRc"|jSrJ)rrs rOrz(BlockManager.iset..value_getitemhsY..//rRTr4rrr c3DK|]\}}|tvs|ywrJ)set)rrrlremoved_blknoss rOrz$BlockManager.iset..s& 3ASEX.s>"  !$"0w! 1L"M!"s.1rrF)/rDrPr^rrTr/rrqr is_integerr rUr_rFrr _iset_singlerarr:r;r should_storer rr set_inplacerrr rzerosrbool_rMintpfillrrCrrr rr4rrT)rNrrrrvalue_is_extension_typerrlrr_raunfit_mgr_locsunfit_val_locsblkno_lval_locsblk_locs is_deleted new_blknos unfit_idxr unfit_countrunfit_val_itemsrs ` ` @rOisetzBlockManager.iset*s == TYY]  , , .#6ekk"B&zzQ*5q9{{12$**QR.0$O >>#  sC.CKK$E++e$C3==!Q&((# )%C #   0S!,,s#((*!-!B!B6QU!V I GX++g&Cx//0H3++E2&(1M1Mg1V**=+B+OOHmH.EF%%cll&;&;H&EF%%h/x=C $55"))'2**7H4*H- I0 ~ $,,bhh?J)-J~ &$,,bgg>J OOB &(ii s>?R0R&SJ { #%dll3DL "+DKK"8 DK 7Jj/K&(J&!!" $. ",.99[+AC DT+T Z(,- j)#1"3":":>!";M"N!! ,_="0"<!,/t{{+; Z(,.IIk,B j) KK5, ,K(-D $O rRc|j|}|j|jt|j |}|1|j j |}t|t||}n|d}t|dd}t|j} |jd||fz|j|dzdz|z} | |_|s|ytjt||j|j j<t|D]j\} } tjt| |j| j j<| | z|j| j j<ly)a?Removes columns from a block by splitting the block. Avoids copying the whole block through slicing and updates the manager after determinint the new block structure. Optionally adds a new block, otherwise has to be done by the caller. Parameters ---------- blkno_l: The block number to operate on, relevant for updating the manager blk_locs: The locations of our block that should be deleted. value: The value to set as a replacement. refs: The reference tracking object of the value to set. Nrrrc)rFrDr^rdeleterr r4rrrrrrrC) rNrrrrrlnbs_tuplocsfirst_nb nr_blocks blocks_tuprros rOrzBlockManager._iset_split_blocksV(kk'" ==  , , . 8,-  <<((2D#E>$+?dKHqzHGABK(G $ KK !XK /$++gkm2L Lw V ! 5, 3599S]3K h''//0w' >EAr133r71CDMM"++-- .01I DLL,, - >rRcD|ra|j|rPd}tr|j|sd}|j|}|j t ||dz||yt ||j|} |j} | d|| fz| |dzdz} | |_y)z Fastpath for iset when we are only setting a single position and the Block currently in that position is itself single-column. In this case we can swap out the entire Block and blklocs and blknos are unaffected. FTrc)rNrer) rr rrarrir4rrF) rNrrrrrlrrrro old_blocksrs rOrzBlockManager._iset_singles$ s''.D"$T-I-I%-P<<$D OOE$q15tO D  %3==t D[[ '2%/*UQY[2II   rRcd}trN|j|s=t|j|j|j t tfsd}ntr|j|sq|j|}|j|}|j|j }|jdk(r|j}n||g}|j||g||j|d} |r| j||n;| j|f|} |j!|| j"j d|r)t%j&t(t*t-yy)z Set values ("setitem") into a single column (not setting the full column). This is a method on the BlockManager level, to avoid creating an intermediate Series at the DataFrame level (`s = df[loc]; s[idx] = value`) FTrc)r)rrN)r rrfrFr_rhrrr rarPrrrsetitem_inplacerr_blockrrr+rr) rNridxr inplace_only needs_to_warnrrrhcol_mgrr.s rOcolumn_setitemzBlockManager.column_setitems@  (>(>s(C DKK,-44$&67 !% "4+A+A#+FKK$Ell3'G[['..F{{a  *  " "57)V <))C5)1   # #C /oosfe4G IIc7>>00$I ?  MM'+-  rRctj5tjddt|jj ||}ddd|j dk(r<|j}t|dkDr9td|jjt||j }tt||dz}t||| }t|jsWt!j"d gt j$ |_t!j"d gt j$ |_n"|j+||j-||j.d <|xj|fz c_d |_t3d |jDdkDr%tj4dt6t9yy#1swYxYw)z Insert item at selected position. Parameters ---------- loc : int item : hashable value : np.ndarray or ExtensionArray refs : The reference tracking object of the value to set. ignorez.ps?%5%%%?sdaDataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`r)rcatch_warningsfilterwarningsrrinsertrPrrrrr/rrir4rFrrrrDrC_insert_update_mgr_locs!_insert_update_blklocs_and_blknosrHrTrwrrr)rNritemrrr+rnrs rOrzBlockManager.insertCs $ $ & 4  # #N&  zz((d3H 4 ::?GGE5zA~ CEGGMM?S'u499=E E#sQw/ 0ERdC4;;HHaS8DM88QCrww7DL  ( ( -  2 23 7 !  x #( ?4;;? ?# E MMW#+-   FE 4 4s 9GG'ct|j|dD]4\}}|j|}|jj ||_6y)z When inserting a new Block at location 'loc', we increment all of the mgr_locs of blocks above that by one. N)_fast_count_smallintsr_rFrincrement_above)rNrrcountrls rOrz$BlockManager._insert_update_mgr_locszsK 2$++cd2CD ?LE5++e$CMM99#>CM ?rRc||jjdk(r^tj|jd|_tj|j t |j|_y|dk(rvtj|jddddddd|_tj|j dddt |jddd|_ytj|j|j|t |j\}}||_||_y)zk When inserting a new Block at location 'loc', we update our _blklocs and _blknos. rNr ) rarrrrDrCrrFr:update_blklocs_and_blknosr_)rNr new_blklocsrs rOrz.BlockManager._insert_update_blklocs_and_blknoss $,,$$Q' 'IIdmmQ7DM99T\\3t{{3CDDL AXIIdmmDbD&91=ddCDM99T\\$B$%7T[[9IJ4R4PDL&2&L&L dkk3DKK0@' #K(DM%DLrRc<tj|jdtj}d||<|j d}|j |dd}|j |}||jdg}t|t||dS)zJ Delete selected locations, returning a new BlockManager. rrT)r&r0rcFr) rrrrnonzeror)rrHrkr)rNrrrIr new_columnsrHs rOideletezBlockManager.ideletesXXdjjm288< " 7%%'*))%DQU)Vjj*- TYYq\*tDz%*dUCCrRcg}|jD]^}|jr3|jD]}|j|}t ||}!B|j|}t ||}`t |dk(rd}n|dj jd}tt|}t|j||jd|gS)z Apply grouped reduction function blockwise, returning a new BlockManager. Parameters ---------- func : grouped reduction function Returns ------- BlockManager rr ) rFrrrr0rrhrr%rangerkr\rH)rNfuncrrlsbrnrowsrs rOgrouped_reducezBlockManager.grouped_reduces&( ;; FC}}**,JB hhtnG$1'=$IMJ))D/ -g} E  F }  "E!!$++11"5EeEl#Dz%%mdiilE5JKKrRc|jdk(sJg}|jD]$}|j|}|j|&t dg}t |j ||j|g}|S)z Apply reduction function blockwise, returning a single-row BlockManager. Parameters ---------- func : reduction function Returns ------- BlockManager ruN)rPrFreducerr%rkr\r)rNr res_blocksrlrrr.s rOrzBlockManager.reducesyyyA~~"$ ;; #C**T"C   c " #tf t*((djj%5HIrRct|||S)zO Apply array_op blockwise with another (aligned) BlockManager. )r6)rNotherarray_ops rOr6zBlockManager.operate_blockwises!uh77rRc$t||tS) Used in .equals defined in base class. Only check the column values assuming shape and indexes have already been checked. )r5r)rNrs rO _equal_valueszBlockManager._equal_valuess T5,77rRlinear) interpolationc&|jdk\sJt|sJt|j}t |t j |d<|jDcgc]}|j||}}t|||Scc}w)a Iterate over blocks applying quantile reduction. This routine is intended for reduction type operations and will do inference on the generated blocks. Parameters ---------- interpolation : type of interpolation, default 'linear' qs : list of the quantiles to be computed Returns ------- BlockManager rurrc)qsr) rPrrrHr%rfloat64rFquantilerk)rNrrrrlrFs rOrzBlockManager.quantiles,yyA~~B ?Bbjj1 IM  ADCLLBmL <  tDz&(++  s Bc*|j|j}|j}|j }|r7|jj |j }|jd}n(tj|j dt}g}g} t|jdk(rd} n.Gs$H2S%6$HrvFr)get_new_columnsr new_indexmask_allmaskreshape full_shaperrrrSrrUrFrtile_for_unstack_unstackrrwrn)rN unstackerr%rrr2 new_mask2Drr columns_maskfactorfacrlrrrFrr s rOunstackzBlockManager.unstacks // ; '' "+++ 39>>/22I4H4HIJ&NNN2MHHY%9%9!%QV W rRci}|jD]6}|jt|jgj |8|j Dcic]\}}||j |c}}Scc}}w)z Return a dict of str(dtype) -> BlockManager Returns ------- values : a dict of dtype -> BlockManager )rF setdefaultr`rrrr)rNbdrrrFs rOto_dictzBlockManager.to_dictQsm&( 6A MM#agg, + 2 21 5 6CE((*Mt}}V,,MMMsA;ctj|xr t|}t|jdk(r5t j |jt}|jS|jr|jd}|tjur%tj|jdr|rnd}|jr8|jj!|||j#|j}nF|s"t j$|j|}n"t j&|j||}t)r7|s5|j+}d|j,_n|j1||}|tjur |jS|jj2dk(r|r |jS||t|<|jS) a- Convert the blockmanager data into an numpy array. Parameters ---------- dtype : np.dtype or None, default None Data type of the return array. copy : bool, default False If True then guarantee that a copy is returned. A value of False does not guarantee that the underlying data is not copied. na_value : object, default lib.no_default Value to be used as the missing value sentinel. Returns ------- arr : ndarray rrrT)rna_valuer)rrFrr)r is_floatrrrFrrMrfloat transposerr6 is_np_dtyperrrhto_numpyrasarrayrr rflags writeable _interleavekind)rNrrr passed_nanrmrls rOr zBlockManager.as_arrayas0\\(+>X t{{ q ((4::U3C==? "   ++a.Cs~~-??399c2zD jj))%*'#))$  jj59hhszzTB"$Thhj&+ #"""BC s~~ %  }} YY^^s "z }}&CS N}}rRc|s-t|jDcgc]}|jc}}t|}t j |j |}t j|j d}|t jdk(r`|tjurN|jD]=}|j}|j|}|||j<d||j<?|S|jD]g}|j}|jr|jj||}n|j|}|||j<d||j<i|j!s t#d|Scc}w)zt Return ndarray from blocks with specified item order Items must be contained in the blocks rrrrcrz'Some items were not contained in blocks)r*rFrr)rrMrrr r6r get_valuesrrrhr rrq)rNrrrlr-itemmaskrrms rOrzBlockManager._interleaves\&&*kk2s2E  &$**E288DJJqM* BHHX& &8s~~+E{{ )\\nnU+%(rzz"'($  ) M;; %CB jj))%* nnU+!$F2:: #$HRZZ  % ||~ !JK K M3sF cR|js|j|jS)zH Return True if more than one block with the same dtype )rT_consolidate_checkrUrMs rOrzBlockManager.is_consolidateds%''  # # %$$$rRct|jdk(rd|_d|_y|jDcgc]}|js|j }}t|tt |k(|_d|_ycc}w)NrcT)rrFrUrTr=rrrs rOrzBlockManager._consolidate_checksq t{{ q $(D !'+D $ '+{{Kc6J6J#))KK #F s3v;/? ?#' Ls BBc|js9t|j|_d|_d|_|j yyrr)r _consolidaterFrUrTr^rMs rOrz!BlockManager._consolidate_inplacesA ##%&t{{3DK$(D !'+D $  , , . &rRc(d}g}|D]v}|jD]M}|jtd}|jj ||_|j |O|t |jz }x|t||}|S)zK Concatenate uniformly-indexed BlockManagers horizontally. rN) rFslice_block_columnsriraddrrrr) r[mgrsrHoffsetrFrrlror.s rOconcat_horizontalzBlockManager.concat_horizontals   %Czz ",,U4[9!||//7  b!  " c#))n $F %eFmT*rRctd)zI Concatenate uniformly-indexed BlockManagers vertically. z.This logic lives (for now) in internals.concatrK)r[rrHs rOconcat_verticalzBlockManager.concat_verticals ""RSSrRrV)rFzSequence[Block]rHzSequence[Index]rWrSrTrWrTrWrX)rrUrTrg)rrUrrSrTrg)rrUrTr7)rTzlist[np.ndarray])FN) rint | slice | np.ndarrayrr7rrSrBlockValuesRefs | NonerTrW)NN) rrUrznp.ndarray | list[int]rzArrayLike | Nonerr#rTrWrJ)rrUrr7rrSrrUrlr-rr#rTrWF)rrUrr"rrSrTrW)rrUrrrr7rTrW)rTrn)rrrTr;)rrnrTrn)rNrnrrnrTrS)rr%rr:rTr;)rTzdict[str, Self])rnp.dtype | NonerrSrrrT np.ndarray)rr%rrrTr&r[)rz list[Self]rHrGrTr;)&rrdrerfrPrXrrrjr\rrrrirrrrrrrrrrrr6rrrrr r6r rrrrrr rArRrOrnrns D"& %%% %  %, 9947l 4 >'+ T- %T-T- T- % T-  T-t#''+ />/>)/> /> % />  />p(,      % DTY//5/LP/ /b5n?&, D LB08 808 ,  ,- ,  ,H;zN$"&>> HHH H  HX"&>>444  4r%( /(TTrRrnceZdZdZeddZdZdZdZdZ d d!dZ e d"dZ e d# d$dZ d%dZd&d'd Zd Zd(d Zd(d Zed)d ZedZedZd*dZd&d+dZed,dZed-dZd.dZdZdZd/dZd0dZed1dZ d2d3fd Z!d4dZ"dZ#d5dZ$d6dZ%xZ&S)7rgzmanage a single block withcyr~rArMs rOrPzSingleBlockManager.ndim$srRTrAc$|g|_|f|_yrJrHrF)rNrrwrWs rOrXzSingleBlockManager.__init__-sF h rRcdt|dk(sJt|dk(sJ||d|ddS)r|rcrFrrrZs rOr\zSingleBlockManager.from_blocks:s=6{a4yA~~6!9d1g>>rRct|}ttdt|}t ||d|}|||S)zN Constructor for if we have an array that is not yet a Block. rrcr~)r2rrirr3)r[rrrrnrs rO from_arrayzSingleBlockManager.from_arrayGs@$E* E!SZ0 1%2ADA5%  rRc|jd}t|jd}td}t |||d|j }||j dg}t|g|dS)z5 Manager analogue of Series.to_frame rrurvr~F)rHrW)rFr/rhrrkrrHrn)rNcolumnsrlrmrnnew_blkrHs rO to_2d_mgrzSingleBlockManager.to_2d_mgrSshkk!n !4 A $s)C2ACHHE1&WID5IIrRcR|jdjj S)rrr)rNrs rOrz$SingleBlockManager._has_no_reference^s$ ;;q>&&44666rRc|jDcgc]}|j}}|jDcgc]%}|j|jj'}}t |j }d||jDcgc]%}|j|jjd'c}di}||||fScc}wcc}wcc}w)N0.14.1)rhrr*)rFrhrrrrrH)rNrrQ block_items axes_array extra_states rO __getstate__zSingleBlockManager.__getstate__fs*.++6Q6 6?C{{K!tzz!**"4"45K K$))_  ""[[ !xxQZZ5G5GH <kAA!7K sB9*B>*CcRd dt|trqt|dk\rcd|dvr\|dd}|dDcgc] }t|c}|_t|jtfd|dD|_n t d|jycc}w) Nct|d}t|ts t|}t|}t |||S)NT) extract_numpyr)r#rfrr2r3)rhrrPs rOunpickle_blockz7SingleBlockManager.__setstate__..unpickle_blockzs=#6>Fh7)(3(0FVxdC CrRr5rHc3@K|]}|d|dyw)rhrrvNrA)rrrPr=s rOrz2SingleBlockManager.__setstate__..s- q{AjMEE srFz*pre-0.14.1 pickles are no longer supported)rPrUrTr-)rfrrr&rHrFrL_post_setstate)rNstaterrPr=s @@rO __setstate__zSingleBlockManager.__setstate__ys D eU #E aHaD x DK &&RS S CsB$cyrJrArMs rOrAz!SingleBlockManager._post_setstates rRc |jdSr)rFrMs rOrzSingleBlockManager._blocks{{1~rRcyzcompat with BlockManagerNrArMs rOrCzSingleBlockManager._blknosrRcyrGrArMs rOrDzSingleBlockManager._blklocsrHrRc |j}trJt|dkDr<|jr,t ||j d|j S|j|}t|tjr|jjdk(rd}n |j}ttdt|}t |||d|}|j |}t |||S)NrFrrrcr~)rr rrrkrrrhrfrrrrrrri)rNrrlrrrnrnew_idxs rOget_rows_with_maskz%SingleBlockManager.get_rows_with_maskskk  S\A%5'++-4:chhEh2DJJ? ? 7# grzz *w}}/A/AS/HD88D E!SZ0 1S %2ADA**W%tDz%))rRc@||jk\r td|j}|j|}t t dt |}t|||d|j}|jj|}t|||S)Nr$rrcr~) rPr(rrhrrirrkrr_getitem_slice)rNrDrwrlrrnrrs rO get_slicezSingleBlockManager.get_slices 499 BC Ckk 5! E!SZ0 1S %2ACHHEJJ--e4 tDz%++rRc |jdSrrrMs rOrzSingleBlockManager.indexrrRc.|jjSrJ)rrrMs rOrzSingleBlockManager.dtypes{{   rRcbtj|jjgtSr)rrrrrrMs rOrzSingleBlockManager.get_dtypess xx**+6::rRc6|jjS)z$The array that Series.values returns)rexternal_valuesrMs rOrTz"SingleBlockManager.external_valuess{{**,,rRc.|jjS)z%The array that Series._values returns)rrhrMs rOinternal_valuesz"SingleBlockManager.internal_valuess{{!!!rRc.|jjS)z#The array that Series.array returns)rrrMs rOrzSingleBlockManager.array_values{{'''rRcr|jjr|jdS|jS)NFr)rrrrprMs rOrz#SingleBlockManager.get_numeric_datas- ;; ! !99%9( (  rRc.|jjSrJ)r _can_hold_narMs rOr[zSingleBlockManager._can_hold_narXrRcJt}t}|s|rz|jdsi|r;|jj f|_|j jn,|r*|r(tjtttt|9||y)a' Set values with indexer. For Single[Block/Array]Manager, this backs s[indexer] = value This is an inplace version of `setitem()`, mutating the manager/values in place, not returning a new Manager (and Block), and thus never changing the dtype. rrN)r r rrrrF_cacheclearrrr,rrsuperr)rNrrrrwarn_cow __class__s rOrz"SingleBlockManager.setitem_inplaces() %' 4+A+A!+D#{{//13  !!#d +!/1 /rRc|jj|d}|f|_|jdj||jd<|jj |S)zy Delete single location from SingleBlockManager. Ensures that self.blocks doesn't become empty. r)rrrFrHr]r^)rNrros rOrzSingleBlockManager.ideletes[ [[   ( +e yy|**73 !   rRctd)zY fast path for getting a cross-section return a view of the data zUse series._values[loc] insteadrK)rNrs rOrzSingleBlockManager.fast_xs s ""CDDrRc||jd_ttt ||jd_y)a Set the values of the single block in place. Use at your own risk! This does not check if the passed values are valid for the current Block/SingleBlockManager (length, dtype, etc), and this does not properly keep track of references. rN)rFrhrrirr)rNrhs rO set_valueszSingleBlockManager.set_valuess2!' A#1%F 2D#E A rRc|jdk7ry|jdj}|jdj}t||S)rrcFr)rPrFrhr)rNrleftrights rOrz SingleBlockManager._equal_valuessE ::?{{1~$$ Q&&D%((rR)rTz Literal[1]r$)rr-rwr%rWrSrTrWrXrJ)rr7rr%rr#rTrg)r0r%rTrn)rr]r!)rTr-)rznpt.NDArray[np.bool_]rTr;)rDrirwr8rTrgr\)rTr9r^)rTr>rZr[rV)rrSrTrW)rTrg)rhr7rTrW)rr;rTrS)'rrdrerfrirPrUrTrgrrXrjr\r.r2rr9rCrArrrCrDrLrOrrrrTrVrrr[rrrrer __classcell__)ras@rOrgrg!s$ IO "'       ? ? ?  ? ?LP ! !&+ !3I !  ! ! J7B&0 *( ,!!;-"(! ((02 E F )rRrgc t|||}|rj S#t$rY}|Dcgc]}|jncc}w}}td|D}t ||dj dd||Yd}~qd}~wwxYw)Nrc3:K|]}|jdyw)rN)r)rrms rOrz3create_block_manager_from_blocks..As7 ! 7srrc)rnrrhrwrxrr) rFrHr!rWrerrrlrrzs rO create_block_manager_from_blocksrm/sL64:JK   " J L(./#**///777  F1IOOAB,?sKKLs$ BBA8BBc t|||}t||d}|rj S#t$r.}tt ||dj ||Yd}~Fd}~wwxYw)NFrr) _form_blocksrnrrxrrr)rrHr!rrFres rO'create_block_manager_from_column_arraysrqIsk"Hfk4864%@   " J H VfQiootQGGHs1 A($A##A(c $ttt|gt|z}t |dkr|ddd}td|D}t |dkr|ddd}||k(r|||ddk(r t dt d|d|) z.raise a helpful message about our constructionruNr c32K|]}t|ywrJr,)rrs rOrz+raise_construction_error..ps+CG+srz)Empty data passed with indices specified.zShape of passed values is z, indices imply )rmaprUrrr)rz block_shaperHrppassedimplieds rOrxrxds3sYK${*;;< =F 6{a"+d++G 7|q$B$-Q]1~DEE 1&9I'S TTrRc`|dj}t|rt|}||fSd}||fS)Nrcr)rrid)tuprseps rO_grouping_funcr|s? FLLE5!i : :rRc 0tt|}|s t||Stj|t }g}|D]G\\}}}t |} t|tjr|jdv} t|jttfrtjt}t!t||\} } | r t#| } | | t%| d} |j'| t)|r:|Dcgc]}| |dt%|dd}}|j+||Dcgc]&}| t-|ddt%|dd(}}|j+|J|Scc}wcc}w)NmMrurrcr)rr _tuples_to_blocks_no_consolidate itertoolsgroupbyr|r1rfrrr issubclassrkr`bytesr _stack_arraysr"rrrrr/)rr!rtuplesgrouperr_r tup_block block_type is_dtlikerhrerlru dtype_blockss rOroros )F# $F /== 7GC!(% EI#E* eRXX & d*I%**sEl3( -d9ou E FI7?V~i/HqQC JJsO  '#1Q4>!A$+?aHL JJ| $# &qtQ/>!A$;OVWL JJ| $;%< Js !F +Fc t||Dcgc]*\\}}}tt|dt||,c}}}Scc}}}w)Nrurvr)rAr4r/r)rrrrmrs rOrrsR #640    Xas  s +~a7Hs   s/Act|\}}|d}t|f|jz}tj||}t |D] \}}|||< ||fS)Nrr)rArrrrMr) rrrerfirstrstackedrrms rOrrskV Iv 1IE [NU[[ (EhhuE*GF#3  I rRcd}tjt|||}g}|D].\\}}}tt |||\}}t ||}0t |S)zJ Merge blocks having same dtype, exclude non-consolidating blocks c|jSrJ)_consolidate_key)rus rOz_consolidate..s Q''rR)key)rcan_consolidate)rrsorted _merge_blocksrr0r) rFgkeyrrr=r group_blocks merged_blocksrs rOrrsx (Dv4 8$?G J3:>/! 5<(  e=M  q#=*= >  rRcjt|dk(r|dfS|r tj|Dcgc]}|jjc}}t |dj tj r.tj|Dcgc]}|jc}}nF|Dcgc]}|j}}ttt|}|dj|d}tj|} || }|| }t|} t|| gdfS|dfScc}wcc}wcc}w)NrcFrrrdT)rrr rr rfrvstackrhr rr!_concat_same_typeargsortrr4) rFrrrr3 new_valuesrlbvalsbvals2rrns rOrrs 6{au}~~F&Kqqzz':':&KL  fQioorxx 0 f#=AHH#=>J+12CSZZ2E2(#>?GF44V!4DJ**\*( #G, L )Z267== 5=/'L$>2sD&D+&D0cptj|}|jd}t|||S)z:Faster version of set(arr) for sequences of small numbers.r)rbincountrrA)rmcountsnzs rOrr s4 [[ F  ! B r6": rRcLt|trd|tj||fSt|tj r|j jdk7r"t|dd}tt||t|}|s t||}d|t|fS)Nrirrfancy)rfrir: slice_lenrrrrr TypeErrorrkrr$r)rBlengthr2rrs rOr7r7 s"E*    " "#3V <  +RZZ8%%**c1,gt *((*jjuEj: # AhhuE2 $ :: 8EKrR)TT) rFrYrHrGr!rSrWrSrTrn) rr_rHrGr!rSrrrTrnrJ)rzrUrur<rHrGrpzValueError | None)rzztuple[int, ArrayLike]rTztuple[int, DtypeObj])rr_r!rSrrrTrY)rTrY)rznp.dtype)rFrErTrE)rFrYrr9rrSrTztuple[list[Block], bool])rmrB)rBrcrrUr2rS)rr9rr<rTr7)m __future__rcollections.abcrrrtypingrrrr rnumpyrpandas._configr r pandas._libsr r:r pandas._libs.internalsrrpandas._libs.tslibsr pandas.errorsrpandas.util._decoratorsrpandas.util._exceptionsrpandas.core.dtypes.castrpandas.core.dtypes.commonrrrpandas.core.dtypes.dtypesrrpandas.core.dtypes.genericrrpandas.core.dtypes.missingrrpandas.core.algorithmscore algorithmsr9pandas.core.arraysrrr pandas.core.arrays._mixinsr!pandas.core.constructionr"r#pandas.core.indexersr$pandas.core.indexes.apir%r&pandas.core.internals.baser'r(r)r*pandas.core.internals.blocksr+r,r-r.r/r0r1r2r3r4pandas.core.internals.opsr5r6pandas._typingr7r8r9r:r;r<r=pandas.api.extensionsr>r@rnrgrmrqrxr|rorrrrrr7rOrArRrOrs"  *,24;  '& C7    5X  {X  vWT<,,.>WTtG))+<G)b!      4      > UUU U U: +\ "    ( ;?  F.(.25.CG.. rR