import{S as p0,i as m0,s as b0,e as a,k as s,w as p,t as d,M as h0,c as o,d as t,m as l,a as r,x as m,h as c,b as i,G as e,g as k,y as b,q as h,o as u,B as g,v as u0,L as g0}from"../../chunks/vendor-hf-doc-builder.js";import{D as f}from"../../chunks/Docstring-hf-doc-builder.js";import{C as f0}from"../../chunks/CodeBlock-hf-doc-builder.js";import{I as Cn}from"../../chunks/IconCopyLink-hf-doc-builder.js";import{E as y0}from"../../chunks/ExampleCodeBlock-hf-doc-builder.js";function v0(Bd){let M,_e,P,C,j;return C=new f0({props:{code:`import pandas as pd
import pyarrow as pa
df = pd.DataFrame({
pa.Table.from_pandas(df)`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> pandas <span class="hljs-keyword">as</span> pd
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> pyarrow <span class="hljs-keyword">as</span> pa
<span class="hljs-meta">&gt;&gt;&gt; </span>df = pd.DataFrame({
    ...     <span class="hljs-string">&#x27;int&#x27;</span>: [<span class="hljs-number">1</span>, <span class="hljs-number">2</span>],
    ...     <span class="hljs-string">&#x27;str&#x27;</span>: [<span class="hljs-string">&#x27;a&#x27;</span>, <span class="hljs-string">&#x27;b&#x27;</span>]
    ... })
<span class="hljs-meta">&gt;&gt;&gt; </span>pa.Table.from_pandas(df)
&lt;pyarrow.lib.Table <span class="hljs-built_in">object</span> at <span class="hljs-number">0x7f05d1fb1b40</span>&gt;`}}),{c(){M=a("p"),_e=d("Examples:"),P=s(),p(C.$$.fragment)},l(I){M=o(I,"P",{});var F=r(M);_e=c(F,"Examples:"),F.forEach(t),P=l(I),m(C.$$.fragment,I)},m(I,F){k(I,M,F),e(M,_e),k(I,P,F),b(C,I,F),j=!0},p:g0,i(I){j||(h(C.$$.fragment,I),j=!0)},o(I){u(C.$$.fragment,I),j=!1},d(I){I&&t(M),I&&t(P),g(C,I)}}}function $0(Bd){let M,_e,P,C,j,I,F,Pn,lp,Wd,V,dp,Ln,cp,ip,Br,pp,mp,Xd,ae,we,An,ca,bp,Nn,hp,Hd,E,ia,up,A,gp,jn,fp,yp,Fn,vp,$p,Vn,_p,wp,Tp,oe,Ep,Sn,xp,Dp,On,kp,Ip,Mp,Rn,Cp,Pp,S,pa,Lp,qn,Ap,Np,re,jp,Un,Fp,Vp,zn,Sp,Op,Rp,Te,ma,qp,Bn,Up,zp,Ee,ba,Bp,ha,Wp,Wn,Xp,Hp,Kp,xe,ua,Gp,ne,Yp,Xn,Jp,Qp,Hn,Zp,em,tm,De,ga,am,Kn,om,rm,Wr,fa,nm,ke,ya,sm,Gn,lm,dm,Ie,va,cm,Yn,im,pm,Me,$a,mm,Jn,bm,hm,Ce,_a,um,Qn,gm,fm,Pe,wa,ym,Zn,vm,$m,Le,Ta,_m,es,wm,Tm,O,Ea,Em,ts,xm,Dm,as,km,Im,Ae,xa,Mm,os,Cm,Pm,Ne,Da,Lm,rs,Am,Kd,se,je,ns,ka,Nm,ss,jm,Gd,y,Ia,Fm,ls,Vm,Sm,ds,Om,Rm,le,qm,cs,Um,zm,is,Bm,Wm,Xm,Fe,ps,Hm,Km,ms,Gm,Ym,Jm,R,Ma,Qm,bs,Zm,eb,de,tb,hs,ab,ob,us,rb,nb,sb,Ve,Ca,lb,gs,db,cb,Se,Pa,ib,La,pb,fs,mb,bb,hb,Oe,Aa,ub,ce,gb,ys,fb,yb,vs,vb,$b,_b,Re,Na,wb,$s,Tb,Eb,Xr,ja,xb,qe,Fa,Db,_s,kb,Ib,Ue,Va,Mb,ws,Cb,Pb,ze,Sa,Lb,Ts,Ab,Nb,Be,Oa,jb,Es,Fb,Vb,We,Ra,Sb,xs,Ob,Rb,Xe,qa,qb,Ds,Ub,zb,q,Ua,Bb,ks,Wb,Xb,Is,Hb,Kb,He,za,Gb,Ms,Yb,Jb,Ke,Ba,Qb,Cs,Zb,eh,Ge,Wa,th,Ps,ah,oh,Ye,Xa,rh,Ls,nh,sh,Je,Ha,lh,Ka,dh,As,ch,ih,ph,Qe,Ga,mh,Ns,bh,hh,U,Ya,uh,js,gh,fh,Ja,yh,Fs,vh,$h,_h,Ze,Qa,wh,Vs,Th,Eh,et,Za,xh,eo,Dh,Ss,kh,Ih,Mh,z,to,Ch,Os,Ph,Lh,Rs,Ah,Nh,tt,ao,jh,qs,Fh,Vh,at,oo,Sh,Us,Oh,Rh,ot,ro,qh,zs,Uh,zh,rt,no,Bh,Bs,Wh,Xh,B,so,Hh,Ws,Kh,Gh,Xs,Yh,Jh,nt,lo,Qh,Hs,Zh,eu,Hr,co,tu,Kr,io,au,L,po,ou,Ks,ru,nu,mo,su,Gs,lu,du,cu,ie,iu,Ys,pu,mu,Js,bu,hu,uu,st,gu,lt,bo,fu,Qs,yu,vu,dt,ho,$u,Zs,_u,wu,ct,uo,Tu,go,Eu,el,xu,Du,Yd,pe,it,tl,fo,ku,al,Iu,Jd,_,yo,Mu,ol,Cu,Pu,rl,Lu,Au,nl,Nu,ju,vo,Fu,sl,Vu,Su,Ou,pt,ll,Ru,qu,dl,Uu,zu,Bu,W,$o,Wu,cl,Xu,Hu,me,Ku,il,Gu,Yu,pl,Ju,Qu,Zu,mt,_o,eg,ml,tg,ag,bt,wo,og,To,rg,bl,ng,sg,lg,ht,Eo,dg,be,cg,hl,ig,pg,ul,mg,bg,hg,ut,xo,ug,gl,gg,fg,Gr,Do,yg,gt,ko,vg,fl,$g,_g,ft,Io,wg,yl,Tg,Eg,yt,Mo,xg,vl,Dg,kg,vt,Co,Ig,$l,Mg,Cg,$t,Po,Pg,_l,Lg,Ag,_t,Lo,Ng,wl,jg,Fg,X,Ao,Vg,Tl,Sg,Og,El,Rg,qg,wt,No,Ug,xl,zg,Bg,Tt,jo,Wg,Dl,Xg,Hg,Et,Fo,Kg,kl,Gg,Yg,xt,Vo,Jg,Il,Qg,Zg,Dt,So,ef,Oo,tf,Ml,af,of,rf,kt,Ro,nf,Cl,sf,lf,H,qo,df,Pl,cf,pf,Ll,mf,bf,It,Uo,hf,Al,uf,gf,Mt,zo,ff,Nl,yf,vf,K,Bo,$f,jl,_f,wf,Fl,Tf,Ef,Ct,Wo,xf,Vl,Df,kf,Pt,Xo,If,Sl,Mf,Cf,Lt,Ho,Pf,Ol,Lf,Af,At,Ko,Nf,Rl,jf,Ff,G,Go,Vf,ql,Sf,Of,Ul,Rf,qf,Nt,Yo,Uf,zl,zf,Bf,Yr,Jo,Qd,he,jt,Bl,Qo,Wf,Wl,Xf,Zd,v,Zo,Hf,Xl,Kf,Gf,N,Yf,Hl,Jf,Qf,Kl,Zf,ey,Gl,ty,ay,oy,er,tr,ry,Yl,ny,sy,ly,Jl,dy,cy,ar,iy,Ql,py,my,by,or,hy,Zl,uy,gy,fy,ue,yy,ed,vy,$y,td,_y,wy,Ty,Y,rr,Ey,ad,xy,Dy,ge,ky,od,Iy,My,rd,Cy,Py,Ly,Ft,nr,Ay,nd,Ny,jy,Vt,sr,Fy,lr,Vy,sd,Sy,Oy,Ry,St,dr,qy,fe,Uy,ld,zy,By,dd,Wy,Xy,Hy,Ot,cr,Ky,cd,Gy,Yy,Jr,ir,Jy,Rt,pr,Qy,id,Zy,ev,qt,mr,tv,pd,av,ov,Ut,br,rv,md,nv,sv,zt,hr,lv,bd,dv,cv,Bt,ur,iv,hd,pv,mv,Wt,gr,bv,ud,hv,uv,J,fr,gv,gd,fv,yv,fd,vv,$v,Xt,yr,_v,yd,wv,Tv,Ht,vr,Ev,vd,xv,Dv,Kt,$r,kv,$d,Iv,Mv,Gt,_r,Cv,_d,Pv,Lv,Yt,wr,Av,Tr,Nv,wd,jv,Fv,Vv,Jt,Er,Sv,Td,Ov,Rv,Q,xr,qv,Ed,Uv,zv,Dr,Bv,xd,Wv,Xv,Hv,Qt,kr,Kv,Dd,Gv,Yv,Zt,Ir,Jv,Mr,Qv,kd,Zv,e2,t2,Z,Cr,a2,Id,o2,r2,Md,n2,s2,ea,Pr,l2,Cd,d2,c2,ta,Lr,i2,Pd,p2,m2,aa,Ar,b2,Ld,h2,u2,oa,Nr,g2,Ad,f2,y2,ee,jr,v2,Nd,$2,_2,jd,w2,T2,ra,Fr,E2,Fd,x2,D2,Qr,Vr,k2,na,Sr,I2,Or,M2,Vd,C2,P2,ec,ye,sa,Sd,Rr,L2,Od,A2,tc,ve,qr,N2,Rd,j2,ac,$e,Ur,F2,qd,V2,oc;return I=new Cn({}),ca=new Cn({}),ia=new f({props:{name:"class datasets.table.Table",anchor:"datasets.table.Table",parameters:[{name:"table",val:": Table"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L165"}}),pa=new f({props:{name:"validate",anchor:"datasets.table.Table.validate",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.Table.validate.full",description:`<strong>full</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
If <code>True</code>, run expensive checks, otherwise cheap checks only.`,name:"full"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L216",raiseDescription:`
<ul>
<li><code>pa.lib.ArrowInvalid</code> \u2014 if validation fails</li>
</ul>
`,raiseType:`
<p><code>pa.lib.ArrowInvalid</code></p>
`}}),ma=new f({props:{name:"equals",anchor:"datasets.table.Table.equals",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.Table.equals.other",description:`<strong>other</strong> (<a href="/docs/datasets/v2.8.0/en/package_reference/table_classes#datasets.table.Table">Table</a>) &#x2014;
Table to compare against.`,name:"other"},{anchor:"datasets.table.Table.equals.check_metadata",description:`<strong>check_metadata</strong> <code>bool</code>, defaults to <code>False</code>) &#x2014;
Whether schema metadata equality should be checked as well.`,name:"check_metadata"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L232",returnType:`
<p><code>bool</code></p>
`}}),ba=new f({props:{name:"to_batches",anchor:"datasets.table.Table.to_batches",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.Table.to_batches.max_chunksize",description:`<strong>max_chunksize</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Maximum size for <code>RecordBatch</code> chunks. Individual chunks may be
smaller depending on the chunk layout of individual columns.`,name:"max_chunksize"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L249",returnDescription:`
<p><code>List[pyarrow.RecordBatch]</code></p>
`}}),ua=new f({props:{name:"to_pydict",anchor:"datasets.table.Table.to_pydict",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L263",returnType:`
<p><code>dict</code></p>
`}}),ga=new f({props:{name:"to_pandas",anchor:"datasets.table.Table.to_pandas",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.Table.to_pandas.memory_pool",description:`<strong>memory_pool</strong> (<code>MemoryPool</code>, defaults to <code>None</code>) &#x2014;
Arrow MemoryPool to use for allocations. Uses the default memory
pool is not passed.`,name:"memory_pool"},{anchor:"datasets.table.Table.to_pandas.strings_to_categorical",description:`<strong>strings_to_categorical</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Encode string (UTF8) and binary types to <code>pandas.Categorical</code>.`,name:"strings_to_categorical"},{anchor:"datasets.table.Table.to_pandas.categories",description:`<strong>categories</strong> (<code>list</code>, defaults to <code>empty</code>) &#x2014;
List of fields that should be returned as <code>pandas.Categorical</code>. Only
applies to table-like data structures.`,name:"categories"},{anchor:"datasets.table.Table.to_pandas.zero_copy_only",description:`<strong>zero_copy_only</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Raise an <code>ArrowException</code> if this function call would require copying
the underlying data.`,name:"zero_copy_only"},{anchor:"datasets.table.Table.to_pandas.integer_object_nulls",description:`<strong>integer_object_nulls</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Cast integers with nulls to objects.`,name:"integer_object_nulls"},{anchor:"datasets.table.Table.to_pandas.date_as_object",description:`<strong>date_as_object</strong> (<code>bool</code>, defaults to <code>True</code>) &#x2014;
Cast dates to objects. If <code>False</code>, convert to <code>datetime64[ns]</code> dtype.`,name:"date_as_object"},{anchor:"datasets.table.Table.to_pandas.timestamp_as_object",description:`<strong>timestamp_as_object</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Cast non-nanosecond timestamps (<code>np.datetime64</code>) to objects. This is
useful if you have timestamps that don&#x2019;t fit in the normal date
range of nanosecond timestamps (1678 CE-2262 CE).
If <code>False</code>, all timestamps are converted to <code>datetime64[ns]</code> dtype.`,name:"timestamp_as_object"},{anchor:"datasets.table.Table.to_pandas.use_threads",description:`<strong>use_threads</strong> (<code>bool</code>, defaults to <code>True</code>) &#x2014;
Whether to parallelize the conversion using multiple threads.`,name:"use_threads"},{anchor:"datasets.table.Table.to_pandas.deduplicate_objects",description:`<strong>deduplicate_objects</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Do not create multiple copies Python objects when created, to save
on memory use. Conversion will be slower.`,name:"deduplicate_objects"},{anchor:"datasets.table.Table.to_pandas.ignore_metadata",description:`<strong>ignore_metadata</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
If <code>True</code>, do not use the &#x2018;pandas&#x2019; metadata to reconstruct the
DataFrame index, if present.`,name:"ignore_metadata"},{anchor:"datasets.table.Table.to_pandas.safe",description:`<strong>safe</strong> (<code>bool</code>, defaults to <code>True</code>) &#x2014;
For certain data types, a cast is needed in order to store the
data in a pandas DataFrame or Series (e.g. timestamps are always
stored as nanoseconds in pandas). This option controls whether it
is a safe cast or not.`,name:"safe"},{anchor:"datasets.table.Table.to_pandas.split_blocks",description:`<strong>split_blocks</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
If <code>True</code>, generate one internal &#x201C;block&#x201D; for each column when
creating a pandas.DataFrame from a <code>RecordBatch</code> or <code>Table</code>. While this
can temporarily reduce memory note that various pandas operations
can trigger &#x201C;consolidation&#x201D; which may balloon memory use.`,name:"split_blocks"},{anchor:"datasets.table.Table.to_pandas.self_destruct",description:`<strong>self_destruct</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
EXPERIMENTAL: If <code>True</code>, attempt to deallocate the originating Arrow
memory while converting the Arrow object to pandas. If you use the
object after calling <code>to_pandas</code> with this option it will crash your
program.`,name:"self_destruct"},{anchor:"datasets.table.Table.to_pandas.types_mapper",description:`<strong>types_mapper</strong> (<code>function</code>, defaults to <code>None</code>) &#x2014;
A function mapping a pyarrow DataType to a pandas <code>ExtensionDtype</code>.
This can be used to override the default pandas type for conversion
of built-in pyarrow types or in absence of <code>pandas_metadata</code> in the
Table schema. The function receives a pyarrow DataType and is
expected to return a pandas <code>ExtensionDtype</code> or <code>None</code> if the
default conversion should be used for that type. If you have
a dictionary mapping, you can pass <code>dict.get</code> as function.`,name:"types_mapper"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L285",returnDescription:`
<p><code>pandas.Series</code> or <code>pandas.DataFrame</code> depending on type of object</p>
`,returnType:`
<p><code>pandas.Series</code> or <code>pandas.DataFrame</code></p>
`}}),fa=new f({props:{name:"to_string",anchor:"datasets.table.Table.to_string",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L347"}}),ya=new f({props:{name:"field",anchor:"datasets.table.Table.field",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.Table.field.i",description:`<strong>i</strong> (<code>Union[int, str]</code>) &#x2014;
The index or name of the field to retrieve.`,name:"i"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L368",returnDescription:`
<p><code>pyarrow.Field</code></p>
`}}),va=new f({props:{name:"column",anchor:"datasets.table.Table.column",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.Table.column.i",description:`<strong>i</strong> (<code>Union[int, str]</code>) &#x2014;
The index or name of the column to retrieve.`,name:"i"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L381",returnDescription:`
<p><code>pyarrow.ChunkedArray</code></p>
`}}),$a=new f({props:{name:"itercolumns",anchor:"datasets.table.Table.itercolumns",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L394"}}),_a=new f({props:{name:"schema",anchor:"datasets.table.Table.schema",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L403",returnDescription:`
<p><code>pyarrow.Schema</code></p>
`}}),wa=new f({props:{name:"columns",anchor:"datasets.table.Table.columns",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L413",returnDescription:`
<p><code>List[pa.ChunkedArray]</code></p>
`}}),Ta=new f({props:{name:"num_columns",anchor:"datasets.table.Table.num_columns",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L423",returnDescription:`
<p>int</p>
`}}),Ea=new f({props:{name:"num_rows",anchor:"datasets.table.Table.num_rows",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L433",returnDescription:`
<p>int</p>
`}}),xa=new f({props:{name:"shape",anchor:"datasets.table.Table.shape",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L446",returnDescription:`
<p>Number of rows and number of columns.</p>
`,returnType:`
<p><code>(int, int)</code></p>
`}}),Da=new f({props:{name:"nbytes",anchor:"datasets.table.Table.nbytes",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L456"}}),ka=new Cn({}),Ia=new f({props:{name:"class datasets.table.InMemoryTable",anchor:"datasets.table.InMemoryTable",parameters:[{name:"table",val:": Table"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L682"}}),Ma=new f({props:{name:"validate",anchor:"datasets.table.InMemoryTable.validate",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.validate.full",description:`<strong>full</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
If <code>True</code>, run expensive checks, otherwise cheap checks only.`,name:"full"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L216",raiseDescription:`
<ul>
<li><code>pa.lib.ArrowInvalid</code> \u2014 if validation fails</li>
</ul>
`,raiseType:`
<p><code>pa.lib.ArrowInvalid</code></p>
`}}),Ca=new f({props:{name:"equals",anchor:"datasets.table.InMemoryTable.equals",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.equals.other",description:`<strong>other</strong> (<a href="/docs/datasets/v2.8.0/en/package_reference/table_classes#datasets.table.Table">Table</a>) &#x2014;
Table to compare against.`,name:"other"},{anchor:"datasets.table.InMemoryTable.equals.check_metadata",description:`<strong>check_metadata</strong> <code>bool</code>, defaults to <code>False</code>) &#x2014;
Whether schema metadata equality should be checked as well.`,name:"check_metadata"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L232",returnType:`
<p><code>bool</code></p>
`}}),Pa=new f({props:{name:"to_batches",anchor:"datasets.table.InMemoryTable.to_batches",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.to_batches.max_chunksize",description:`<strong>max_chunksize</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Maximum size for <code>RecordBatch</code> chunks. Individual chunks may be
smaller depending on the chunk layout of individual columns.`,name:"max_chunksize"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L249",returnDescription:`
<p><code>List[pyarrow.RecordBatch]</code></p>
`}}),Aa=new f({props:{name:"to_pydict",anchor:"datasets.table.InMemoryTable.to_pydict",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L263",returnType:`
<p><code>dict</code></p>
`}}),Na=new f({props:{name:"to_pandas",anchor:"datasets.table.InMemoryTable.to_pandas",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.to_pandas.memory_pool",description:`<strong>memory_pool</strong> (<code>MemoryPool</code>, defaults to <code>None</code>) &#x2014;
Arrow MemoryPool to use for allocations. Uses the default memory
pool is not passed.`,name:"memory_pool"},{anchor:"datasets.table.InMemoryTable.to_pandas.strings_to_categorical",description:`<strong>strings_to_categorical</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Encode string (UTF8) and binary types to <code>pandas.Categorical</code>.`,name:"strings_to_categorical"},{anchor:"datasets.table.InMemoryTable.to_pandas.categories",description:`<strong>categories</strong> (<code>list</code>, defaults to <code>empty</code>) &#x2014;
List of fields that should be returned as <code>pandas.Categorical</code>. Only
applies to table-like data structures.`,name:"categories"},{anchor:"datasets.table.InMemoryTable.to_pandas.zero_copy_only",description:`<strong>zero_copy_only</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Raise an <code>ArrowException</code> if this function call would require copying
the underlying data.`,name:"zero_copy_only"},{anchor:"datasets.table.InMemoryTable.to_pandas.integer_object_nulls",description:`<strong>integer_object_nulls</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Cast integers with nulls to objects.`,name:"integer_object_nulls"},{anchor:"datasets.table.InMemoryTable.to_pandas.date_as_object",description:`<strong>date_as_object</strong> (<code>bool</code>, defaults to <code>True</code>) &#x2014;
Cast dates to objects. If <code>False</code>, convert to <code>datetime64[ns]</code> dtype.`,name:"date_as_object"},{anchor:"datasets.table.InMemoryTable.to_pandas.timestamp_as_object",description:`<strong>timestamp_as_object</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Cast non-nanosecond timestamps (<code>np.datetime64</code>) to objects. This is
useful if you have timestamps that don&#x2019;t fit in the normal date
range of nanosecond timestamps (1678 CE-2262 CE).
If <code>False</code>, all timestamps are converted to <code>datetime64[ns]</code> dtype.`,name:"timestamp_as_object"},{anchor:"datasets.table.InMemoryTable.to_pandas.use_threads",description:`<strong>use_threads</strong> (<code>bool</code>, defaults to <code>True</code>) &#x2014;
Whether to parallelize the conversion using multiple threads.`,name:"use_threads"},{anchor:"datasets.table.InMemoryTable.to_pandas.deduplicate_objects",description:`<strong>deduplicate_objects</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Do not create multiple copies Python objects when created, to save
on memory use. Conversion will be slower.`,name:"deduplicate_objects"},{anchor:"datasets.table.InMemoryTable.to_pandas.ignore_metadata",description:`<strong>ignore_metadata</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
If <code>True</code>, do not use the &#x2018;pandas&#x2019; metadata to reconstruct the
DataFrame index, if present.`,name:"ignore_metadata"},{anchor:"datasets.table.InMemoryTable.to_pandas.safe",description:`<strong>safe</strong> (<code>bool</code>, defaults to <code>True</code>) &#x2014;
For certain data types, a cast is needed in order to store the
data in a pandas DataFrame or Series (e.g. timestamps are always
stored as nanoseconds in pandas). This option controls whether it
is a safe cast or not.`,name:"safe"},{anchor:"datasets.table.InMemoryTable.to_pandas.split_blocks",description:`<strong>split_blocks</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
If <code>True</code>, generate one internal &#x201C;block&#x201D; for each column when
creating a pandas.DataFrame from a <code>RecordBatch</code> or <code>Table</code>. While this
can temporarily reduce memory note that various pandas operations
can trigger &#x201C;consolidation&#x201D; which may balloon memory use.`,name:"split_blocks"},{anchor:"datasets.table.InMemoryTable.to_pandas.self_destruct",description:`<strong>self_destruct</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
EXPERIMENTAL: If <code>True</code>, attempt to deallocate the originating Arrow
memory while converting the Arrow object to pandas. If you use the
object after calling <code>to_pandas</code> with this option it will crash your
program.`,name:"self_destruct"},{anchor:"datasets.table.InMemoryTable.to_pandas.types_mapper",description:`<strong>types_mapper</strong> (<code>function</code>, defaults to <code>None</code>) &#x2014;
A function mapping a pyarrow DataType to a pandas <code>ExtensionDtype</code>.
This can be used to override the default pandas type for conversion
of built-in pyarrow types or in absence of <code>pandas_metadata</code> in the
Table schema. The function receives a pyarrow DataType and is
expected to return a pandas <code>ExtensionDtype</code> or <code>None</code> if the
default conversion should be used for that type. If you have
a dictionary mapping, you can pass <code>dict.get</code> as function.`,name:"types_mapper"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L285",returnDescription:`
<p><code>pandas.Series</code> or <code>pandas.DataFrame</code> depending on type of object</p>
`,returnType:`
<p><code>pandas.Series</code> or <code>pandas.DataFrame</code></p>
`}}),ja=new f({props:{name:"to_string",anchor:"datasets.table.InMemoryTable.to_string",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L347"}}),Fa=new f({props:{name:"field",anchor:"datasets.table.InMemoryTable.field",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.field.i",description:`<strong>i</strong> (<code>Union[int, str]</code>) &#x2014;
The index or name of the field to retrieve.`,name:"i"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L368",returnDescription:`
<p><code>pyarrow.Field</code></p>
`}}),Va=new f({props:{name:"column",anchor:"datasets.table.InMemoryTable.column",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.column.i",description:`<strong>i</strong> (<code>Union[int, str]</code>) &#x2014;
The index or name of the column to retrieve.`,name:"i"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L381",returnDescription:`
<p><code>pyarrow.ChunkedArray</code></p>
`}}),Sa=new f({props:{name:"itercolumns",anchor:"datasets.table.InMemoryTable.itercolumns",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L394"}}),Oa=new f({props:{name:"schema",anchor:"datasets.table.InMemoryTable.schema",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L403",returnDescription:`
<p><code>pyarrow.Schema</code></p>
`}}),Ra=new f({props:{name:"columns",anchor:"datasets.table.InMemoryTable.columns",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L413",returnDescription:`
<p><code>List[pa.ChunkedArray]</code></p>
`}}),qa=new f({props:{name:"num_columns",anchor:"datasets.table.InMemoryTable.num_columns",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L423",returnDescription:`
<p>int</p>
`}}),Ua=new f({props:{name:"num_rows",anchor:"datasets.table.InMemoryTable.num_rows",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L433",returnDescription:`
<p>int</p>
`}}),za=new f({props:{name:"shape",anchor:"datasets.table.InMemoryTable.shape",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L446",returnDescription:`
<p>Number of rows and number of columns.</p>
`,returnType:`
<p><code>(int, int)</code></p>
`}}),Ba=new f({props:{name:"nbytes",anchor:"datasets.table.InMemoryTable.nbytes",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L456"}}),Wa=new f({props:{name:"column_names",anchor:"datasets.table.InMemoryTable.column_names",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L463"}}),Xa=new f({props:{name:"slice",anchor:"datasets.table.InMemoryTable.slice",parameters:[{name:"offset",val:" = 0"},{name:"length",val:" = None"}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.slice.offset",description:`<strong>offset</strong> (<code>int</code>, defaults to <code>0</code>) &#x2014;
Offset from start of table to slice.`,name:"offset"},{anchor:"datasets.table.InMemoryTable.slice.length",description:`<strong>length</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Length of slice (default is until end of table starting from
offset).`,name:"length"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L841",returnDescription:`
<p><code>datasets.table.Table</code></p>
`}}),Ha=new f({props:{name:"filter",anchor:"datasets.table.InMemoryTable.filter",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L858"}}),Ga=new f({props:{name:"flatten",anchor:"datasets.table.InMemoryTable.flatten",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.flatten.memory_pool",description:`<strong>memory_pool</strong> (<code>MemoryPool</code>, defaults to <code>None</code>) &#x2014;
For memory allocations, if required, otherwise use default pool.`,name:"memory_pool"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L864",returnDescription:`
<p><code>datasets.table.Table</code></p>
`}}),Ya=new f({props:{name:"combine_chunks",anchor:"datasets.table.InMemoryTable.combine_chunks",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.combine_chunks.memory_pool",description:`<strong>memory_pool</strong> (<code>MemoryPool</code>, defaults to <code>None</code>) &#x2014;
For memory allocations, if required, otherwise use default pool.`,name:"memory_pool"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L878",returnDescription:`
<p><code>datasets.table.Table</code></p>
`}}),Qa=new f({props:{name:"cast",anchor:"datasets.table.InMemoryTable.cast",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.cast.target_schema",description:`<strong>target_schema</strong> (<code>Schema</code>) &#x2014;
Schema to cast to, the names and order of fields must match.`,name:"target_schema"},{anchor:"datasets.table.InMemoryTable.cast.safe",description:`<strong>safe</strong> (<code>bool</code>, defaults to <code>True</code>) &#x2014;
Check for overflows or other unsafe conversions.`,name:"safe"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L894",returnDescription:`
<p><code>datasets.table.Table</code></p>
`}}),Za=new f({props:{name:"replace_schema_metadata",anchor:"datasets.table.InMemoryTable.replace_schema_metadata",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.replace_schema_metadata.metadata",description:"<strong>metadata</strong> (<code>dict</code>, defaults to <code>None</code>) &#x2014;",name:"metadata"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L909",returnDescription:`
<p>shallow_copy</p>
`,returnType:`
<p><code>datasets.table.Table</code></p>
`}}),to=new f({props:{name:"add_column",anchor:"datasets.table.InMemoryTable.add_column",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.add_column.i",description:`<strong>i</strong> (<code>int</code>) &#x2014;
Index to place the column at.`,name:"i"},{anchor:"datasets.table.InMemoryTable.add_column.field_",description:`<strong>field_</strong> (<code>Union[str, pyarrow.Field]</code>) &#x2014;
If a string is passed then the type is deduced from the column
data.`,name:"field_"},{anchor:"datasets.table.InMemoryTable.add_column.column",description:`<strong>column</strong> (<code>Union[pyarrow.Array, List[pyarrow.Array]]</code>) &#x2014;
Column data.`,name:"column"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L923",returnDescription:`
<p>New table with the passed column added.</p>
`,returnType:`
<p><code>datasets.table.Table</code></p>
`}}),ao=new f({props:{name:"append_column",anchor:"datasets.table.InMemoryTable.append_column",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.append_column.field_",description:`<strong>field_</strong> (<code>Union[str, pyarrow.Field]</code>) &#x2014;
If a string is passed then the type is deduced from the column
data.`,name:"field_"},{anchor:"datasets.table.InMemoryTable.append_column.column",description:`<strong>column</strong> (<code>Union[pyarrow.Array, List[pyarrow.Array]]</code>) &#x2014;
Column data.`,name:"column"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L944",returnDescription:`
<p>New table with the passed column added.</p>
`,returnType:`
<p><code>datasets.table.Table</code></p>
`}}),oo=new f({props:{name:"remove_column",anchor:"datasets.table.InMemoryTable.remove_column",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.remove_column.i",description:`<strong>i</strong> (<code>int</code>) &#x2014;
Index of column to remove.`,name:"i"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L961",returnDescription:`
<p>New table without the column.</p>
`,returnType:`
<p><code>datasets.table.Table</code></p>
`}}),ro=new f({props:{name:"set_column",anchor:"datasets.table.InMemoryTable.set_column",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.set_column.i",description:`<strong>i</strong> (<code>int</code>) &#x2014;
Index to place the column at.`,name:"i"},{anchor:"datasets.table.InMemoryTable.set_column.field_",description:`<strong>field_</strong> (<code>Union[str, pyarrow.Field]</code>) &#x2014;
If a string is passed then the type is deduced from the column
data.`,name:"field_"},{anchor:"datasets.table.InMemoryTable.set_column.column",description:`<strong>column</strong> (<code>Union[pyarrow.Array, List[pyarrow.Array]]</code>) &#x2014;
Column data.`,name:"column"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L975",returnDescription:`
<p>New table with the passed column set.</p>
`,returnType:`
<p><code>datasets.table.Table</code></p>
`}}),no=new f({props:{name:"rename_columns",anchor:"datasets.table.InMemoryTable.rename_columns",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L994"}}),so=new f({props:{name:"select",anchor:"datasets.table.InMemoryTable.select",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.select.columns",description:`<strong>columns</strong> (<code>Union[List[str], List[int]]</code>) &#x2014;
The column names or integer indices to select.`,name:"columns"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1017",returnDescription:`
<p>New table with the specified columns, and metadata preserved.</p>
`,returnType:`
<p><a
  href="/docs/datasets/v2.8.0/en/package_reference/table_classes#datasets.table.Table"
>datasets.table.Table</a></p>
`}}),lo=new f({props:{name:"drop",anchor:"datasets.table.InMemoryTable.drop",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.drop.columns",description:`<strong>columns</strong> (<code>List[str]</code>) &#x2014;
List of field names referencing existing columns.`,name:"columns"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1000",returnDescription:`
<p>New table without the columns.</p>
`,returnType:`
<p><code>datasets.table.Table</code></p>
`,raiseDescription:`
<ul>
<li><code>KeyError</code> \u2014 : if any of the passed columns name are not existing.</li>
</ul>
`,raiseType:`
<p><code>KeyError</code></p>
`}}),co=new f({props:{name:"from_file",anchor:"datasets.table.InMemoryTable.from_file",parameters:[{name:"filename",val:": str"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L697"}}),io=new f({props:{name:"from_buffer",anchor:"datasets.table.InMemoryTable.from_buffer",parameters:[{name:"buffer",val:": Buffer"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L702"}}),po=new f({props:{name:"from_pandas",anchor:"datasets.table.InMemoryTable.from_pandas",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.from_pandas.df",description:"<strong>df</strong> (<code>pandas.DataFrame</code>) &#x2014;",name:"df"},{anchor:"datasets.table.InMemoryTable.from_pandas.schema",description:`<strong>schema</strong> (<code>pyarrow.Schema</code>, <em>optional</em>) &#x2014;
The expected schema of the Arrow Table. This can be used to
indicate the type of columns if we cannot infer it automatically.
If passed, the output will have exactly this schema. Columns
specified in the schema that are not found in the DataFrame columns
or its index will raise an error. Additional columns or index
levels in the DataFrame which are not specified in the schema will
be ignored.`,name:"schema"},{anchor:"datasets.table.InMemoryTable.from_pandas.preserve_index",description:`<strong>preserve_index</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether to store the index as an additional column in the resulting
<code>Table</code>. The default of None will store the index as a column,
except for RangeIndex which is stored as metadata only. Use
<code>preserve_index=True</code> to force it to be stored as a column.`,name:"preserve_index"},{anchor:"datasets.table.InMemoryTable.from_pandas.nthreads",description:`<strong>nthreads</strong> (<code>int</code>, defaults to <code>None</code> (may use up to system CPU count threads)) &#x2014;
If greater than 1, convert columns to Arrow in parallel using
indicated number of threads.`,name:"nthreads"},{anchor:"datasets.table.InMemoryTable.from_pandas.columns",description:`<strong>columns</strong> (<code>List[str]</code>, <em>optional</em>) &#x2014;
List of column to be converted. If <code>None</code>, use all columns.`,name:"columns"},{anchor:"datasets.table.InMemoryTable.from_pandas.safe",description:`<strong>safe</strong> (<code>bool</code>, defaults to <code>True</code>) &#x2014;
Check for overflows or other unsafe conversions,`,name:"safe"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L707",returnType:`
<p><code>datasets.table.Table</code></p>
`}}),st=new y0({props:{anchor:"datasets.table.InMemoryTable.from_pandas.example",$$slots:{default:[v0]},$$scope:{ctx:Bd}}}),bo=new f({props:{name:"from_arrays",anchor:"datasets.table.InMemoryTable.from_arrays",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.from_arrays.arrays",description:`<strong>arrays</strong> (<code>List[Union[pyarrow.Array, pyarrow.ChunkedArray]]</code>) &#x2014;
Equal-length arrays that should form the table.`,name:"arrays"},{anchor:"datasets.table.InMemoryTable.from_arrays.names",description:`<strong>names</strong> (<code>List[str]</code>, <em>optional</em>) &#x2014;
Names for the table columns. If not passed, schema must be passed.`,name:"names"},{anchor:"datasets.table.InMemoryTable.from_arrays.schema",description:`<strong>schema</strong> (<code>Schema</code>, defaults to <code>None</code>) &#x2014;
Schema for the created table. If not passed, names must be passed.`,name:"schema"},{anchor:"datasets.table.InMemoryTable.from_arrays.metadata",description:`<strong>metadata</strong> (<code>Union[dict, Mapping]</code>, defaults to <code>None</code>) &#x2014;
Optional metadata for the schema (if inferred).`,name:"metadata"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L765",returnDescription:`
<p><code>datasets.table.Table</code></p>
`}}),ho=new f({props:{name:"from_pydict",anchor:"datasets.table.InMemoryTable.from_pydict",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.from_pydict.mapping",description:`<strong>mapping</strong> (<code>Union[dict, Mapping]</code>) &#x2014;
A mapping of strings to Arrays or Python lists.`,name:"mapping"},{anchor:"datasets.table.InMemoryTable.from_pydict.schema",description:`<strong>schema</strong> (<code>Schema</code>, defaults to <code>None</code>) &#x2014;
If not passed, will be inferred from the Mapping values`,name:"schema"},{anchor:"datasets.table.InMemoryTable.from_pydict.metadata",description:`<strong>metadata</strong> (<code>Union[dict, Mapping]</code>, defaults to <code>None</code>) &#x2014;
Optional metadata for the schema (if inferred).`,name:"metadata"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L785",returnDescription:`
<p><code>datasets.table.Table</code></p>
`}}),uo=new f({props:{name:"from_batches",anchor:"datasets.table.InMemoryTable.from_batches",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.InMemoryTable.from_batches.batches",description:`<strong>batches</strong> (<code>Union[Sequence[pyarrow.RecordBatch], Iterator[pyarrow.RecordBatch]]</code>) &#x2014;
Sequence of <code>RecordBatch</code> to be converted, all schemas must be equal.`,name:"batches"},{anchor:"datasets.table.InMemoryTable.from_batches.schema",description:`<strong>schema</strong> (<code>Schema</code>, defaults to <code>None</code>) &#x2014;
If not passed, will be inferred from the first <code>RecordBatch</code>.`,name:"schema"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L825",returnType:`
<p><code>datasets.table.Table</code></p>
`}}),fo=new Cn({}),yo=new f({props:{name:"class datasets.table.MemoryMappedTable",anchor:"datasets.table.MemoryMappedTable",parameters:[{name:"table",val:": Table"},{name:"path",val:": str"},{name:"replays",val:": typing.Union[typing.List[typing.Tuple[str, tuple, dict]], NoneType] = None"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1037"}}),$o=new f({props:{name:"validate",anchor:"datasets.table.MemoryMappedTable.validate",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.MemoryMappedTable.validate.full",description:`<strong>full</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
If <code>True</code>, run expensive checks, otherwise cheap checks only.`,name:"full"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L216",raiseDescription:`
<ul>
<li><code>pa.lib.ArrowInvalid</code> \u2014 if validation fails</li>
</ul>
`,raiseType:`
<p><code>pa.lib.ArrowInvalid</code></p>
`}}),_o=new f({props:{name:"equals",anchor:"datasets.table.MemoryMappedTable.equals",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.MemoryMappedTable.equals.other",description:`<strong>other</strong> (<a href="/docs/datasets/v2.8.0/en/package_reference/table_classes#datasets.table.Table">Table</a>) &#x2014;
Table to compare against.`,name:"other"},{anchor:"datasets.table.MemoryMappedTable.equals.check_metadata",description:`<strong>check_metadata</strong> <code>bool</code>, defaults to <code>False</code>) &#x2014;
Whether schema metadata equality should be checked as well.`,name:"check_metadata"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L232",returnType:`
<p><code>bool</code></p>
`}}),wo=new f({props:{name:"to_batches",anchor:"datasets.table.MemoryMappedTable.to_batches",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.MemoryMappedTable.to_batches.max_chunksize",description:`<strong>max_chunksize</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Maximum size for <code>RecordBatch</code> chunks. Individual chunks may be
smaller depending on the chunk layout of individual columns.`,name:"max_chunksize"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L249",returnDescription:`
<p><code>List[pyarrow.RecordBatch]</code></p>
`}}),Eo=new f({props:{name:"to_pydict",anchor:"datasets.table.MemoryMappedTable.to_pydict",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L263",returnType:`
<p><code>dict</code></p>
`}}),xo=new f({props:{name:"to_pandas",anchor:"datasets.table.MemoryMappedTable.to_pandas",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.MemoryMappedTable.to_pandas.memory_pool",description:`<strong>memory_pool</strong> (<code>MemoryPool</code>, defaults to <code>None</code>) &#x2014;
Arrow MemoryPool to use for allocations. Uses the default memory
pool is not passed.`,name:"memory_pool"},{anchor:"datasets.table.MemoryMappedTable.to_pandas.strings_to_categorical",description:`<strong>strings_to_categorical</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Encode string (UTF8) and binary types to <code>pandas.Categorical</code>.`,name:"strings_to_categorical"},{anchor:"datasets.table.MemoryMappedTable.to_pandas.categories",description:`<strong>categories</strong> (<code>list</code>, defaults to <code>empty</code>) &#x2014;
List of fields that should be returned as <code>pandas.Categorical</code>. Only
applies to table-like data structures.`,name:"categories"},{anchor:"datasets.table.MemoryMappedTable.to_pandas.zero_copy_only",description:`<strong>zero_copy_only</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Raise an <code>ArrowException</code> if this function call would require copying
the underlying data.`,name:"zero_copy_only"},{anchor:"datasets.table.MemoryMappedTable.to_pandas.integer_object_nulls",description:`<strong>integer_object_nulls</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Cast integers with nulls to objects.`,name:"integer_object_nulls"},{anchor:"datasets.table.MemoryMappedTable.to_pandas.date_as_object",description:`<strong>date_as_object</strong> (<code>bool</code>, defaults to <code>True</code>) &#x2014;
Cast dates to objects. If <code>False</code>, convert to <code>datetime64[ns]</code> dtype.`,name:"date_as_object"},{anchor:"datasets.table.MemoryMappedTable.to_pandas.timestamp_as_object",description:`<strong>timestamp_as_object</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Cast non-nanosecond timestamps (<code>np.datetime64</code>) to objects. This is
useful if you have timestamps that don&#x2019;t fit in the normal date
range of nanosecond timestamps (1678 CE-2262 CE).
If <code>False</code>, all timestamps are converted to <code>datetime64[ns]</code> dtype.`,name:"timestamp_as_object"},{anchor:"datasets.table.MemoryMappedTable.to_pandas.use_threads",description:`<strong>use_threads</strong> (<code>bool</code>, defaults to <code>True</code>) &#x2014;
Whether to parallelize the conversion using multiple threads.`,name:"use_threads"},{anchor:"datasets.table.MemoryMappedTable.to_pandas.deduplicate_objects",description:`<strong>deduplicate_objects</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Do not create multiple copies Python objects when created, to save
on memory use. Conversion will be slower.`,name:"deduplicate_objects"},{anchor:"datasets.table.MemoryMappedTable.to_pandas.ignore_metadata",description:`<strong>ignore_metadata</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
If <code>True</code>, do not use the &#x2018;pandas&#x2019; metadata to reconstruct the
DataFrame index, if present.`,name:"ignore_metadata"},{anchor:"datasets.table.MemoryMappedTable.to_pandas.safe",description:`<strong>safe</strong> (<code>bool</code>, defaults to <code>True</code>) &#x2014;
For certain data types, a cast is needed in order to store the
data in a pandas DataFrame or Series (e.g. timestamps are always
stored as nanoseconds in pandas). This option controls whether it
is a safe cast or not.`,name:"safe"},{anchor:"datasets.table.MemoryMappedTable.to_pandas.split_blocks",description:`<strong>split_blocks</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
If <code>True</code>, generate one internal &#x201C;block&#x201D; for each column when
creating a pandas.DataFrame from a <code>RecordBatch</code> or <code>Table</code>. While this
can temporarily reduce memory note that various pandas operations
can trigger &#x201C;consolidation&#x201D; which may balloon memory use.`,name:"split_blocks"},{anchor:"datasets.table.MemoryMappedTable.to_pandas.self_destruct",description:`<strong>self_destruct</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
EXPERIMENTAL: If <code>True</code>, attempt to deallocate the originating Arrow
memory while converting the Arrow object to pandas. If you use the
object after calling <code>to_pandas</code> with this option it will crash your
program.`,name:"self_destruct"},{anchor:"datasets.table.MemoryMappedTable.to_pandas.types_mapper",description:`<strong>types_mapper</strong> (<code>function</code>, defaults to <code>None</code>) &#x2014;
A function mapping a pyarrow DataType to a pandas <code>ExtensionDtype</code>.
This can be used to override the default pandas type for conversion
of built-in pyarrow types or in absence of <code>pandas_metadata</code> in the
Table schema. The function receives a pyarrow DataType and is
expected to return a pandas <code>ExtensionDtype</code> or <code>None</code> if the
default conversion should be used for that type. If you have
a dictionary mapping, you can pass <code>dict.get</code> as function.`,name:"types_mapper"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L285",returnDescription:`
<p><code>pandas.Series</code> or <code>pandas.DataFrame</code> depending on type of object</p>
`,returnType:`
<p><code>pandas.Series</code> or <code>pandas.DataFrame</code></p>
`}}),Do=new f({props:{name:"to_string",anchor:"datasets.table.MemoryMappedTable.to_string",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L347"}}),ko=new f({props:{name:"field",anchor:"datasets.table.MemoryMappedTable.field",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.MemoryMappedTable.field.i",description:`<strong>i</strong> (<code>Union[int, str]</code>) &#x2014;
The index or name of the field to retrieve.`,name:"i"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L368",returnDescription:`
<p><code>pyarrow.Field</code></p>
`}}),Io=new f({props:{name:"column",anchor:"datasets.table.MemoryMappedTable.column",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.MemoryMappedTable.column.i",description:`<strong>i</strong> (<code>Union[int, str]</code>) &#x2014;
The index or name of the column to retrieve.`,name:"i"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L381",returnDescription:`
<p><code>pyarrow.ChunkedArray</code></p>
`}}),Mo=new f({props:{name:"itercolumns",anchor:"datasets.table.MemoryMappedTable.itercolumns",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L394"}}),Co=new f({props:{name:"schema",anchor:"datasets.table.MemoryMappedTable.schema",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L403",returnDescription:`
<p><code>pyarrow.Schema</code></p>
`}}),Po=new f({props:{name:"columns",anchor:"datasets.table.MemoryMappedTable.columns",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L413",returnDescription:`
<p><code>List[pa.ChunkedArray]</code></p>
`}}),Lo=new f({props:{name:"num_columns",anchor:"datasets.table.MemoryMappedTable.num_columns",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L423",returnDescription:`
<p>int</p>
`}}),Ao=new f({props:{name:"num_rows",anchor:"datasets.table.MemoryMappedTable.num_rows",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L433",returnDescription:`
<p>int</p>
`}}),No=new f({props:{name:"shape",anchor:"datasets.table.MemoryMappedTable.shape",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L446",returnDescription:`
<p>Number of rows and number of columns.</p>
`,returnType:`
<p><code>(int, int)</code></p>
`}}),jo=new f({props:{name:"nbytes",anchor:"datasets.table.MemoryMappedTable.nbytes",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L456"}}),Fo=new f({props:{name:"column_names",anchor:"datasets.table.MemoryMappedTable.column_names",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L463"}}),Vo=new f({props:{name:"slice",anchor:"datasets.table.MemoryMappedTable.slice",parameters:[{name:"offset",val:" = 0"},{name:"length",val:" = None"}],parametersDescription:[{anchor:"datasets.table.MemoryMappedTable.slice.offset",description:`<strong>offset</strong> (<code>int</code>, defaults to <code>0</code>) &#x2014;
Offset from start of table to slice.`,name:"offset"},{anchor:"datasets.table.MemoryMappedTable.slice.length",description:`<strong>length</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Length of slice (default is until end of table starting from
offset).`,name:"length"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1096",returnDescription:`
<p><code>datasets.table.Table</code></p>
`}}),So=new f({props:{name:"filter",anchor:"datasets.table.MemoryMappedTable.filter",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1115"}}),Ro=new f({props:{name:"flatten",anchor:"datasets.table.MemoryMappedTable.flatten",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.MemoryMappedTable.flatten.memory_pool",description:`<strong>memory_pool</strong> (<code>MemoryPool</code>, defaults to <code>None</code>) &#x2014;
For memory allocations, if required, otherwise use default pool.`,name:"memory_pool"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1123",returnDescription:`
<p><code>datasets.table.Table</code></p>
`}}),qo=new f({props:{name:"combine_chunks",anchor:"datasets.table.MemoryMappedTable.combine_chunks",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.MemoryMappedTable.combine_chunks.memory_pool",description:`<strong>memory_pool</strong> (<code>MemoryPool</code>, defaults to <code>None</code>) &#x2014;
For memory allocations, if required, otherwise use default pool.`,name:"memory_pool"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1139",returnDescription:`
<p><code>datasets.table.Table</code></p>
`}}),Uo=new f({props:{name:"cast",anchor:"datasets.table.MemoryMappedTable.cast",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.MemoryMappedTable.cast.target_schema",description:`<strong>target_schema</strong> (<code>Schema</code>) &#x2014;
Schema to cast to, the names and order of fields must match.`,name:"target_schema"},{anchor:"datasets.table.MemoryMappedTable.cast.safe",description:`<strong>safe</strong> (<code>bool</code>, defaults to <code>True</code>) &#x2014;
Check for overflows or other unsafe conversions.`,name:"safe"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1157",returnDescription:`
<p><code>datasets.table.Table</code></p>
`}}),zo=new f({props:{name:"replace_schema_metadata",anchor:"datasets.table.MemoryMappedTable.replace_schema_metadata",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.MemoryMappedTable.replace_schema_metadata.metadata",description:"<strong>metadata</strong> (<code>dict</code>, defaults to <code>None</code>) &#x2014;",name:"metadata"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1174",returnDescription:`
<p>shallow_copy</p>
`,returnType:`
<p><code>datasets.table.Table</code></p>
`}}),Bo=new f({props:{name:"add_column",anchor:"datasets.table.MemoryMappedTable.add_column",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.MemoryMappedTable.add_column.i",description:`<strong>i</strong> (<code>int</code>) &#x2014;
Index to place the column at.`,name:"i"},{anchor:"datasets.table.MemoryMappedTable.add_column.field_",description:`<strong>field_</strong> (<code>Union[str, pyarrow.Field]</code>) &#x2014;
If a string is passed then the type is deduced from the column
data.`,name:"field_"},{anchor:"datasets.table.MemoryMappedTable.add_column.column",description:`<strong>column</strong> (<code>Union[pyarrow.Array, List[pyarrow.Array]]</code>) &#x2014;
Column data.`,name:"column"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1190",returnDescription:`
<p>New table with the passed column added.</p>
`,returnType:`
<p><code>datasets.table.Table</code></p>
`}}),Wo=new f({props:{name:"append_column",anchor:"datasets.table.MemoryMappedTable.append_column",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.MemoryMappedTable.append_column.field_",description:`<strong>field_</strong> (<code>Union[str, pyarrow.Field]</code>) &#x2014;
If a string is passed then the type is deduced from the column
data.`,name:"field_"},{anchor:"datasets.table.MemoryMappedTable.append_column.column",description:`<strong>column</strong> (<code>Union[pyarrow.Array, List[pyarrow.Array]]</code>) &#x2014;
Column data.`,name:"column"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1213",returnDescription:`
<p>New table with the passed column added.</p>
`,returnType:`
<p><code>datasets.table.Table</code></p>
`}}),Xo=new f({props:{name:"remove_column",anchor:"datasets.table.MemoryMappedTable.remove_column",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.MemoryMappedTable.remove_column.i",description:`<strong>i</strong> (<code>int</code>) &#x2014;
Index of column to remove.`,name:"i"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1232",returnDescription:`
<p>New table without the column.</p>
`,returnType:`
<p><code>datasets.table.Table</code></p>
`}}),Ho=new f({props:{name:"set_column",anchor:"datasets.table.MemoryMappedTable.set_column",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.MemoryMappedTable.set_column.i",description:`<strong>i</strong> (<code>int</code>) &#x2014;
Index to place the column at.`,name:"i"},{anchor:"datasets.table.MemoryMappedTable.set_column.field_",description:`<strong>field_</strong> (<code>Union[str, pyarrow.Field]</code>) &#x2014;
If a string is passed then the type is deduced from the column
data.`,name:"field_"},{anchor:"datasets.table.MemoryMappedTable.set_column.column",description:`<strong>column</strong> (<code>Union[pyarrow.Array, List[pyarrow.Array]]</code>) &#x2014;
Column data.`,name:"column"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1248",returnDescription:`
<p>New table with the passed column set.</p>
`,returnType:`
<p><code>datasets.table.Table</code></p>
`}}),Ko=new f({props:{name:"rename_columns",anchor:"datasets.table.MemoryMappedTable.rename_columns",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1269"}}),Go=new f({props:{name:"select",anchor:"datasets.table.MemoryMappedTable.select",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.MemoryMappedTable.select.columns",description:`<strong>columns</strong> (<code>Union[List[str], List[int]]</code>) &#x2014;
The column names or integer indices to select.`,name:"columns"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1296",returnDescription:`
<p>New table with the specified columns, and metadata preserved.</p>
`,returnType:`
<p><a
  href="/docs/datasets/v2.8.0/en/package_reference/table_classes#datasets.table.Table"
>datasets.table.Table</a></p>
`}}),Yo=new f({props:{name:"drop",anchor:"datasets.table.MemoryMappedTable.drop",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.MemoryMappedTable.drop.columns",description:`<strong>columns</strong> (<code>List[str]</code>) &#x2014;
List of field names referencing existing columns.`,name:"columns"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1277",returnDescription:`
<p>New table without the columns.</p>
`,returnType:`
<p><code>datasets.table.Table</code></p>
`,raiseDescription:`
<ul>
<li><code>KeyError</code> \u2014 : if any of the passed columns name are not existing.</li>
</ul>
`,raiseType:`
<p><code>KeyError</code></p>
`}}),Jo=new f({props:{name:"from_file",anchor:"datasets.table.MemoryMappedTable.from_file",parameters:[{name:"filename",val:": str"},{name:"replays",val:" = None"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1063"}}),Qo=new Cn({}),Zo=new f({props:{name:"class datasets.table.ConcatenationTable",anchor:"datasets.table.ConcatenationTable",parameters:[{name:"table",val:": Table"},{name:"blocks",val:": typing.List[typing.List[datasets.table.TableBlock]]"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1321"}}),rr=new f({props:{name:"validate",anchor:"datasets.table.ConcatenationTable.validate",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.ConcatenationTable.validate.full",description:`<strong>full</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
If <code>True</code>, run expensive checks, otherwise cheap checks only.`,name:"full"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L216",raiseDescription:`
<ul>
<li><code>pa.lib.ArrowInvalid</code> \u2014 if validation fails</li>
</ul>
`,raiseType:`
<p><code>pa.lib.ArrowInvalid</code></p>
`}}),nr=new f({props:{name:"equals",anchor:"datasets.table.ConcatenationTable.equals",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.ConcatenationTable.equals.other",description:`<strong>other</strong> (<a href="/docs/datasets/v2.8.0/en/package_reference/table_classes#datasets.table.Table">Table</a>) &#x2014;
Table to compare against.`,name:"other"},{anchor:"datasets.table.ConcatenationTable.equals.check_metadata",description:`<strong>check_metadata</strong> <code>bool</code>, defaults to <code>False</code>) &#x2014;
Whether schema metadata equality should be checked as well.`,name:"check_metadata"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L232",returnType:`
<p><code>bool</code></p>
`}}),sr=new f({props:{name:"to_batches",anchor:"datasets.table.ConcatenationTable.to_batches",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.ConcatenationTable.to_batches.max_chunksize",description:`<strong>max_chunksize</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Maximum size for <code>RecordBatch</code> chunks. Individual chunks may be
smaller depending on the chunk layout of individual columns.`,name:"max_chunksize"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L249",returnDescription:`
<p><code>List[pyarrow.RecordBatch]</code></p>
`}}),dr=new f({props:{name:"to_pydict",anchor:"datasets.table.ConcatenationTable.to_pydict",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L263",returnType:`
<p><code>dict</code></p>
`}}),cr=new f({props:{name:"to_pandas",anchor:"datasets.table.ConcatenationTable.to_pandas",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.ConcatenationTable.to_pandas.memory_pool",description:`<strong>memory_pool</strong> (<code>MemoryPool</code>, defaults to <code>None</code>) &#x2014;
Arrow MemoryPool to use for allocations. Uses the default memory
pool is not passed.`,name:"memory_pool"},{anchor:"datasets.table.ConcatenationTable.to_pandas.strings_to_categorical",description:`<strong>strings_to_categorical</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Encode string (UTF8) and binary types to <code>pandas.Categorical</code>.`,name:"strings_to_categorical"},{anchor:"datasets.table.ConcatenationTable.to_pandas.categories",description:`<strong>categories</strong> (<code>list</code>, defaults to <code>empty</code>) &#x2014;
List of fields that should be returned as <code>pandas.Categorical</code>. Only
applies to table-like data structures.`,name:"categories"},{anchor:"datasets.table.ConcatenationTable.to_pandas.zero_copy_only",description:`<strong>zero_copy_only</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Raise an <code>ArrowException</code> if this function call would require copying
the underlying data.`,name:"zero_copy_only"},{anchor:"datasets.table.ConcatenationTable.to_pandas.integer_object_nulls",description:`<strong>integer_object_nulls</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Cast integers with nulls to objects.`,name:"integer_object_nulls"},{anchor:"datasets.table.ConcatenationTable.to_pandas.date_as_object",description:`<strong>date_as_object</strong> (<code>bool</code>, defaults to <code>True</code>) &#x2014;
Cast dates to objects. If <code>False</code>, convert to <code>datetime64[ns]</code> dtype.`,name:"date_as_object"},{anchor:"datasets.table.ConcatenationTable.to_pandas.timestamp_as_object",description:`<strong>timestamp_as_object</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Cast non-nanosecond timestamps (<code>np.datetime64</code>) to objects. This is
useful if you have timestamps that don&#x2019;t fit in the normal date
range of nanosecond timestamps (1678 CE-2262 CE).
If <code>False</code>, all timestamps are converted to <code>datetime64[ns]</code> dtype.`,name:"timestamp_as_object"},{anchor:"datasets.table.ConcatenationTable.to_pandas.use_threads",description:`<strong>use_threads</strong> (<code>bool</code>, defaults to <code>True</code>) &#x2014;
Whether to parallelize the conversion using multiple threads.`,name:"use_threads"},{anchor:"datasets.table.ConcatenationTable.to_pandas.deduplicate_objects",description:`<strong>deduplicate_objects</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Do not create multiple copies Python objects when created, to save
on memory use. Conversion will be slower.`,name:"deduplicate_objects"},{anchor:"datasets.table.ConcatenationTable.to_pandas.ignore_metadata",description:`<strong>ignore_metadata</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
If <code>True</code>, do not use the &#x2018;pandas&#x2019; metadata to reconstruct the
DataFrame index, if present.`,name:"ignore_metadata"},{anchor:"datasets.table.ConcatenationTable.to_pandas.safe",description:`<strong>safe</strong> (<code>bool</code>, defaults to <code>True</code>) &#x2014;
For certain data types, a cast is needed in order to store the
data in a pandas DataFrame or Series (e.g. timestamps are always
stored as nanoseconds in pandas). This option controls whether it
is a safe cast or not.`,name:"safe"},{anchor:"datasets.table.ConcatenationTable.to_pandas.split_blocks",description:`<strong>split_blocks</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
If <code>True</code>, generate one internal &#x201C;block&#x201D; for each column when
creating a pandas.DataFrame from a <code>RecordBatch</code> or <code>Table</code>. While this
can temporarily reduce memory note that various pandas operations
can trigger &#x201C;consolidation&#x201D; which may balloon memory use.`,name:"split_blocks"},{anchor:"datasets.table.ConcatenationTable.to_pandas.self_destruct",description:`<strong>self_destruct</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
EXPERIMENTAL: If <code>True</code>, attempt to deallocate the originating Arrow
memory while converting the Arrow object to pandas. If you use the
object after calling <code>to_pandas</code> with this option it will crash your
program.`,name:"self_destruct"},{anchor:"datasets.table.ConcatenationTable.to_pandas.types_mapper",description:`<strong>types_mapper</strong> (<code>function</code>, defaults to <code>None</code>) &#x2014;
A function mapping a pyarrow DataType to a pandas <code>ExtensionDtype</code>.
This can be used to override the default pandas type for conversion
of built-in pyarrow types or in absence of <code>pandas_metadata</code> in the
Table schema. The function receives a pyarrow DataType and is
expected to return a pandas <code>ExtensionDtype</code> or <code>None</code> if the
default conversion should be used for that type. If you have
a dictionary mapping, you can pass <code>dict.get</code> as function.`,name:"types_mapper"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L285",returnDescription:`
<p><code>pandas.Series</code> or <code>pandas.DataFrame</code> depending on type of object</p>
`,returnType:`
<p><code>pandas.Series</code> or <code>pandas.DataFrame</code></p>
`}}),ir=new f({props:{name:"to_string",anchor:"datasets.table.ConcatenationTable.to_string",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L347"}}),pr=new f({props:{name:"field",anchor:"datasets.table.ConcatenationTable.field",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.ConcatenationTable.field.i",description:`<strong>i</strong> (<code>Union[int, str]</code>) &#x2014;
The index or name of the field to retrieve.`,name:"i"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L368",returnDescription:`
<p><code>pyarrow.Field</code></p>
`}}),mr=new f({props:{name:"column",anchor:"datasets.table.ConcatenationTable.column",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.ConcatenationTable.column.i",description:`<strong>i</strong> (<code>Union[int, str]</code>) &#x2014;
The index or name of the column to retrieve.`,name:"i"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L381",returnDescription:`
<p><code>pyarrow.ChunkedArray</code></p>
`}}),br=new f({props:{name:"itercolumns",anchor:"datasets.table.ConcatenationTable.itercolumns",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L394"}}),hr=new f({props:{name:"schema",anchor:"datasets.table.ConcatenationTable.schema",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L403",returnDescription:`
<p><code>pyarrow.Schema</code></p>
`}}),ur=new f({props:{name:"columns",anchor:"datasets.table.ConcatenationTable.columns",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L413",returnDescription:`
<p><code>List[pa.ChunkedArray]</code></p>
`}}),gr=new f({props:{name:"num_columns",anchor:"datasets.table.ConcatenationTable.num_columns",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L423",returnDescription:`
<p>int</p>
`}}),fr=new f({props:{name:"num_rows",anchor:"datasets.table.ConcatenationTable.num_rows",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L433",returnDescription:`
<p>int</p>
`}}),yr=new f({props:{name:"shape",anchor:"datasets.table.ConcatenationTable.shape",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L446",returnDescription:`
<p>Number of rows and number of columns.</p>
`,returnType:`
<p><code>(int, int)</code></p>
`}}),vr=new f({props:{name:"nbytes",anchor:"datasets.table.ConcatenationTable.nbytes",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L456"}}),$r=new f({props:{name:"column_names",anchor:"datasets.table.ConcatenationTable.column_names",parameters:[],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L463"}}),_r=new f({props:{name:"slice",anchor:"datasets.table.ConcatenationTable.slice",parameters:[{name:"offset",val:" = 0"},{name:"length",val:" = None"}],parametersDescription:[{anchor:"datasets.table.ConcatenationTable.slice.offset",description:`<strong>offset</strong> (<code>int</code>, defaults to <code>0</code>) &#x2014;
Offset from start of table to slice.`,name:"offset"},{anchor:"datasets.table.ConcatenationTable.slice.length",description:`<strong>length</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Length of slice (default is until end of table starting from
offset).`,name:"length"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1494",returnDescription:`
<p><code>datasets.table.Table</code></p>
`}}),wr=new f({props:{name:"filter",anchor:"datasets.table.ConcatenationTable.filter",parameters:[{name:"mask",val:""},{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1525"}}),Er=new f({props:{name:"flatten",anchor:"datasets.table.ConcatenationTable.flatten",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.ConcatenationTable.flatten.memory_pool",description:`<strong>memory_pool</strong> (<code>MemoryPool</code>, defaults to <code>None</code>) &#x2014;
For memory allocations, if required, otherwise use default pool.`,name:"memory_pool"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1536",returnDescription:`
<p><code>datasets.table.Table</code></p>
`}}),xr=new f({props:{name:"combine_chunks",anchor:"datasets.table.ConcatenationTable.combine_chunks",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.ConcatenationTable.combine_chunks.memory_pool",description:`<strong>memory_pool</strong> (<code>MemoryPool</code>, defaults to <code>None</code>) &#x2014;
For memory allocations, if required, otherwise use default pool.`,name:"memory_pool"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1554",returnDescription:`
<p><code>datasets.table.Table</code></p>
`}}),kr=new f({props:{name:"cast",anchor:"datasets.table.ConcatenationTable.cast",parameters:[{name:"target_schema",val:""},{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.ConcatenationTable.cast.target_schema",description:`<strong>target_schema</strong> (<code>Schema</code>) &#x2014;
Schema to cast to, the names and order of fields must match.`,name:"target_schema"},{anchor:"datasets.table.ConcatenationTable.cast.safe",description:`<strong>safe</strong> (<code>bool</code>, defaults to <code>True</code>) &#x2014;
Check for overflows or other unsafe conversions.`,name:"safe"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1574",returnDescription:`
<p><code>datasets.table.Table</code></p>
`}}),Ir=new f({props:{name:"replace_schema_metadata",anchor:"datasets.table.ConcatenationTable.replace_schema_metadata",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.ConcatenationTable.replace_schema_metadata.metadata",description:"<strong>metadata</strong> (<code>dict</code>, defaults to <code>None</code>) &#x2014;",name:"metadata"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1605",returnDescription:`
<p>shallow_copy</p>
`,returnType:`
<p><code>datasets.table.Table</code></p>
`}}),Cr=new f({props:{name:"add_column",anchor:"datasets.table.ConcatenationTable.add_column",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.ConcatenationTable.add_column.i",description:`<strong>i</strong> (<code>int</code>) &#x2014;
Index to place the column at.`,name:"i"},{anchor:"datasets.table.ConcatenationTable.add_column.field_",description:`<strong>field_</strong> (<code>Union[str, pyarrow.Field]</code>) &#x2014;
If a string is passed then the type is deduced from the column
data.`,name:"field_"},{anchor:"datasets.table.ConcatenationTable.add_column.column",description:`<strong>column</strong> (<code>Union[pyarrow.Array, List[pyarrow.Array]]</code>) &#x2014;
Column data.`,name:"column"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1623",returnDescription:`
<p>New table with the passed column added.</p>
`,returnType:`
<p><code>datasets.table.Table</code></p>
`}}),Pr=new f({props:{name:"append_column",anchor:"datasets.table.ConcatenationTable.append_column",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.ConcatenationTable.append_column.field_",description:`<strong>field_</strong> (<code>Union[str, pyarrow.Field]</code>) &#x2014;
If a string is passed then the type is deduced from the column
data.`,name:"field_"},{anchor:"datasets.table.ConcatenationTable.append_column.column",description:`<strong>column</strong> (<code>Union[pyarrow.Array, List[pyarrow.Array]]</code>) &#x2014;
Column data.`,name:"column"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1644",returnDescription:`
<p>New table with the passed column added.</p>
`,returnType:`
<p><code>datasets.table.Table</code></p>
`}}),Lr=new f({props:{name:"remove_column",anchor:"datasets.table.ConcatenationTable.remove_column",parameters:[{name:"i",val:""},{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.ConcatenationTable.remove_column.i",description:`<strong>i</strong> (<code>int</code>) &#x2014;
Index of column to remove.`,name:"i"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1661",returnDescription:`
<p>New table without the column.</p>
`,returnType:`
<p><code>datasets.table.Table</code></p>
`}}),Ar=new f({props:{name:"set_column",anchor:"datasets.table.ConcatenationTable.set_column",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.ConcatenationTable.set_column.i",description:`<strong>i</strong> (<code>int</code>) &#x2014;
Index to place the column at.`,name:"i"},{anchor:"datasets.table.ConcatenationTable.set_column.field_",description:`<strong>field_</strong> (<code>Union[str, pyarrow.Field]</code>) &#x2014;
If a string is passed then the type is deduced from the column
data.`,name:"field_"},{anchor:"datasets.table.ConcatenationTable.set_column.column",description:`<strong>column</strong> (<code>Union[pyarrow.Array, List[pyarrow.Array]]</code>) &#x2014;
Column data.`,name:"column"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1685",returnDescription:`
<p>New table with the passed column set.</p>
`,returnType:`
<p><code>datasets.table.Table</code></p>
`}}),Nr=new f({props:{name:"rename_columns",anchor:"datasets.table.ConcatenationTable.rename_columns",parameters:[{name:"names",val:""},{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1704"}}),jr=new f({props:{name:"select",anchor:"datasets.table.ConcatenationTable.select",parameters:[{name:"columns",val:""},{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.ConcatenationTable.select.columns",description:`<strong>columns</strong> (<code>Union[List[str], List[int]]</code>) &#x2014;
The column names or integer indices to select.`,name:"columns"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1738",returnDescription:`
<p>New table with the specified columns, and metadata preserved.</p>
`,returnType:`
<p><a
  href="/docs/datasets/v2.8.0/en/package_reference/table_classes#datasets.table.Table"
>datasets.table.Table</a></p>
`}}),Fr=new f({props:{name:"drop",anchor:"datasets.table.ConcatenationTable.drop",parameters:[{name:"columns",val:""},{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"datasets.table.ConcatenationTable.drop.columns",description:`<strong>columns</strong> (<code>List[str]</code>) &#x2014;
List of field names referencing existing columns.`,name:"columns"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1717",returnDescription:`
<p>New table without the columns.</p>
`,returnType:`
<p><code>datasets.table.Table</code></p>
`,raiseDescription:`
<ul>
<li><code>KeyError</code> \u2014 : if any of the passed columns name are not existing.</li>
</ul>
`,raiseType:`
<p><code>KeyError</code></p>
`}}),Vr=new f({props:{name:"from_blocks",anchor:"datasets.table.ConcatenationTable.from_blocks",parameters:[{name:"blocks",val:": TableBlockContainer"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1420"}}),Sr=new f({props:{name:"from_tables",anchor:"datasets.table.ConcatenationTable.from_tables",parameters:[{name:"tables",val:": typing.List[typing.Union[pyarrow.lib.Table, datasets.table.Table]]"},{name:"axis",val:": int = 0"}],parametersDescription:[{anchor:"datasets.table.ConcatenationTable.from_tables.tables",description:`<strong>tables</strong> (list of <code>Table</code> or list of <code>pyarrow.Table</code>) &#x2014;
List of tables.`,name:"tables"},{anchor:"datasets.table.ConcatenationTable.from_tables.axis",description:`<strong>axis</strong> (<code>{0, 1}</code>, defaults to <code>0</code>, meaning over rows) &#x2014;
Axis to concatenate over, where <code>0</code> means over rows (vertically) and <code>1</code> means over columns
(horizontally).</p>
<div class="course-tip  bg-gradient-to-br dark:bg-gradient-to-r before:border-green-500 dark:before:border-green-800 from-green-50 dark:from-gray-900 to-white dark:to-gray-950 border border-green-50 text-green-700 dark:text-gray-400">
						<p class="font-medium">Added in 1.6.0</p>
						
					</div>`,name:"axis"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1434"}}),Rr=new Cn({}),qr=new f({props:{name:"datasets.table.concat_tables",anchor:"datasets.table.concat_tables",parameters:[{name:"tables",val:": typing.List[datasets.table.Table]"},{name:"axis",val:": int = 0"}],parametersDescription:[{anchor:"datasets.table.concat_tables.tables",description:`<strong>tables</strong> (list of <code>Table</code>) &#x2014;
List of tables to be concatenated.`,name:"tables"},{anchor:"datasets.table.concat_tables.axis",description:`<strong>axis</strong> (<code>{0, 1}</code>, defaults to <code>0</code>, meaning over rows) &#x2014;
Axis to concatenate over, where <code>0</code> means over rows (vertically) and <code>1</code> means over columns
(horizontally).</p>
<div class="course-tip  bg-gradient-to-br dark:bg-gradient-to-r before:border-green-500 dark:before:border-green-800 from-green-50 dark:from-gray-900 to-white dark:to-gray-950 border border-green-50 text-green-700 dark:text-gray-400">
						<p class="font-medium">Added in 1.6.0</p>
						
					</div>`,name:"axis"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1758",returnDescription:`
<p>If the number of input tables is > 1, then the returned table is a <code>datasets.table.ConcatenationTable</code>.
Otherwise if there\u2019s only one table, it is returned as is.</p>
`,returnType:`
<p><code>datasets.table.Table</code></p>
`}}),Ur=new f({props:{name:"datasets.table.list_table_cache_files",anchor:"datasets.table.list_table_cache_files",parameters:[{name:"table",val:": Table"}],source:"https://github.com/huggingface/datasets/blob/2.8.0/src/datasets/table.py#L1781",returnDescription:`
<p>A list of paths to the cache files loaded by the table.</p>
`,returnType:`
<p><code>List[str]</code></p>
`}}),{c(){M=a("meta"),_e=s(),P=a("h1"),C=a("a"),j=a("span"),p(I.$$.fragment),F=s(),Pn=a("span"),lp=d("Table Classes"),Wd=s(),V=a("p"),dp=d("Each "),Ln=a("code"),cp=d("Dataset"),ip=d(` object is backed by a PyArrow Table.
A Table can be loaded from either the disk (memory mapped) or in memory.
Several Table types are available, and they all inherit from `),Br=a("a"),pp=d("table.Table"),mp=d("."),Xd=s(),ae=a("h2"),we=a("a"),An=a("span"),p(ca.$$.fragment),bp=s(),Nn=a("span"),hp=d("Table"),Hd=s(),E=a("div"),p(ia.$$.fragment),up=s(),A=a("p"),gp=d(`Wraps a pyarrow Table by using composition.
This is the base class for `),jn=a("code"),fp=d("InMemoryTable"),yp=d(", "),Fn=a("code"),vp=d("MemoryMappedTable"),$p=d(" and "),Vn=a("code"),_p=d("ConcatenationTable"),wp=d("."),Tp=s(),oe=a("p"),Ep=d(`It implements all the basic attributes/methods of the pyarrow Table class except
the Table transforms: `),Sn=a("code"),xp=d("slice, filter, flatten, combine_chunks, cast, add_column, append_column, remove_column, set_column, rename_columns"),Dp=d(" and "),On=a("code"),kp=d("drop"),Ip=d("."),Mp=s(),Rn=a("p"),Cp=d("The implementation of these methods differs for the subclasses."),Pp=s(),S=a("div"),p(pa.$$.fragment),Lp=s(),qn=a("p"),Ap=d("Perform validation checks.  An exception is raised if validation fails."),Np=s(),re=a("p"),jp=d("By default only cheap validation checks are run.  Pass "),Un=a("code"),Fp=d("full=True"),Vp=d(`
for thorough validation checks (potentially `),zn=a("code"),Sp=d("O(n)"),Op=d(")."),Rp=s(),Te=a("div"),p(ma.$$.fragment),qp=s(),Bn=a("p"),Up=d("Check if contents of two tables are equal."),zp=s(),Ee=a("div"),p(ba.$$.fragment),Bp=s(),ha=a("p"),Wp=d("Convert Table to list of (contiguous) "),Wn=a("code"),Xp=d("RecordBatch"),Hp=d(" objects."),Kp=s(),xe=a("div"),p(ua.$$.fragment),Gp=s(),ne=a("p"),Yp=d("Convert the Table to a "),Xn=a("code"),Jp=d("dict"),Qp=d(" or "),Hn=a("code"),Zp=d("OrderedDict"),em=d("."),tm=s(),De=a("div"),p(ga.$$.fragment),am=s(),Kn=a("p"),om=d("Convert to a pandas-compatible NumPy array or DataFrame, as appropriate."),rm=s(),Wr=a("div"),p(fa.$$.fragment),nm=s(),ke=a("div"),p(ya.$$.fragment),sm=s(),Gn=a("p"),lm=d("Select a schema field by its column name or numeric index."),dm=s(),Ie=a("div"),p(va.$$.fragment),cm=s(),Yn=a("p"),im=d("Select a column by its column name, or numeric index."),pm=s(),Me=a("div"),p($a.$$.fragment),mm=s(),Jn=a("p"),bm=d("Iterator over all columns in their numerical order."),hm=s(),Ce=a("div"),p(_a.$$.fragment),um=s(),Qn=a("p"),gm=d("Schema of the table and its columns."),fm=s(),Pe=a("div"),p(wa.$$.fragment),ym=s(),Zn=a("p"),vm=d("List of all columns in numerical order."),$m=s(),Le=a("div"),p(Ta.$$.fragment),_m=s(),es=a("p"),wm=d("Number of columns in this table."),Tm=s(),O=a("div"),p(Ea.$$.fragment),Em=s(),ts=a("p"),xm=d("Number of rows in this table."),Dm=s(),as=a("p"),km=d(`Due to the definition of a table, all columns have the same number of
rows.`),Im=s(),Ae=a("div"),p(xa.$$.fragment),Mm=s(),os=a("p"),Cm=d("Dimensions of the table: (#rows, #columns)."),Pm=s(),Ne=a("div"),p(Da.$$.fragment),Lm=s(),rs=a("p"),Am=d("Total number of bytes consumed by the elements of the table."),Kd=s(),se=a("h2"),je=a("a"),ns=a("span"),p(ka.$$.fragment),Nm=s(),ss=a("span"),jm=d("InMemoryTable"),Gd=s(),y=a("div"),p(Ia.$$.fragment),Fm=s(),ls=a("p"),Vm=d("The table is said in-memory when it is loaded into the user\u2019s RAM."),Sm=s(),ds=a("p"),Om=d(`Pickling it does copy all the data using memory.
Its implementation is simple and uses the underlying pyarrow Table methods directly.`),Rm=s(),le=a("p"),qm=d("This is different from the "),cs=a("code"),Um=d("MemoryMapped"),zm=d(` table, for which pickling doesn\u2019t copy all the
data in memory. For a `),is=a("code"),Bm=d("MemoryMapped"),Wm=d(", unpickling instead reloads the table from the disk."),Xm=s(),Fe=a("p"),ps=a("code"),Hm=d("InMemoryTable"),Km=d(" must be used when data fit in memory, while "),ms=a("code"),Gm=d("MemoryMapped"),Ym=d(` are reserved for
data bigger than memory or when you want the memory footprint of your application to
stay low.`),Jm=s(),R=a("div"),p(Ma.$$.fragment),Qm=s(),bs=a("p"),Zm=d("Perform validation checks.  An exception is raised if validation fails."),eb=s(),de=a("p"),tb=d("By default only cheap validation checks are run.  Pass "),hs=a("code"),ab=d("full=True"),ob=d(`
for thorough validation checks (potentially `),us=a("code"),rb=d("O(n)"),nb=d(")."),sb=s(),Ve=a("div"),p(Ca.$$.fragment),lb=s(),gs=a("p"),db=d("Check if contents of two tables are equal."),cb=s(),Se=a("div"),p(Pa.$$.fragment),ib=s(),La=a("p"),pb=d("Convert Table to list of (contiguous) "),fs=a("code"),mb=d("RecordBatch"),bb=d(" objects."),hb=s(),Oe=a("div"),p(Aa.$$.fragment),ub=s(),ce=a("p"),gb=d("Convert the Table to a "),ys=a("code"),fb=d("dict"),yb=d(" or "),vs=a("code"),vb=d("OrderedDict"),$b=d("."),_b=s(),Re=a("div"),p(Na.$$.fragment),wb=s(),$s=a("p"),Tb=d("Convert to a pandas-compatible NumPy array or DataFrame, as appropriate."),Eb=s(),Xr=a("div"),p(ja.$$.fragment),xb=s(),qe=a("div"),p(Fa.$$.fragment),Db=s(),_s=a("p"),kb=d("Select a schema field by its column name or numeric index."),Ib=s(),Ue=a("div"),p(Va.$$.fragment),Mb=s(),ws=a("p"),Cb=d("Select a column by its column name, or numeric index."),Pb=s(),ze=a("div"),p(Sa.$$.fragment),Lb=s(),Ts=a("p"),Ab=d("Iterator over all columns in their numerical order."),Nb=s(),Be=a("div"),p(Oa.$$.fragment),jb=s(),Es=a("p"),Fb=d("Schema of the table and its columns."),Vb=s(),We=a("div"),p(Ra.$$.fragment),Sb=s(),xs=a("p"),Ob=d("List of all columns in numerical order."),Rb=s(),Xe=a("div"),p(qa.$$.fragment),qb=s(),Ds=a("p"),Ub=d("Number of columns in this table."),zb=s(),q=a("div"),p(Ua.$$.fragment),Bb=s(),ks=a("p"),Wb=d("Number of rows in this table."),Xb=s(),Is=a("p"),Hb=d(`Due to the definition of a table, all columns have the same number of
rows.`),Kb=s(),He=a("div"),p(za.$$.fragment),Gb=s(),Ms=a("p"),Yb=d("Dimensions of the table: (#rows, #columns)."),Jb=s(),Ke=a("div"),p(Ba.$$.fragment),Qb=s(),Cs=a("p"),Zb=d("Total number of bytes consumed by the elements of the table."),eh=s(),Ge=a("div"),p(Wa.$$.fragment),th=s(),Ps=a("p"),ah=d("Names of the table\u2019s columns."),oh=s(),Ye=a("div"),p(Xa.$$.fragment),rh=s(),Ls=a("p"),nh=d("Compute zero-copy slice of this Table."),sh=s(),Je=a("div"),p(Ha.$$.fragment),lh=s(),Ka=a("p"),dh=d("Select records from a Table. See "),As=a("code"),ch=d("pyarrow.compute.filter"),ih=d(" for full usage."),ph=s(),Qe=a("div"),p(Ga.$$.fragment),mh=s(),Ns=a("p"),bh=d(`Flatten this Table.  Each column with a struct type is flattened
into one column per struct field.  Other columns are left unchanged.`),hh=s(),U=a("div"),p(Ya.$$.fragment),uh=s(),js=a("p"),gh=d("Make a new table by combining the chunks this table has."),fh=s(),Ja=a("p"),yh=d("All the underlying chunks in the "),Fs=a("code"),vh=d("ChunkedArray"),$h=d(` of each column are
concatenated into zero or one chunk.`),_h=s(),Ze=a("div"),p(Qa.$$.fragment),wh=s(),Vs=a("p"),Th=d("Cast table values to another schema."),Eh=s(),et=a("div"),p(Za.$$.fragment),xh=s(),eo=a("p"),Dh=d(`EXPERIMENTAL: Create shallow copy of table by replacing schema
key-value metadata with the indicated new metadata (which may be `),Ss=a("code"),kh=d("None"),Ih=d(`,
which deletes any existing metadata).`),Mh=s(),z=a("div"),p(to.$$.fragment),Ch=s(),Os=a("p"),Ph=d("Add column to Table at position."),Lh=s(),Rs=a("p"),Ah=d(`A new table is returned with the column added, the original table
object is left unchanged.`),Nh=s(),tt=a("div"),p(ao.$$.fragment),jh=s(),qs=a("p"),Fh=d("Append column at end of columns."),Vh=s(),at=a("div"),p(oo.$$.fragment),Sh=s(),Us=a("p"),Oh=d("Create new Table with the indicated column removed."),Rh=s(),ot=a("div"),p(ro.$$.fragment),qh=s(),zs=a("p"),Uh=d("Replace column in Table at position."),zh=s(),rt=a("div"),p(no.$$.fragment),Bh=s(),Bs=a("p"),Wh=d("Create new table with columns renamed to provided names."),Xh=s(),B=a("div"),p(so.$$.fragment),Hh=s(),Ws=a("p"),Kh=d("Select columns of the table."),Gh=s(),Xs=a("p"),Yh=d("Returns a new table with the specified columns, and metadata preserved."),Jh=s(),nt=a("div"),p(lo.$$.fragment),Qh=s(),Hs=a("p"),Zh=d("Drop one or more columns and return a new table."),eu=s(),Hr=a("div"),p(co.$$.fragment),tu=s(),Kr=a("div"),p(io.$$.fragment),au=s(),L=a("div"),p(po.$$.fragment),ou=s(),Ks=a("p"),ru=d("Convert pandas.DataFrame to an Arrow Table."),nu=s(),mo=a("p"),su=d(`The column types in the resulting Arrow Table are inferred from the
dtypes of the pandas.Series in the DataFrame. In the case of non-object
Series, the NumPy dtype is translated to its Arrow equivalent. In the
case of `),Gs=a("code"),lu=d("object"),du=d(`, we need to guess the datatype by looking at the
Python objects in this Series.`),cu=s(),ie=a("p"),iu=d("Be aware that Series of the "),Ys=a("code"),pu=d("object"),mu=d(` dtype don\u2019t carry enough
information to always lead to a meaningful Arrow type. In the case that
we cannot infer a type, e.g. because the DataFrame is of length 0 or
the Series only contains `),Js=a("code"),bu=d("None/nan"),hu=d(` objects, the type is set to
null. This behavior can be avoided by constructing an explicit schema
and passing it to this function.`),uu=s(),p(st.$$.fragment),gu=s(),lt=a("div"),p(bo.$$.fragment),fu=s(),Qs=a("p"),yu=d("Construct a Table from Arrow arrays."),vu=s(),dt=a("div"),p(ho.$$.fragment),$u=s(),Zs=a("p"),_u=d("Construct a Table from Arrow arrays or columns."),wu=s(),ct=a("div"),p(uo.$$.fragment),Tu=s(),go=a("p"),Eu=d("Construct a Table from a sequence or iterator of Arrow "),el=a("code"),xu=d("RecordBatches"),Du=d("."),Yd=s(),pe=a("h2"),it=a("a"),tl=a("span"),p(fo.$$.fragment),ku=s(),al=a("span"),Iu=d("MemoryMappedTable"),Jd=s(),_=a("div"),p(yo.$$.fragment),Mu=s(),ol=a("p"),Cu=d(`The table is said memory mapped when it doesn\u2019t use the user\u2019s RAM but loads the data
from the disk instead.`),Pu=s(),rl=a("p"),Lu=d(`Pickling it doesn\u2019t copy the data into memory.
Instead, only the path to the memory mapped arrow file is pickled, as well as the list
of transforms to \u201Creplay\u201D when reloading the table from the disk.`),Au=s(),nl=a("p"),Nu=d(`Its implementation requires to store an history of all the transforms that were applied
to the underlying pyarrow Table, so that they can be \u201Creplayed\u201D when reloading the Table
from the disk.`),ju=s(),vo=a("p"),Fu=d("This is different from the "),sl=a("code"),Vu=d("InMemoryTable"),Su=d(` table, for which pickling does copy all the
data in memory.`),Ou=s(),pt=a("p"),ll=a("code"),Ru=d("InMemoryTable"),qu=d(" must be used when data fit in memory, while "),dl=a("code"),Uu=d("MemoryMapped"),zu=d(` are reserved for
data bigger than memory or when you want the memory footprint of your application to
stay low.`),Bu=s(),W=a("div"),p($o.$$.fragment),Wu=s(),cl=a("p"),Xu=d("Perform validation checks.  An exception is raised if validation fails."),Hu=s(),me=a("p"),Ku=d("By default only cheap validation checks are run.  Pass "),il=a("code"),Gu=d("full=True"),Yu=d(`
for thorough validation checks (potentially `),pl=a("code"),Ju=d("O(n)"),Qu=d(")."),Zu=s(),mt=a("div"),p(_o.$$.fragment),eg=s(),ml=a("p"),tg=d("Check if contents of two tables are equal."),ag=s(),bt=a("div"),p(wo.$$.fragment),og=s(),To=a("p"),rg=d("Convert Table to list of (contiguous) "),bl=a("code"),ng=d("RecordBatch"),sg=d(" objects."),lg=s(),ht=a("div"),p(Eo.$$.fragment),dg=s(),be=a("p"),cg=d("Convert the Table to a "),hl=a("code"),ig=d("dict"),pg=d(" or "),ul=a("code"),mg=d("OrderedDict"),bg=d("."),hg=s(),ut=a("div"),p(xo.$$.fragment),ug=s(),gl=a("p"),gg=d("Convert to a pandas-compatible NumPy array or DataFrame, as appropriate."),fg=s(),Gr=a("div"),p(Do.$$.fragment),yg=s(),gt=a("div"),p(ko.$$.fragment),vg=s(),fl=a("p"),$g=d("Select a schema field by its column name or numeric index."),_g=s(),ft=a("div"),p(Io.$$.fragment),wg=s(),yl=a("p"),Tg=d("Select a column by its column name, or numeric index."),Eg=s(),yt=a("div"),p(Mo.$$.fragment),xg=s(),vl=a("p"),Dg=d("Iterator over all columns in their numerical order."),kg=s(),vt=a("div"),p(Co.$$.fragment),Ig=s(),$l=a("p"),Mg=d("Schema of the table and its columns."),Cg=s(),$t=a("div"),p(Po.$$.fragment),Pg=s(),_l=a("p"),Lg=d("List of all columns in numerical order."),Ag=s(),_t=a("div"),p(Lo.$$.fragment),Ng=s(),wl=a("p"),jg=d("Number of columns in this table."),Fg=s(),X=a("div"),p(Ao.$$.fragment),Vg=s(),Tl=a("p"),Sg=d("Number of rows in this table."),Og=s(),El=a("p"),Rg=d(`Due to the definition of a table, all columns have the same number of
rows.`),qg=s(),wt=a("div"),p(No.$$.fragment),Ug=s(),xl=a("p"),zg=d("Dimensions of the table: (#rows, #columns)."),Bg=s(),Tt=a("div"),p(jo.$$.fragment),Wg=s(),Dl=a("p"),Xg=d("Total number of bytes consumed by the elements of the table."),Hg=s(),Et=a("div"),p(Fo.$$.fragment),Kg=s(),kl=a("p"),Gg=d("Names of the table\u2019s columns."),Yg=s(),xt=a("div"),p(Vo.$$.fragment),Jg=s(),Il=a("p"),Qg=d("Compute zero-copy slice of this Table."),Zg=s(),Dt=a("div"),p(So.$$.fragment),ef=s(),Oo=a("p"),tf=d("Select records from a Table. See "),Ml=a("code"),af=d("pyarrow.compute.filter"),of=d(" for full usage."),rf=s(),kt=a("div"),p(Ro.$$.fragment),nf=s(),Cl=a("p"),sf=d(`Flatten this Table.  Each column with a struct type is flattened
into one column per struct field.  Other columns are left unchanged.`),lf=s(),H=a("div"),p(qo.$$.fragment),df=s(),Pl=a("p"),cf=d("Make a new table by combining the chunks this table has."),pf=s(),Ll=a("p"),mf=d(`All the underlying chunks in the ChunkedArray of each column are
concatenated into zero or one chunk.`),bf=s(),It=a("div"),p(Uo.$$.fragment),hf=s(),Al=a("p"),uf=d("Cast table values to another schema"),gf=s(),Mt=a("div"),p(zo.$$.fragment),ff=s(),Nl=a("p"),yf=d(`EXPERIMENTAL: Create shallow copy of table by replacing schema
key-value metadata with the indicated new metadata (which may be None,
which deletes any existing metadata.`),vf=s(),K=a("div"),p(Bo.$$.fragment),$f=s(),jl=a("p"),_f=d("Add column to Table at position."),wf=s(),Fl=a("p"),Tf=d(`A new table is returned with the column added, the original table
object is left unchanged.`),Ef=s(),Ct=a("div"),p(Wo.$$.fragment),xf=s(),Vl=a("p"),Df=d("Append column at end of columns."),kf=s(),Pt=a("div"),p(Xo.$$.fragment),If=s(),Sl=a("p"),Mf=d("Create new Table with the indicated column removed."),Cf=s(),Lt=a("div"),p(Ho.$$.fragment),Pf=s(),Ol=a("p"),Lf=d("Replace column in Table at position."),Af=s(),At=a("div"),p(Ko.$$.fragment),Nf=s(),Rl=a("p"),jf=d("Create new table with columns renamed to provided names."),Ff=s(),G=a("div"),p(Go.$$.fragment),Vf=s(),ql=a("p"),Sf=d("Select columns of the table."),Of=s(),Ul=a("p"),Rf=d("Returns a new table with the specified columns, and metadata preserved."),qf=s(),Nt=a("div"),p(Yo.$$.fragment),Uf=s(),zl=a("p"),zf=d("Drop one or more columns and return a new table."),Bf=s(),Yr=a("div"),p(Jo.$$.fragment),Qd=s(),he=a("h2"),jt=a("a"),Bl=a("span"),p(Qo.$$.fragment),Wf=s(),Wl=a("span"),Xf=d("ConcatenationTable"),Zd=s(),v=a("div"),p(Zo.$$.fragment),Hf=s(),Xl=a("p"),Kf=d(`The table comes from the concatenation of several tables called blocks.
It enables concatenation on both axis 0 (append rows) and axis 1 (append columns).`),Gf=s(),N=a("p"),Yf=d("The underlying tables are called \u201Cblocks\u201D and can be either "),Hl=a("code"),Jf=d("InMemoryTable"),Qf=d(`
or `),Kl=a("code"),Zf=d("MemoryMappedTable"),ey=d(` objects.
This allows to combine tables that come from memory or that are memory mapped.
When a `),Gl=a("code"),ty=d("ConcatenationTable"),ay=d(" is pickled, then each block is pickled:"),oy=s(),er=a("ul"),tr=a("li"),ry=d("the "),Yl=a("code"),ny=d("InMemoryTable"),sy=d(" objects are pickled by copying all the data in memory."),ly=s(),Jl=a("li"),dy=d(`the MemoryMappedTable objects are pickled without copying the data into memory.
Instead, only the path to the memory mapped arrow file is pickled, as well as the list
of transforms to \u201Creplays\u201D when reloading the table from the disk.`),cy=s(),ar=a("p"),iy=d(`Its implementation requires to store each block separately.
The `),Ql=a("code"),py=d("blocks"),my=d(` attributes stores a list of list of blocks.
The first axis concatenates the tables along the axis 0 (it appends rows),
while the second axis concatenates tables along the axis 1 (it appends columns).`),by=s(),or=a("p"),hy=d(`If some columns are missing when concatenating on axis 0, they are filled with null values.
This is done using `),Zl=a("code"),uy=d("pyarrow.concat_tables(tables, promote=True)"),gy=d("."),fy=s(),ue=a("p"),yy=d("You can access the fully combined table by accessing the "),ed=a("code"),vy=d("ConcatenationTable.table"),$y=d(` attribute,
and the blocks by accessing the `),td=a("code"),_y=d("ConcatenationTable.blocks"),wy=d(" attribute."),Ty=s(),Y=a("div"),p(rr.$$.fragment),Ey=s(),ad=a("p"),xy=d("Perform validation checks.  An exception is raised if validation fails."),Dy=s(),ge=a("p"),ky=d("By default only cheap validation checks are run.  Pass "),od=a("code"),Iy=d("full=True"),My=d(`
for thorough validation checks (potentially `),rd=a("code"),Cy=d("O(n)"),Py=d(")."),Ly=s(),Ft=a("div"),p(nr.$$.fragment),Ay=s(),nd=a("p"),Ny=d("Check if contents of two tables are equal."),jy=s(),Vt=a("div"),p(sr.$$.fragment),Fy=s(),lr=a("p"),Vy=d("Convert Table to list of (contiguous) "),sd=a("code"),Sy=d("RecordBatch"),Oy=d(" objects."),Ry=s(),St=a("div"),p(dr.$$.fragment),qy=s(),fe=a("p"),Uy=d("Convert the Table to a "),ld=a("code"),zy=d("dict"),By=d(" or "),dd=a("code"),Wy=d("OrderedDict"),Xy=d("."),Hy=s(),Ot=a("div"),p(cr.$$.fragment),Ky=s(),cd=a("p"),Gy=d("Convert to a pandas-compatible NumPy array or DataFrame, as appropriate."),Yy=s(),Jr=a("div"),p(ir.$$.fragment),Jy=s(),Rt=a("div"),p(pr.$$.fragment),Qy=s(),id=a("p"),Zy=d("Select a schema field by its column name or numeric index."),ev=s(),qt=a("div"),p(mr.$$.fragment),tv=s(),pd=a("p"),av=d("Select a column by its column name, or numeric index."),ov=s(),Ut=a("div"),p(br.$$.fragment),rv=s(),md=a("p"),nv=d("Iterator over all columns in their numerical order."),sv=s(),zt=a("div"),p(hr.$$.fragment),lv=s(),bd=a("p"),dv=d("Schema of the table and its columns."),cv=s(),Bt=a("div"),p(ur.$$.fragment),iv=s(),hd=a("p"),pv=d("List of all columns in numerical order."),mv=s(),Wt=a("div"),p(gr.$$.fragment),bv=s(),ud=a("p"),hv=d("Number of columns in this table."),uv=s(),J=a("div"),p(fr.$$.fragment),gv=s(),gd=a("p"),fv=d("Number of rows in this table."),yv=s(),fd=a("p"),vv=d(`Due to the definition of a table, all columns have the same number of
rows.`),$v=s(),Xt=a("div"),p(yr.$$.fragment),_v=s(),yd=a("p"),wv=d("Dimensions of the table: (#rows, #columns)."),Tv=s(),Ht=a("div"),p(vr.$$.fragment),Ev=s(),vd=a("p"),xv=d("Total number of bytes consumed by the elements of the table."),Dv=s(),Kt=a("div"),p($r.$$.fragment),kv=s(),$d=a("p"),Iv=d("Names of the table\u2019s columns."),Mv=s(),Gt=a("div"),p(_r.$$.fragment),Cv=s(),_d=a("p"),Pv=d("Compute zero-copy slice of this Table."),Lv=s(),Yt=a("div"),p(wr.$$.fragment),Av=s(),Tr=a("p"),Nv=d("Select records from a Table. See "),wd=a("code"),jv=d("pyarrow.compute.filter"),Fv=d(" for full usage."),Vv=s(),Jt=a("div"),p(Er.$$.fragment),Sv=s(),Td=a("p"),Ov=d(`Flatten this Table.  Each column with a struct type is flattened
into one column per struct field.  Other columns are left unchanged.`),Rv=s(),Q=a("div"),p(xr.$$.fragment),qv=s(),Ed=a("p"),Uv=d("Make a new table by combining the chunks this table has."),zv=s(),Dr=a("p"),Bv=d("All the underlying chunks in the "),xd=a("code"),Wv=d("ChunkedArray"),Xv=d(` of each column are
concatenated into zero or one chunk.`),Hv=s(),Qt=a("div"),p(kr.$$.fragment),Kv=s(),Dd=a("p"),Gv=d("Cast table values to another schema."),Yv=s(),Zt=a("div"),p(Ir.$$.fragment),Jv=s(),Mr=a("p"),Qv=d(`EXPERIMENTAL: Create shallow copy of table by replacing schema
key-value metadata with the indicated new metadata (which may be `),kd=a("code"),Zv=d("None"),e2=d(`,
which deletes any existing metadata).`),t2=s(),Z=a("div"),p(Cr.$$.fragment),a2=s(),Id=a("p"),o2=d("Add column to Table at position."),r2=s(),Md=a("p"),n2=d(`A new table is returned with the column added, the original table
object is left unchanged.`),s2=s(),ea=a("div"),p(Pr.$$.fragment),l2=s(),Cd=a("p"),d2=d("Append column at end of columns."),c2=s(),ta=a("div"),p(Lr.$$.fragment),i2=s(),Pd=a("p"),p2=d("Create new Table with the indicated column removed."),m2=s(),aa=a("div"),p(Ar.$$.fragment),b2=s(),Ld=a("p"),h2=d("Replace column in Table at position."),u2=s(),oa=a("div"),p(Nr.$$.fragment),g2=s(),Ad=a("p"),f2=d("Create new table with columns renamed to provided names."),y2=s(),ee=a("div"),p(jr.$$.fragment),v2=s(),Nd=a("p"),$2=d("Select columns of the table."),_2=s(),jd=a("p"),w2=d("Returns a new table with the specified columns, and metadata preserved."),T2=s(),ra=a("div"),p(Fr.$$.fragment),E2=s(),Fd=a("p"),x2=d("Drop one or more columns and return a new table."),D2=s(),Qr=a("div"),p(Vr.$$.fragment),k2=s(),na=a("div"),p(Sr.$$.fragment),I2=s(),Or=a("p"),M2=d("Create "),Vd=a("code"),C2=d("ConcatenationTable"),P2=d(" from list of tables."),ec=s(),ye=a("h2"),sa=a("a"),Sd=a("span"),p(Rr.$$.fragment),L2=s(),Od=a("span"),A2=d("Utils"),tc=s(),ve=a("div"),p(qr.$$.fragment),N2=s(),Rd=a("p"),j2=d("Concatenate tables."),ac=s(),$e=a("div"),p(Ur.$$.fragment),F2=s(),qd=a("p"),V2=d(`Get the cache files that are loaded by the table.
Cache file are used when parts of the table come from the disk via memory mapping.`),this.h()},l(n){const D=h0('[data-svelte="svelte-1phssyn"]',document.head);M=o(D,"META",{name:!0,content:!0}),D.forEach(t),_e=l(n),P=o(n,"H1",{class:!0});var zr=r(P);C=o(zr,"A",{id:!0,class:!0,href:!0});var S2=r(C);j=o(S2,"SPAN",{});var O2=r(j);m(I.$$.fragment,O2),O2.forEach(t),S2.forEach(t),F=l(zr),Pn=o(zr,"SPAN",{});var R2=r(Pn);lp=c(R2,"Table Classes"),R2.forEach(t),zr.forEach(t),Wd=l(n),V=o(n,"P",{});var Zr=r(V);dp=c(Zr,"Each "),Ln=o(Zr,"CODE",{});var q2=r(Ln);cp=c(q2,"Dataset"),q2.forEach(t),ip=c(Zr,` object is backed by a PyArrow Table.
A Table can be loaded from either the disk (memory mapped) or in memory.
Several Table types are available, and they all inherit from `),Br=o(Zr,"A",{href:!0});var U2=r(Br);pp=c(U2,"table.Table"),U2.forEach(t),mp=c(Zr,"."),Zr.forEach(t),Xd=l(n),ae=o(n,"H2",{class:!0});var rc=r(ae);we=o(rc,"A",{id:!0,class:!0,href:!0});var z2=r(we);An=o(z2,"SPAN",{});var B2=r(An);m(ca.$$.fragment,B2),B2.forEach(t),z2.forEach(t),bp=l(rc),Nn=o(rc,"SPAN",{});var W2=r(Nn);hp=c(W2,"Table"),W2.forEach(t),rc.forEach(t),Hd=l(n),E=o(n,"DIV",{class:!0});var x=r(E);m(ia.$$.fragment,x),up=l(x),A=o(x,"P",{});var la=r(A);gp=c(la,`Wraps a pyarrow Table by using composition.
This is the base class for `),jn=o(la,"CODE",{});var X2=r(jn);fp=c(X2,"InMemoryTable"),X2.forEach(t),yp=c(la,", "),Fn=o(la,"CODE",{});var H2=r(Fn);vp=c(H2,"MemoryMappedTable"),H2.forEach(t),$p=c(la," and "),Vn=o(la,"CODE",{});var K2=r(Vn);_p=c(K2,"ConcatenationTable"),K2.forEach(t),wp=c(la,"."),la.forEach(t),Tp=l(x),oe=o(x,"P",{});var en=r(oe);Ep=c(en,`It implements all the basic attributes/methods of the pyarrow Table class except
the Table transforms: `),Sn=o(en,"CODE",{});var G2=r(Sn);xp=c(G2,"slice, filter, flatten, combine_chunks, cast, add_column, append_column, remove_column, set_column, rename_columns"),G2.forEach(t),Dp=c(en," and "),On=o(en,"CODE",{});var Y2=r(On);kp=c(Y2,"drop"),Y2.forEach(t),Ip=c(en,"."),en.forEach(t),Mp=l(x),Rn=o(x,"P",{});var J2=r(Rn);Cp=c(J2,"The implementation of these methods differs for the subclasses."),J2.forEach(t),Pp=l(x),S=o(x,"DIV",{class:!0});var tn=r(S);m(pa.$$.fragment,tn),Lp=l(tn),qn=o(tn,"P",{});var Q2=r(qn);Ap=c(Q2,"Perform validation checks.  An exception is raised if validation fails."),Q2.forEach(t),Np=l(tn),re=o(tn,"P",{});var an=r(re);jp=c(an,"By default only cheap validation checks are run.  Pass "),Un=o(an,"CODE",{});var Z2=r(Un);Fp=c(Z2,"full=True"),Z2.forEach(t),Vp=c(an,`
for thorough validation checks (potentially `),zn=o(an,"CODE",{});var e$=r(zn);Sp=c(e$,"O(n)"),e$.forEach(t),Op=c(an,")."),an.forEach(t),tn.forEach(t),Rp=l(x),Te=o(x,"DIV",{class:!0});var nc=r(Te);m(ma.$$.fragment,nc),qp=l(nc),Bn=o(nc,"P",{});var t$=r(Bn);Up=c(t$,"Check if contents of two tables are equal."),t$.forEach(t),nc.forEach(t),zp=l(x),Ee=o(x,"DIV",{class:!0});var sc=r(Ee);m(ba.$$.fragment,sc),Bp=l(sc),ha=o(sc,"P",{});var lc=r(ha);Wp=c(lc,"Convert Table to list of (contiguous) "),Wn=o(lc,"CODE",{});var a$=r(Wn);Xp=c(a$,"RecordBatch"),a$.forEach(t),Hp=c(lc," objects."),lc.forEach(t),sc.forEach(t),Kp=l(x),xe=o(x,"DIV",{class:!0});var dc=r(xe);m(ua.$$.fragment,dc),Gp=l(dc),ne=o(dc,"P",{});var on=r(ne);Yp=c(on,"Convert the Table to a "),Xn=o(on,"CODE",{});var o$=r(Xn);Jp=c(o$,"dict"),o$.forEach(t),Qp=c(on," or "),Hn=o(on,"CODE",{});var r$=r(Hn);Zp=c(r$,"OrderedDict"),r$.forEach(t),em=c(on,"."),on.forEach(t),dc.forEach(t),tm=l(x),De=o(x,"DIV",{class:!0});var cc=r(De);m(ga.$$.fragment,cc),am=l(cc),Kn=o(cc,"P",{});var n$=r(Kn);om=c(n$,"Convert to a pandas-compatible NumPy array or DataFrame, as appropriate."),n$.forEach(t),cc.forEach(t),rm=l(x),Wr=o(x,"DIV",{class:!0});var s$=r(Wr);m(fa.$$.fragment,s$),s$.forEach(t),nm=l(x),ke=o(x,"DIV",{class:!0});var ic=r(ke);m(ya.$$.fragment,ic),sm=l(ic),Gn=o(ic,"P",{});var l$=r(Gn);lm=c(l$,"Select a schema field by its column name or numeric index."),l$.forEach(t),ic.forEach(t),dm=l(x),Ie=o(x,"DIV",{class:!0});var pc=r(Ie);m(va.$$.fragment,pc),cm=l(pc),Yn=o(pc,"P",{});var d$=r(Yn);im=c(d$,"Select a column by its column name, or numeric index."),d$.forEach(t),pc.forEach(t),pm=l(x),Me=o(x,"DIV",{class:!0});var mc=r(Me);m($a.$$.fragment,mc),mm=l(mc),Jn=o(mc,"P",{});var c$=r(Jn);bm=c(c$,"Iterator over all columns in their numerical order."),c$.forEach(t),mc.forEach(t),hm=l(x),Ce=o(x,"DIV",{class:!0});var bc=r(Ce);m(_a.$$.fragment,bc),um=l(bc),Qn=o(bc,"P",{});var i$=r(Qn);gm=c(i$,"Schema of the table and its columns."),i$.forEach(t),bc.forEach(t),fm=l(x),Pe=o(x,"DIV",{class:!0});var hc=r(Pe);m(wa.$$.fragment,hc),ym=l(hc),Zn=o(hc,"P",{});var p$=r(Zn);vm=c(p$,"List of all columns in numerical order."),p$.forEach(t),hc.forEach(t),$m=l(x),Le=o(x,"DIV",{class:!0});var uc=r(Le);m(Ta.$$.fragment,uc),_m=l(uc),es=o(uc,"P",{});var m$=r(es);wm=c(m$,"Number of columns in this table."),m$.forEach(t),uc.forEach(t),Tm=l(x),O=o(x,"DIV",{class:!0});var rn=r(O);m(Ea.$$.fragment,rn),Em=l(rn),ts=o(rn,"P",{});var b$=r(ts);xm=c(b$,"Number of rows in this table."),b$.forEach(t),Dm=l(rn),as=o(rn,"P",{});var h$=r(as);km=c(h$,`Due to the definition of a table, all columns have the same number of
rows.`),h$.forEach(t),rn.forEach(t),Im=l(x),Ae=o(x,"DIV",{class:!0});var gc=r(Ae);m(xa.$$.fragment,gc),Mm=l(gc),os=o(gc,"P",{});var u$=r(os);Cm=c(u$,"Dimensions of the table: (#rows, #columns)."),u$.forEach(t),gc.forEach(t),Pm=l(x),Ne=o(x,"DIV",{class:!0});var fc=r(Ne);m(Da.$$.fragment,fc),Lm=l(fc),rs=o(fc,"P",{});var g$=r(rs);Am=c(g$,"Total number of bytes consumed by the elements of the table."),g$.forEach(t),fc.forEach(t),x.forEach(t),Kd=l(n),se=o(n,"H2",{class:!0});var yc=r(se);je=o(yc,"A",{id:!0,class:!0,href:!0});var f$=r(je);ns=o(f$,"SPAN",{});var y$=r(ns);m(ka.$$.fragment,y$),y$.forEach(t),f$.forEach(t),Nm=l(yc),ss=o(yc,"SPAN",{});var v$=r(ss);jm=c(v$,"InMemoryTable"),v$.forEach(t),yc.forEach(t),Gd=l(n),y=o(n,"DIV",{class:!0});var $=r(y);m(Ia.$$.fragment,$),Fm=l($),ls=o($,"P",{});var $$=r(ls);Vm=c($$,"The table is said in-memory when it is loaded into the user\u2019s RAM."),$$.forEach(t),Sm=l($),ds=o($,"P",{});var _$=r(ds);Om=c(_$,`Pickling it does copy all the data using memory.
Its implementation is simple and uses the underlying pyarrow Table methods directly.`),_$.forEach(t),Rm=l($),le=o($,"P",{});var nn=r(le);qm=c(nn,"This is different from the "),cs=o(nn,"CODE",{});var w$=r(cs);Um=c(w$,"MemoryMapped"),w$.forEach(t),zm=c(nn,` table, for which pickling doesn\u2019t copy all the
data in memory. For a `),is=o(nn,"CODE",{});var T$=r(is);Bm=c(T$,"MemoryMapped"),T$.forEach(t),Wm=c(nn,", unpickling instead reloads the table from the disk."),nn.forEach(t),Xm=l($),Fe=o($,"P",{});var Ud=r(Fe);ps=o(Ud,"CODE",{});var E$=r(ps);Hm=c(E$,"InMemoryTable"),E$.forEach(t),Km=c(Ud," must be used when data fit in memory, while "),ms=o(Ud,"CODE",{});var x$=r(ms);Gm=c(x$,"MemoryMapped"),x$.forEach(t),Ym=c(Ud,` are reserved for
data bigger than memory or when you want the memory footprint of your application to
stay low.`),Ud.forEach(t),Jm=l($),R=o($,"DIV",{class:!0});var sn=r(R);m(Ma.$$.fragment,sn),Qm=l(sn),bs=o(sn,"P",{});var D$=r(bs);Zm=c(D$,"Perform validation checks.  An exception is raised if validation fails."),D$.forEach(t),eb=l(sn),de=o(sn,"P",{});var ln=r(de);tb=c(ln,"By default only cheap validation checks are run.  Pass "),hs=o(ln,"CODE",{});var k$=r(hs);ab=c(k$,"full=True"),k$.forEach(t),ob=c(ln,`
for thorough validation checks (potentially `),us=o(ln,"CODE",{});var I$=r(us);rb=c(I$,"O(n)"),I$.forEach(t),nb=c(ln,")."),ln.forEach(t),sn.forEach(t),sb=l($),Ve=o($,"DIV",{class:!0});var vc=r(Ve);m(Ca.$$.fragment,vc),lb=l(vc),gs=o(vc,"P",{});var M$=r(gs);db=c(M$,"Check if contents of two tables are equal."),M$.forEach(t),vc.forEach(t),cb=l($),Se=o($,"DIV",{class:!0});var $c=r(Se);m(Pa.$$.fragment,$c),ib=l($c),La=o($c,"P",{});var _c=r(La);pb=c(_c,"Convert Table to list of (contiguous) "),fs=o(_c,"CODE",{});var C$=r(fs);mb=c(C$,"RecordBatch"),C$.forEach(t),bb=c(_c," objects."),_c.forEach(t),$c.forEach(t),hb=l($),Oe=o($,"DIV",{class:!0});var wc=r(Oe);m(Aa.$$.fragment,wc),ub=l(wc),ce=o(wc,"P",{});var dn=r(ce);gb=c(dn,"Convert the Table to a "),ys=o(dn,"CODE",{});var P$=r(ys);fb=c(P$,"dict"),P$.forEach(t),yb=c(dn," or "),vs=o(dn,"CODE",{});var L$=r(vs);vb=c(L$,"OrderedDict"),L$.forEach(t),$b=c(dn,"."),dn.forEach(t),wc.forEach(t),_b=l($),Re=o($,"DIV",{class:!0});var Tc=r(Re);m(Na.$$.fragment,Tc),wb=l(Tc),$s=o(Tc,"P",{});var A$=r($s);Tb=c(A$,"Convert to a pandas-compatible NumPy array or DataFrame, as appropriate."),A$.forEach(t),Tc.forEach(t),Eb=l($),Xr=o($,"DIV",{class:!0});var N$=r(Xr);m(ja.$$.fragment,N$),N$.forEach(t),xb=l($),qe=o($,"DIV",{class:!0});var Ec=r(qe);m(Fa.$$.fragment,Ec),Db=l(Ec),_s=o(Ec,"P",{});var j$=r(_s);kb=c(j$,"Select a schema field by its column name or numeric index."),j$.forEach(t),Ec.forEach(t),Ib=l($),Ue=o($,"DIV",{class:!0});var xc=r(Ue);m(Va.$$.fragment,xc),Mb=l(xc),ws=o(xc,"P",{});var F$=r(ws);Cb=c(F$,"Select a column by its column name, or numeric index."),F$.forEach(t),xc.forEach(t),Pb=l($),ze=o($,"DIV",{class:!0});var Dc=r(ze);m(Sa.$$.fragment,Dc),Lb=l(Dc),Ts=o(Dc,"P",{});var V$=r(Ts);Ab=c(V$,"Iterator over all columns in their numerical order."),V$.forEach(t),Dc.forEach(t),Nb=l($),Be=o($,"DIV",{class:!0});var kc=r(Be);m(Oa.$$.fragment,kc),jb=l(kc),Es=o(kc,"P",{});var S$=r(Es);Fb=c(S$,"Schema of the table and its columns."),S$.forEach(t),kc.forEach(t),Vb=l($),We=o($,"DIV",{class:!0});var Ic=r(We);m(Ra.$$.fragment,Ic),Sb=l(Ic),xs=o(Ic,"P",{});var O$=r(xs);Ob=c(O$,"List of all columns in numerical order."),O$.forEach(t),Ic.forEach(t),Rb=l($),Xe=o($,"DIV",{class:!0});var Mc=r(Xe);m(qa.$$.fragment,Mc),qb=l(Mc),Ds=o(Mc,"P",{});var R$=r(Ds);Ub=c(R$,"Number of columns in this table."),R$.forEach(t),Mc.forEach(t),zb=l($),q=o($,"DIV",{class:!0});var cn=r(q);m(Ua.$$.fragment,cn),Bb=l(cn),ks=o(cn,"P",{});var q$=r(ks);Wb=c(q$,"Number of rows in this table."),q$.forEach(t),Xb=l(cn),Is=o(cn,"P",{});var U$=r(Is);Hb=c(U$,`Due to the definition of a table, all columns have the same number of
rows.`),U$.forEach(t),cn.forEach(t),Kb=l($),He=o($,"DIV",{class:!0});var Cc=r(He);m(za.$$.fragment,Cc),Gb=l(Cc),Ms=o(Cc,"P",{});var z$=r(Ms);Yb=c(z$,"Dimensions of the table: (#rows, #columns)."),z$.forEach(t),Cc.forEach(t),Jb=l($),Ke=o($,"DIV",{class:!0});var Pc=r(Ke);m(Ba.$$.fragment,Pc),Qb=l(Pc),Cs=o(Pc,"P",{});var B$=r(Cs);Zb=c(B$,"Total number of bytes consumed by the elements of the table."),B$.forEach(t),Pc.forEach(t),eh=l($),Ge=o($,"DIV",{class:!0});var Lc=r(Ge);m(Wa.$$.fragment,Lc),th=l(Lc),Ps=o(Lc,"P",{});var W$=r(Ps);ah=c(W$,"Names of the table\u2019s columns."),W$.forEach(t),Lc.forEach(t),oh=l($),Ye=o($,"DIV",{class:!0});var Ac=r(Ye);m(Xa.$$.fragment,Ac),rh=l(Ac),Ls=o(Ac,"P",{});var X$=r(Ls);nh=c(X$,"Compute zero-copy slice of this Table."),X$.forEach(t),Ac.forEach(t),sh=l($),Je=o($,"DIV",{class:!0});var Nc=r(Je);m(Ha.$$.fragment,Nc),lh=l(Nc),Ka=o(Nc,"P",{});var jc=r(Ka);dh=c(jc,"Select records from a Table. See "),As=o(jc,"CODE",{});var H$=r(As);ch=c(H$,"pyarrow.compute.filter"),H$.forEach(t),ih=c(jc," for full usage."),jc.forEach(t),Nc.forEach(t),ph=l($),Qe=o($,"DIV",{class:!0});var Fc=r(Qe);m(Ga.$$.fragment,Fc),mh=l(Fc),Ns=o(Fc,"P",{});var K$=r(Ns);bh=c(K$,`Flatten this Table.  Each column with a struct type is flattened
into one column per struct field.  Other columns are left unchanged.`),K$.forEach(t),Fc.forEach(t),hh=l($),U=o($,"DIV",{class:!0});var pn=r(U);m(Ya.$$.fragment,pn),uh=l(pn),js=o(pn,"P",{});var G$=r(js);gh=c(G$,"Make a new table by combining the chunks this table has."),G$.forEach(t),fh=l(pn),Ja=o(pn,"P",{});var Vc=r(Ja);yh=c(Vc,"All the underlying chunks in the "),Fs=o(Vc,"CODE",{});var Y$=r(Fs);vh=c(Y$,"ChunkedArray"),Y$.forEach(t),$h=c(Vc,` of each column are
concatenated into zero or one chunk.`),Vc.forEach(t),pn.forEach(t),_h=l($),Ze=o($,"DIV",{class:!0});var Sc=r(Ze);m(Qa.$$.fragment,Sc),wh=l(Sc),Vs=o(Sc,"P",{});var J$=r(Vs);Th=c(J$,"Cast table values to another schema."),J$.forEach(t),Sc.forEach(t),Eh=l($),et=o($,"DIV",{class:!0});var Oc=r(et);m(Za.$$.fragment,Oc),xh=l(Oc),eo=o(Oc,"P",{});var Rc=r(eo);Dh=c(Rc,`EXPERIMENTAL: Create shallow copy of table by replacing schema
key-value metadata with the indicated new metadata (which may be `),Ss=o(Rc,"CODE",{});var Q$=r(Ss);kh=c(Q$,"None"),Q$.forEach(t),Ih=c(Rc,`,
which deletes any existing metadata).`),Rc.forEach(t),Oc.forEach(t),Mh=l($),z=o($,"DIV",{class:!0});var mn=r(z);m(to.$$.fragment,mn),Ch=l(mn),Os=o(mn,"P",{});var Z$=r(Os);Ph=c(Z$,"Add column to Table at position."),Z$.forEach(t),Lh=l(mn),Rs=o(mn,"P",{});var e1=r(Rs);Ah=c(e1,`A new table is returned with the column added, the original table
object is left unchanged.`),e1.forEach(t),mn.forEach(t),Nh=l($),tt=o($,"DIV",{class:!0});var qc=r(tt);m(ao.$$.fragment,qc),jh=l(qc),qs=o(qc,"P",{});var t1=r(qs);Fh=c(t1,"Append column at end of columns."),t1.forEach(t),qc.forEach(t),Vh=l($),at=o($,"DIV",{class:!0});var Uc=r(at);m(oo.$$.fragment,Uc),Sh=l(Uc),Us=o(Uc,"P",{});var a1=r(Us);Oh=c(a1,"Create new Table with the indicated column removed."),a1.forEach(t),Uc.forEach(t),Rh=l($),ot=o($,"DIV",{class:!0});var zc=r(ot);m(ro.$$.fragment,zc),qh=l(zc),zs=o(zc,"P",{});var o1=r(zs);Uh=c(o1,"Replace column in Table at position."),o1.forEach(t),zc.forEach(t),zh=l($),rt=o($,"DIV",{class:!0});var Bc=r(rt);m(no.$$.fragment,Bc),Bh=l(Bc),Bs=o(Bc,"P",{});var r1=r(Bs);Wh=c(r1,"Create new table with columns renamed to provided names."),r1.forEach(t),Bc.forEach(t),Xh=l($),B=o($,"DIV",{class:!0});var bn=r(B);m(so.$$.fragment,bn),Hh=l(bn),Ws=o(bn,"P",{});var n1=r(Ws);Kh=c(n1,"Select columns of the table."),n1.forEach(t),Gh=l(bn),Xs=o(bn,"P",{});var s1=r(Xs);Yh=c(s1,"Returns a new table with the specified columns, and metadata preserved."),s1.forEach(t),bn.forEach(t),Jh=l($),nt=o($,"DIV",{class:!0});var Wc=r(nt);m(lo.$$.fragment,Wc),Qh=l(Wc),Hs=o(Wc,"P",{});var l1=r(Hs);Zh=c(l1,"Drop one or more columns and return a new table."),l1.forEach(t),Wc.forEach(t),eu=l($),Hr=o($,"DIV",{class:!0});var d1=r(Hr);m(co.$$.fragment,d1),d1.forEach(t),tu=l($),Kr=o($,"DIV",{class:!0});var c1=r(Kr);m(io.$$.fragment,c1),c1.forEach(t),au=l($),L=o($,"DIV",{class:!0});var te=r(L);m(po.$$.fragment,te),ou=l(te),Ks=o(te,"P",{});var i1=r(Ks);ru=c(i1,"Convert pandas.DataFrame to an Arrow Table."),i1.forEach(t),nu=l(te),mo=o(te,"P",{});var Xc=r(mo);su=c(Xc,`The column types in the resulting Arrow Table are inferred from the
dtypes of the pandas.Series in the DataFrame. In the case of non-object
Series, the NumPy dtype is translated to its Arrow equivalent. In the
case of `),Gs=o(Xc,"CODE",{});var p1=r(Gs);lu=c(p1,"object"),p1.forEach(t),du=c(Xc,`, we need to guess the datatype by looking at the
Python objects in this Series.`),Xc.forEach(t),cu=l(te),ie=o(te,"P",{});var hn=r(ie);iu=c(hn,"Be aware that Series of the "),Ys=o(hn,"CODE",{});var m1=r(Ys);pu=c(m1,"object"),m1.forEach(t),mu=c(hn,` dtype don\u2019t carry enough
information to always lead to a meaningful Arrow type. In the case that
we cannot infer a type, e.g. because the DataFrame is of length 0 or
the Series only contains `),Js=o(hn,"CODE",{});var b1=r(Js);bu=c(b1,"None/nan"),b1.forEach(t),hu=c(hn,` objects, the type is set to
null. This behavior can be avoided by constructing an explicit schema
and passing it to this function.`),hn.forEach(t),uu=l(te),m(st.$$.fragment,te),te.forEach(t),gu=l($),lt=o($,"DIV",{class:!0});var Hc=r(lt);m(bo.$$.fragment,Hc),fu=l(Hc),Qs=o(Hc,"P",{});var h1=r(Qs);yu=c(h1,"Construct a Table from Arrow arrays."),h1.forEach(t),Hc.forEach(t),vu=l($),dt=o($,"DIV",{class:!0});var Kc=r(dt);m(ho.$$.fragment,Kc),$u=l(Kc),Zs=o(Kc,"P",{});var u1=r(Zs);_u=c(u1,"Construct a Table from Arrow arrays or columns."),u1.forEach(t),Kc.forEach(t),wu=l($),ct=o($,"DIV",{class:!0});var Gc=r(ct);m(uo.$$.fragment,Gc),Tu=l(Gc),go=o(Gc,"P",{});var Yc=r(go);Eu=c(Yc,"Construct a Table from a sequence or iterator of Arrow "),el=o(Yc,"CODE",{});var g1=r(el);xu=c(g1,"RecordBatches"),g1.forEach(t),Du=c(Yc,"."),Yc.forEach(t),Gc.forEach(t),$.forEach(t),Yd=l(n),pe=o(n,"H2",{class:!0});var Jc=r(pe);it=o(Jc,"A",{id:!0,class:!0,href:!0});var f1=r(it);tl=o(f1,"SPAN",{});var y1=r(tl);m(fo.$$.fragment,y1),y1.forEach(t),f1.forEach(t),ku=l(Jc),al=o(Jc,"SPAN",{});var v1=r(al);Iu=c(v1,"MemoryMappedTable"),v1.forEach(t),Jc.forEach(t),Jd=l(n),_=o(n,"DIV",{class:!0});var T=r(_);m(yo.$$.fragment,T),Mu=l(T),ol=o(T,"P",{});var $1=r(ol);Cu=c($1,`The table is said memory mapped when it doesn\u2019t use the user\u2019s RAM but loads the data
from the disk instead.`),$1.forEach(t),Pu=l(T),rl=o(T,"P",{});var _1=r(rl);Lu=c(_1,`Pickling it doesn\u2019t copy the data into memory.
Instead, only the path to the memory mapped arrow file is pickled, as well as the list
of transforms to \u201Creplay\u201D when reloading the table from the disk.`),_1.forEach(t),Au=l(T),nl=o(T,"P",{});var w1=r(nl);Nu=c(w1,`Its implementation requires to store an history of all the transforms that were applied
to the underlying pyarrow Table, so that they can be \u201Creplayed\u201D when reloading the Table
from the disk.`),w1.forEach(t),ju=l(T),vo=o(T,"P",{});var Qc=r(vo);Fu=c(Qc,"This is different from the "),sl=o(Qc,"CODE",{});var T1=r(sl);Vu=c(T1,"InMemoryTable"),T1.forEach(t),Su=c(Qc,` table, for which pickling does copy all the
data in memory.`),Qc.forEach(t),Ou=l(T),pt=o(T,"P",{});var zd=r(pt);ll=o(zd,"CODE",{});var E1=r(ll);Ru=c(E1,"InMemoryTable"),E1.forEach(t),qu=c(zd," must be used when data fit in memory, while "),dl=o(zd,"CODE",{});var x1=r(dl);Uu=c(x1,"MemoryMapped"),x1.forEach(t),zu=c(zd,` are reserved for
data bigger than memory or when you want the memory footprint of your application to
stay low.`),zd.forEach(t),Bu=l(T),W=o(T,"DIV",{class:!0});var un=r(W);m($o.$$.fragment,un),Wu=l(un),cl=o(un,"P",{});var D1=r(cl);Xu=c(D1,"Perform validation checks.  An exception is raised if validation fails."),D1.forEach(t),Hu=l(un),me=o(un,"P",{});var gn=r(me);Ku=c(gn,"By default only cheap validation checks are run.  Pass "),il=o(gn,"CODE",{});var k1=r(il);Gu=c(k1,"full=True"),k1.forEach(t),Yu=c(gn,`
for thorough validation checks (potentially `),pl=o(gn,"CODE",{});var I1=r(pl);Ju=c(I1,"O(n)"),I1.forEach(t),Qu=c(gn,")."),gn.forEach(t),un.forEach(t),Zu=l(T),mt=o(T,"DIV",{class:!0});var Zc=r(mt);m(_o.$$.fragment,Zc),eg=l(Zc),ml=o(Zc,"P",{});var M1=r(ml);tg=c(M1,"Check if contents of two tables are equal."),M1.forEach(t),Zc.forEach(t),ag=l(T),bt=o(T,"DIV",{class:!0});var ei=r(bt);m(wo.$$.fragment,ei),og=l(ei),To=o(ei,"P",{});var ti=r(To);rg=c(ti,"Convert Table to list of (contiguous) "),bl=o(ti,"CODE",{});var C1=r(bl);ng=c(C1,"RecordBatch"),C1.forEach(t),sg=c(ti," objects."),ti.forEach(t),ei.forEach(t),lg=l(T),ht=o(T,"DIV",{class:!0});var ai=r(ht);m(Eo.$$.fragment,ai),dg=l(ai),be=o(ai,"P",{});var fn=r(be);cg=c(fn,"Convert the Table to a "),hl=o(fn,"CODE",{});var P1=r(hl);ig=c(P1,"dict"),P1.forEach(t),pg=c(fn," or "),ul=o(fn,"CODE",{});var L1=r(ul);mg=c(L1,"OrderedDict"),L1.forEach(t),bg=c(fn,"."),fn.forEach(t),ai.forEach(t),hg=l(T),ut=o(T,"DIV",{class:!0});var oi=r(ut);m(xo.$$.fragment,oi),ug=l(oi),gl=o(oi,"P",{});var A1=r(gl);gg=c(A1,"Convert to a pandas-compatible NumPy array or DataFrame, as appropriate."),A1.forEach(t),oi.forEach(t),fg=l(T),Gr=o(T,"DIV",{class:!0});var N1=r(Gr);m(Do.$$.fragment,N1),N1.forEach(t),yg=l(T),gt=o(T,"DIV",{class:!0});var ri=r(gt);m(ko.$$.fragment,ri),vg=l(ri),fl=o(ri,"P",{});var j1=r(fl);$g=c(j1,"Select a schema field by its column name or numeric index."),j1.forEach(t),ri.forEach(t),_g=l(T),ft=o(T,"DIV",{class:!0});var ni=r(ft);m(Io.$$.fragment,ni),wg=l(ni),yl=o(ni,"P",{});var F1=r(yl);Tg=c(F1,"Select a column by its column name, or numeric index."),F1.forEach(t),ni.forEach(t),Eg=l(T),yt=o(T,"DIV",{class:!0});var si=r(yt);m(Mo.$$.fragment,si),xg=l(si),vl=o(si,"P",{});var V1=r(vl);Dg=c(V1,"Iterator over all columns in their numerical order."),V1.forEach(t),si.forEach(t),kg=l(T),vt=o(T,"DIV",{class:!0});var li=r(vt);m(Co.$$.fragment,li),Ig=l(li),$l=o(li,"P",{});var S1=r($l);Mg=c(S1,"Schema of the table and its columns."),S1.forEach(t),li.forEach(t),Cg=l(T),$t=o(T,"DIV",{class:!0});var di=r($t);m(Po.$$.fragment,di),Pg=l(di),_l=o(di,"P",{});var O1=r(_l);Lg=c(O1,"List of all columns in numerical order."),O1.forEach(t),di.forEach(t),Ag=l(T),_t=o(T,"DIV",{class:!0});var ci=r(_t);m(Lo.$$.fragment,ci),Ng=l(ci),wl=o(ci,"P",{});var R1=r(wl);jg=c(R1,"Number of columns in this table."),R1.forEach(t),ci.forEach(t),Fg=l(T),X=o(T,"DIV",{class:!0});var yn=r(X);m(Ao.$$.fragment,yn),Vg=l(yn),Tl=o(yn,"P",{});var q1=r(Tl);Sg=c(q1,"Number of rows in this table."),q1.forEach(t),Og=l(yn),El=o(yn,"P",{});var U1=r(El);Rg=c(U1,`Due to the definition of a table, all columns have the same number of
rows.`),U1.forEach(t),yn.forEach(t),qg=l(T),wt=o(T,"DIV",{class:!0});var ii=r(wt);m(No.$$.fragment,ii),Ug=l(ii),xl=o(ii,"P",{});var z1=r(xl);zg=c(z1,"Dimensions of the table: (#rows, #columns)."),z1.forEach(t),ii.forEach(t),Bg=l(T),Tt=o(T,"DIV",{class:!0});var pi=r(Tt);m(jo.$$.fragment,pi),Wg=l(pi),Dl=o(pi,"P",{});var B1=r(Dl);Xg=c(B1,"Total number of bytes consumed by the elements of the table."),B1.forEach(t),pi.forEach(t),Hg=l(T),Et=o(T,"DIV",{class:!0});var mi=r(Et);m(Fo.$$.fragment,mi),Kg=l(mi),kl=o(mi,"P",{});var W1=r(kl);Gg=c(W1,"Names of the table\u2019s columns."),W1.forEach(t),mi.forEach(t),Yg=l(T),xt=o(T,"DIV",{class:!0});var bi=r(xt);m(Vo.$$.fragment,bi),Jg=l(bi),Il=o(bi,"P",{});var X1=r(Il);Qg=c(X1,"Compute zero-copy slice of this Table."),X1.forEach(t),bi.forEach(t),Zg=l(T),Dt=o(T,"DIV",{class:!0});var hi=r(Dt);m(So.$$.fragment,hi),ef=l(hi),Oo=o(hi,"P",{});var ui=r(Oo);tf=c(ui,"Select records from a Table. See "),Ml=o(ui,"CODE",{});var H1=r(Ml);af=c(H1,"pyarrow.compute.filter"),H1.forEach(t),of=c(ui," for full usage."),ui.forEach(t),hi.forEach(t),rf=l(T),kt=o(T,"DIV",{class:!0});var gi=r(kt);m(Ro.$$.fragment,gi),nf=l(gi),Cl=o(gi,"P",{});var K1=r(Cl);sf=c(K1,`Flatten this Table.  Each column with a struct type is flattened
into one column per struct field.  Other columns are left unchanged.`),K1.forEach(t),gi.forEach(t),lf=l(T),H=o(T,"DIV",{class:!0});var vn=r(H);m(qo.$$.fragment,vn),df=l(vn),Pl=o(vn,"P",{});var G1=r(Pl);cf=c(G1,"Make a new table by combining the chunks this table has."),G1.forEach(t),pf=l(vn),Ll=o(vn,"P",{});var Y1=r(Ll);mf=c(Y1,`All the underlying chunks in the ChunkedArray of each column are
concatenated into zero or one chunk.`),Y1.forEach(t),vn.forEach(t),bf=l(T),It=o(T,"DIV",{class:!0});var fi=r(It);m(Uo.$$.fragment,fi),hf=l(fi),Al=o(fi,"P",{});var J1=r(Al);uf=c(J1,"Cast table values to another schema"),J1.forEach(t),fi.forEach(t),gf=l(T),Mt=o(T,"DIV",{class:!0});var yi=r(Mt);m(zo.$$.fragment,yi),ff=l(yi),Nl=o(yi,"P",{});var Q1=r(Nl);yf=c(Q1,`EXPERIMENTAL: Create shallow copy of table by replacing schema
key-value metadata with the indicated new metadata (which may be None,
which deletes any existing metadata.`),Q1.forEach(t),yi.forEach(t),vf=l(T),K=o(T,"DIV",{class:!0});var $n=r(K);m(Bo.$$.fragment,$n),$f=l($n),jl=o($n,"P",{});var Z1=r(jl);_f=c(Z1,"Add column to Table at position."),Z1.forEach(t),wf=l($n),Fl=o($n,"P",{});var e_=r(Fl);Tf=c(e_,`A new table is returned with the column added, the original table
object is left unchanged.`),e_.forEach(t),$n.forEach(t),Ef=l(T),Ct=o(T,"DIV",{class:!0});var vi=r(Ct);m(Wo.$$.fragment,vi),xf=l(vi),Vl=o(vi,"P",{});var t_=r(Vl);Df=c(t_,"Append column at end of columns."),t_.forEach(t),vi.forEach(t),kf=l(T),Pt=o(T,"DIV",{class:!0});var $i=r(Pt);m(Xo.$$.fragment,$i),If=l($i),Sl=o($i,"P",{});var a_=r(Sl);Mf=c(a_,"Create new Table with the indicated column removed."),a_.forEach(t),$i.forEach(t),Cf=l(T),Lt=o(T,"DIV",{class:!0});var _i=r(Lt);m(Ho.$$.fragment,_i),Pf=l(_i),Ol=o(_i,"P",{});var o_=r(Ol);Lf=c(o_,"Replace column in Table at position."),o_.forEach(t),_i.forEach(t),Af=l(T),At=o(T,"DIV",{class:!0});var wi=r(At);m(Ko.$$.fragment,wi),Nf=l(wi),Rl=o(wi,"P",{});var r_=r(Rl);jf=c(r_,"Create new table with columns renamed to provided names."),r_.forEach(t),wi.forEach(t),Ff=l(T),G=o(T,"DIV",{class:!0});var _n=r(G);m(Go.$$.fragment,_n),Vf=l(_n),ql=o(_n,"P",{});var n_=r(ql);Sf=c(n_,"Select columns of the table."),n_.forEach(t),Of=l(_n),Ul=o(_n,"P",{});var s_=r(Ul);Rf=c(s_,"Returns a new table with the specified columns, and metadata preserved."),s_.forEach(t),_n.forEach(t),qf=l(T),Nt=o(T,"DIV",{class:!0});var Ti=r(Nt);m(Yo.$$.fragment,Ti),Uf=l(Ti),zl=o(Ti,"P",{});var l_=r(zl);zf=c(l_,"Drop one or more columns and return a new table."),l_.forEach(t),Ti.forEach(t),Bf=l(T),Yr=o(T,"DIV",{class:!0});var d_=r(Yr);m(Jo.$$.fragment,d_),d_.forEach(t),T.forEach(t),Qd=l(n),he=o(n,"H2",{class:!0});var Ei=r(he);jt=o(Ei,"A",{id:!0,class:!0,href:!0});var c_=r(jt);Bl=o(c_,"SPAN",{});var i_=r(Bl);m(Qo.$$.fragment,i_),i_.forEach(t),c_.forEach(t),Wf=l(Ei),Wl=o(Ei,"SPAN",{});var p_=r(Wl);Xf=c(p_,"ConcatenationTable"),p_.forEach(t),Ei.forEach(t),Zd=l(n),v=o(n,"DIV",{class:!0});var w=r(v);m(Zo.$$.fragment,w),Hf=l(w),Xl=o(w,"P",{});var m_=r(Xl);Kf=c(m_,`The table comes from the concatenation of several tables called blocks.
It enables concatenation on both axis 0 (append rows) and axis 1 (append columns).`),m_.forEach(t),Gf=l(w),N=o(w,"P",{});var da=r(N);Yf=c(da,"The underlying tables are called \u201Cblocks\u201D and can be either "),Hl=o(da,"CODE",{});var b_=r(Hl);Jf=c(b_,"InMemoryTable"),b_.forEach(t),Qf=c(da,`
or `),Kl=o(da,"CODE",{});var h_=r(Kl);Zf=c(h_,"MemoryMappedTable"),h_.forEach(t),ey=c(da,` objects.
This allows to combine tables that come from memory or that are memory mapped.
When a `),Gl=o(da,"CODE",{});var u_=r(Gl);ty=c(u_,"ConcatenationTable"),u_.forEach(t),ay=c(da," is pickled, then each block is pickled:"),da.forEach(t),oy=l(w),er=o(w,"UL",{});var xi=r(er);tr=o(xi,"LI",{});var Di=r(tr);ry=c(Di,"the "),Yl=o(Di,"CODE",{});var g_=r(Yl);ny=c(g_,"InMemoryTable"),g_.forEach(t),sy=c(Di," objects are pickled by copying all the data in memory."),Di.forEach(t),ly=l(xi),Jl=o(xi,"LI",{});var f_=r(Jl);dy=c(f_,`the MemoryMappedTable objects are pickled without copying the data into memory.
Instead, only the path to the memory mapped arrow file is pickled, as well as the list
of transforms to \u201Creplays\u201D when reloading the table from the disk.`),f_.forEach(t),xi.forEach(t),cy=l(w),ar=o(w,"P",{});var ki=r(ar);iy=c(ki,`Its implementation requires to store each block separately.
The `),Ql=o(ki,"CODE",{});var y_=r(Ql);py=c(y_,"blocks"),y_.forEach(t),my=c(ki,` attributes stores a list of list of blocks.
The first axis concatenates the tables along the axis 0 (it appends rows),
while the second axis concatenates tables along the axis 1 (it appends columns).`),ki.forEach(t),by=l(w),or=o(w,"P",{});var Ii=r(or);hy=c(Ii,`If some columns are missing when concatenating on axis 0, they are filled with null values.
This is done using `),Zl=o(Ii,"CODE",{});var v_=r(Zl);uy=c(v_,"pyarrow.concat_tables(tables, promote=True)"),v_.forEach(t),gy=c(Ii,"."),Ii.forEach(t),fy=l(w),ue=o(w,"P",{});var wn=r(ue);yy=c(wn,"You can access the fully combined table by accessing the "),ed=o(wn,"CODE",{});var $_=r(ed);vy=c($_,"ConcatenationTable.table"),$_.forEach(t),$y=c(wn,` attribute,
and the blocks by accessing the `),td=o(wn,"CODE",{});var __=r(td);_y=c(__,"ConcatenationTable.blocks"),__.forEach(t),wy=c(wn," attribute."),wn.forEach(t),Ty=l(w),Y=o(w,"DIV",{class:!0});var Tn=r(Y);m(rr.$$.fragment,Tn),Ey=l(Tn),ad=o(Tn,"P",{});var w_=r(ad);xy=c(w_,"Perform validation checks.  An exception is raised if validation fails."),w_.forEach(t),Dy=l(Tn),ge=o(Tn,"P",{});var En=r(ge);ky=c(En,"By default only cheap validation checks are run.  Pass "),od=o(En,"CODE",{});var T_=r(od);Iy=c(T_,"full=True"),T_.forEach(t),My=c(En,`
for thorough validation checks (potentially `),rd=o(En,"CODE",{});var E_=r(rd);Cy=c(E_,"O(n)"),E_.forEach(t),Py=c(En,")."),En.forEach(t),Tn.forEach(t),Ly=l(w),Ft=o(w,"DIV",{class:!0});var Mi=r(Ft);m(nr.$$.fragment,Mi),Ay=l(Mi),nd=o(Mi,"P",{});var x_=r(nd);Ny=c(x_,"Check if contents of two tables are equal."),x_.forEach(t),Mi.forEach(t),jy=l(w),Vt=o(w,"DIV",{class:!0});var Ci=r(Vt);m(sr.$$.fragment,Ci),Fy=l(Ci),lr=o(Ci,"P",{});var Pi=r(lr);Vy=c(Pi,"Convert Table to list of (contiguous) "),sd=o(Pi,"CODE",{});var D_=r(sd);Sy=c(D_,"RecordBatch"),D_.forEach(t),Oy=c(Pi," objects."),Pi.forEach(t),Ci.forEach(t),Ry=l(w),St=o(w,"DIV",{class:!0});var Li=r(St);m(dr.$$.fragment,Li),qy=l(Li),fe=o(Li,"P",{});var xn=r(fe);Uy=c(xn,"Convert the Table to a "),ld=o(xn,"CODE",{});var k_=r(ld);zy=c(k_,"dict"),k_.forEach(t),By=c(xn," or "),dd=o(xn,"CODE",{});var I_=r(dd);Wy=c(I_,"OrderedDict"),I_.forEach(t),Xy=c(xn,"."),xn.forEach(t),Li.forEach(t),Hy=l(w),Ot=o(w,"DIV",{class:!0});var Ai=r(Ot);m(cr.$$.fragment,Ai),Ky=l(Ai),cd=o(Ai,"P",{});var M_=r(cd);Gy=c(M_,"Convert to a pandas-compatible NumPy array or DataFrame, as appropriate."),M_.forEach(t),Ai.forEach(t),Yy=l(w),Jr=o(w,"DIV",{class:!0});var C_=r(Jr);m(ir.$$.fragment,C_),C_.forEach(t),Jy=l(w),Rt=o(w,"DIV",{class:!0});var Ni=r(Rt);m(pr.$$.fragment,Ni),Qy=l(Ni),id=o(Ni,"P",{});var P_=r(id);Zy=c(P_,"Select a schema field by its column name or numeric index."),P_.forEach(t),Ni.forEach(t),ev=l(w),qt=o(w,"DIV",{class:!0});var ji=r(qt);m(mr.$$.fragment,ji),tv=l(ji),pd=o(ji,"P",{});var L_=r(pd);av=c(L_,"Select a column by its column name, or numeric index."),L_.forEach(t),ji.forEach(t),ov=l(w),Ut=o(w,"DIV",{class:!0});var Fi=r(Ut);m(br.$$.fragment,Fi),rv=l(Fi),md=o(Fi,"P",{});var A_=r(md);nv=c(A_,"Iterator over all columns in their numerical order."),A_.forEach(t),Fi.forEach(t),sv=l(w),zt=o(w,"DIV",{class:!0});var Vi=r(zt);m(hr.$$.fragment,Vi),lv=l(Vi),bd=o(Vi,"P",{});var N_=r(bd);dv=c(N_,"Schema of the table and its columns."),N_.forEach(t),Vi.forEach(t),cv=l(w),Bt=o(w,"DIV",{class:!0});var Si=r(Bt);m(ur.$$.fragment,Si),iv=l(Si),hd=o(Si,"P",{});var j_=r(hd);pv=c(j_,"List of all columns in numerical order."),j_.forEach(t),Si.forEach(t),mv=l(w),Wt=o(w,"DIV",{class:!0});var Oi=r(Wt);m(gr.$$.fragment,Oi),bv=l(Oi),ud=o(Oi,"P",{});var F_=r(ud);hv=c(F_,"Number of columns in this table."),F_.forEach(t),Oi.forEach(t),uv=l(w),J=o(w,"DIV",{class:!0});var Dn=r(J);m(fr.$$.fragment,Dn),gv=l(Dn),gd=o(Dn,"P",{});var V_=r(gd);fv=c(V_,"Number of rows in this table."),V_.forEach(t),yv=l(Dn),fd=o(Dn,"P",{});var S_=r(fd);vv=c(S_,`Due to the definition of a table, all columns have the same number of
rows.`),S_.forEach(t),Dn.forEach(t),$v=l(w),Xt=o(w,"DIV",{class:!0});var Ri=r(Xt);m(yr.$$.fragment,Ri),_v=l(Ri),yd=o(Ri,"P",{});var O_=r(yd);wv=c(O_,"Dimensions of the table: (#rows, #columns)."),O_.forEach(t),Ri.forEach(t),Tv=l(w),Ht=o(w,"DIV",{class:!0});var qi=r(Ht);m(vr.$$.fragment,qi),Ev=l(qi),vd=o(qi,"P",{});var R_=r(vd);xv=c(R_,"Total number of bytes consumed by the elements of the table."),R_.forEach(t),qi.forEach(t),Dv=l(w),Kt=o(w,"DIV",{class:!0});var Ui=r(Kt);m($r.$$.fragment,Ui),kv=l(Ui),$d=o(Ui,"P",{});var q_=r($d);Iv=c(q_,"Names of the table\u2019s columns."),q_.forEach(t),Ui.forEach(t),Mv=l(w),Gt=o(w,"DIV",{class:!0});var zi=r(Gt);m(_r.$$.fragment,zi),Cv=l(zi),_d=o(zi,"P",{});var U_=r(_d);Pv=c(U_,"Compute zero-copy slice of this Table."),U_.forEach(t),zi.forEach(t),Lv=l(w),Yt=o(w,"DIV",{class:!0});var Bi=r(Yt);m(wr.$$.fragment,Bi),Av=l(Bi),Tr=o(Bi,"P",{});var Wi=r(Tr);Nv=c(Wi,"Select records from a Table. See "),wd=o(Wi,"CODE",{});var z_=r(wd);jv=c(z_,"pyarrow.compute.filter"),z_.forEach(t),Fv=c(Wi," for full usage."),Wi.forEach(t),Bi.forEach(t),Vv=l(w),Jt=o(w,"DIV",{class:!0});var Xi=r(Jt);m(Er.$$.fragment,Xi),Sv=l(Xi),Td=o(Xi,"P",{});var B_=r(Td);Ov=c(B_,`Flatten this Table.  Each column with a struct type is flattened
into one column per struct field.  Other columns are left unchanged.`),B_.forEach(t),Xi.forEach(t),Rv=l(w),Q=o(w,"DIV",{class:!0});var kn=r(Q);m(xr.$$.fragment,kn),qv=l(kn),Ed=o(kn,"P",{});var W_=r(Ed);Uv=c(W_,"Make a new table by combining the chunks this table has."),W_.forEach(t),zv=l(kn),Dr=o(kn,"P",{});var Hi=r(Dr);Bv=c(Hi,"All the underlying chunks in the "),xd=o(Hi,"CODE",{});var X_=r(xd);Wv=c(X_,"ChunkedArray"),X_.forEach(t),Xv=c(Hi,` of each column are
concatenated into zero or one chunk.`),Hi.forEach(t),kn.forEach(t),Hv=l(w),Qt=o(w,"DIV",{class:!0});var Ki=r(Qt);m(kr.$$.fragment,Ki),Kv=l(Ki),Dd=o(Ki,"P",{});var H_=r(Dd);Gv=c(H_,"Cast table values to another schema."),H_.forEach(t),Ki.forEach(t),Yv=l(w),Zt=o(w,"DIV",{class:!0});var Gi=r(Zt);m(Ir.$$.fragment,Gi),Jv=l(Gi),Mr=o(Gi,"P",{});var Yi=r(Mr);Qv=c(Yi,`EXPERIMENTAL: Create shallow copy of table by replacing schema
key-value metadata with the indicated new metadata (which may be `),kd=o(Yi,"CODE",{});var K_=r(kd);Zv=c(K_,"None"),K_.forEach(t),e2=c(Yi,`,
which deletes any existing metadata).`),Yi.forEach(t),Gi.forEach(t),t2=l(w),Z=o(w,"DIV",{class:!0});var In=r(Z);m(Cr.$$.fragment,In),a2=l(In),Id=o(In,"P",{});var G_=r(Id);o2=c(G_,"Add column to Table at position."),G_.forEach(t),r2=l(In),Md=o(In,"P",{});var Y_=r(Md);n2=c(Y_,`A new table is returned with the column added, the original table
object is left unchanged.`),Y_.forEach(t),In.forEach(t),s2=l(w),ea=o(w,"DIV",{class:!0});var Ji=r(ea);m(Pr.$$.fragment,Ji),l2=l(Ji),Cd=o(Ji,"P",{});var J_=r(Cd);d2=c(J_,"Append column at end of columns."),J_.forEach(t),Ji.forEach(t),c2=l(w),ta=o(w,"DIV",{class:!0});var Qi=r(ta);m(Lr.$$.fragment,Qi),i2=l(Qi),Pd=o(Qi,"P",{});var Q_=r(Pd);p2=c(Q_,"Create new Table with the indicated column removed."),Q_.forEach(t),Qi.forEach(t),m2=l(w),aa=o(w,"DIV",{class:!0});var Zi=r(aa);m(Ar.$$.fragment,Zi),b2=l(Zi),Ld=o(Zi,"P",{});var Z_=r(Ld);h2=c(Z_,"Replace column in Table at position."),Z_.forEach(t),Zi.forEach(t),u2=l(w),oa=o(w,"DIV",{class:!0});var ep=r(oa);m(Nr.$$.fragment,ep),g2=l(ep),Ad=o(ep,"P",{});var e0=r(Ad);f2=c(e0,"Create new table with columns renamed to provided names."),e0.forEach(t),ep.forEach(t),y2=l(w),ee=o(w,"DIV",{class:!0});var Mn=r(ee);m(jr.$$.fragment,Mn),v2=l(Mn),Nd=o(Mn,"P",{});var t0=r(Nd);$2=c(t0,"Select columns of the table."),t0.forEach(t),_2=l(Mn),jd=o(Mn,"P",{});var a0=r(jd);w2=c(a0,"Returns a new table with the specified columns, and metadata preserved."),a0.forEach(t),Mn.forEach(t),T2=l(w),ra=o(w,"DIV",{class:!0});var tp=r(ra);m(Fr.$$.fragment,tp),E2=l(tp),Fd=o(tp,"P",{});var o0=r(Fd);x2=c(o0,"Drop one or more columns and return a new table."),o0.forEach(t),tp.forEach(t),D2=l(w),Qr=o(w,"DIV",{class:!0});var r0=r(Qr);m(Vr.$$.fragment,r0),r0.forEach(t),k2=l(w),na=o(w,"DIV",{class:!0});var ap=r(na);m(Sr.$$.fragment,ap),I2=l(ap),Or=o(ap,"P",{});var op=r(Or);M2=c(op,"Create "),Vd=o(op,"CODE",{});var n0=r(Vd);C2=c(n0,"ConcatenationTable"),n0.forEach(t),P2=c(op," from list of tables."),op.forEach(t),ap.forEach(t),w.forEach(t),ec=l(n),ye=o(n,"H2",{class:!0});var rp=r(ye);sa=o(rp,"A",{id:!0,class:!0,href:!0});var s0=r(sa);Sd=o(s0,"SPAN",{});var l0=r(Sd);m(Rr.$$.fragment,l0),l0.forEach(t),s0.forEach(t),L2=l(rp),Od=o(rp,"SPAN",{});var d0=r(Od);A2=c(d0,"Utils"),d0.forEach(t),rp.forEach(t),tc=l(n),ve=o(n,"DIV",{class:!0});var np=r(ve);m(qr.$$.fragment,np),N2=l(np),Rd=o(np,"P",{});var c0=r(Rd);j2=c(c0,"Concatenate tables."),c0.forEach(t),np.forEach(t),ac=l(n),$e=o(n,"DIV",{class:!0});var sp=r($e);m(Ur.$$.fragment,sp),F2=l(sp),qd=o(sp,"P",{});var i0=r(qd);V2=c(i0,`Get the cache files that are loaded by the table.
Cache file are used when parts of the table come from the disk via memory mapping.`),i0.forEach(t),sp.forEach(t),this.h()},h(){i(M,"name","hf:doc:metadata"),i(M,"content",JSON.stringify(_0)),i(C,"id","table-classes"),i(C,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),i(C,"href","#table-classes"),i(P,"class","relative group"),i(Br,"href","/docs/datasets/v2.8.0/en/package_reference/table_classes#datasets.table.Table"),i(we,"id","datasets.table.Table"),i(we,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),i(we,"href","#datasets.table.Table"),i(ae,"class","relative group"),i(S,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Te,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Ee,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(xe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(De,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Wr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(ke,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Ie,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Me,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Ce,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Pe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Le,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(O,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Ae,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Ne,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(E,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(je,"id","datasets.table.InMemoryTable"),i(je,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),i(je,"href","#datasets.table.InMemoryTable"),i(se,"class","relative group"),i(R,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Ve,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Se,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Oe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Re,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Xr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(qe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Ue,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(ze,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Be,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(We,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Xe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(q,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(He,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Ke,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Ge,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Ye,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Je,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Qe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(U,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Ze,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(et,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(z,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(tt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(at,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(ot,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(rt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(B,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(nt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Hr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Kr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(L,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(lt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(dt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(ct,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(y,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(it,"id","datasets.table.MemoryMappedTable"),i(it,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),i(it,"href","#datasets.table.MemoryMappedTable"),i(pe,"class","relative group"),i(W,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(mt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(bt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(ht,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(ut,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Gr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(gt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(ft,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(yt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(vt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i($t,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(_t,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(X,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(wt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Tt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Et,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(xt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Dt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(kt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(H,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(It,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Mt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(K,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Ct,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Pt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Lt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(At,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(G,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Nt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Yr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(_,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(jt,"id","datasets.table.ConcatenationTable"),i(jt,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),i(jt,"href","#datasets.table.ConcatenationTable"),i(he,"class","relative group"),i(Y,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Ft,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Vt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(St,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Ot,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Jr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Rt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(qt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Ut,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(zt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Bt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Wt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(J,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Xt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Ht,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Kt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Gt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Yt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Jt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Q,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Qt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Zt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Z,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(ea,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(ta,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(aa,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(oa,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(ee,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(ra,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(Qr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(na,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(v,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i(sa,"id","datasets.table.concat_tables"),i(sa,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),i(sa,"href","#datasets.table.concat_tables"),i(ye,"class","relative group"),i(ve,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),i($e,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8")},m(n,D){e(document.head,M),k(n,_e,D),k(n,P,D),e(P,C),e(C,j),b(I,j,null),e(P,F),e(P,Pn),e(Pn,lp),k(n,Wd,D),k(n,V,D),e(V,dp),e(V,Ln),e(Ln,cp),e(V,ip),e(V,Br),e(Br,pp),e(V,mp),k(n,Xd,D),k(n,ae,D),e(ae,we),e(we,An),b(ca,An,null),e(ae,bp),e(ae,Nn),e(Nn,hp),k(n,Hd,D),k(n,E,D),b(ia,E,null),e(E,up),e(E,A),e(A,gp),e(A,jn),e(jn,fp),e(A,yp),e(A,Fn),e(Fn,vp),e(A,$p),e(A,Vn),e(Vn,_p),e(A,wp),e(E,Tp),e(E,oe),e(oe,Ep),e(oe,Sn),e(Sn,xp),e(oe,Dp),e(oe,On),e(On,kp),e(oe,Ip),e(E,Mp),e(E,Rn),e(Rn,Cp),e(E,Pp),e(E,S),b(pa,S,null),e(S,Lp),e(S,qn),e(qn,Ap),e(S,Np),e(S,re),e(re,jp),e(re,Un),e(Un,Fp),e(re,Vp),e(re,zn),e(zn,Sp),e(re,Op),e(E,Rp),e(E,Te),b(ma,Te,null),e(Te,qp),e(Te,Bn),e(Bn,Up),e(E,zp),e(E,Ee),b(ba,Ee,null),e(Ee,Bp),e(Ee,ha),e(ha,Wp),e(ha,Wn),e(Wn,Xp),e(ha,Hp),e(E,Kp),e(E,xe),b(ua,xe,null),e(xe,Gp),e(xe,ne),e(ne,Yp),e(ne,Xn),e(Xn,Jp),e(ne,Qp),e(ne,Hn),e(Hn,Zp),e(ne,em),e(E,tm),e(E,De),b(ga,De,null),e(De,am),e(De,Kn),e(Kn,om),e(E,rm),e(E,Wr),b(fa,Wr,null),e(E,nm),e(E,ke),b(ya,ke,null),e(ke,sm),e(ke,Gn),e(Gn,lm),e(E,dm),e(E,Ie),b(va,Ie,null),e(Ie,cm),e(Ie,Yn),e(Yn,im),e(E,pm),e(E,Me),b($a,Me,null),e(Me,mm),e(Me,Jn),e(Jn,bm),e(E,hm),e(E,Ce),b(_a,Ce,null),e(Ce,um),e(Ce,Qn),e(Qn,gm),e(E,fm),e(E,Pe),b(wa,Pe,null),e(Pe,ym),e(Pe,Zn),e(Zn,vm),e(E,$m),e(E,Le),b(Ta,Le,null),e(Le,_m),e(Le,es),e(es,wm),e(E,Tm),e(E,O),b(Ea,O,null),e(O,Em),e(O,ts),e(ts,xm),e(O,Dm),e(O,as),e(as,km),e(E,Im),e(E,Ae),b(xa,Ae,null),e(Ae,Mm),e(Ae,os),e(os,Cm),e(E,Pm),e(E,Ne),b(Da,Ne,null),e(Ne,Lm),e(Ne,rs),e(rs,Am),k(n,Kd,D),k(n,se,D),e(se,je),e(je,ns),b(ka,ns,null),e(se,Nm),e(se,ss),e(ss,jm),k(n,Gd,D),k(n,y,D),b(Ia,y,null),e(y,Fm),e(y,ls),e(ls,Vm),e(y,Sm),e(y,ds),e(ds,Om),e(y,Rm),e(y,le),e(le,qm),e(le,cs),e(cs,Um),e(le,zm),e(le,is),e(is,Bm),e(le,Wm),e(y,Xm),e(y,Fe),e(Fe,ps),e(ps,Hm),e(Fe,Km),e(Fe,ms),e(ms,Gm),e(Fe,Ym),e(y,Jm),e(y,R),b(Ma,R,null),e(R,Qm),e(R,bs),e(bs,Zm),e(R,eb),e(R,de),e(de,tb),e(de,hs),e(hs,ab),e(de,ob),e(de,us),e(us,rb),e(de,nb),e(y,sb),e(y,Ve),b(Ca,Ve,null),e(Ve,lb),e(Ve,gs),e(gs,db),e(y,cb),e(y,Se),b(Pa,Se,null),e(Se,ib),e(Se,La),e(La,pb),e(La,fs),e(fs,mb),e(La,bb),e(y,hb),e(y,Oe),b(Aa,Oe,null),e(Oe,ub),e(Oe,ce),e(ce,gb),e(ce,ys),e(ys,fb),e(ce,yb),e(ce,vs),e(vs,vb),e(ce,$b),e(y,_b),e(y,Re),b(Na,Re,null),e(Re,wb),e(Re,$s),e($s,Tb),e(y,Eb),e(y,Xr),b(ja,Xr,null),e(y,xb),e(y,qe),b(Fa,qe,null),e(qe,Db),e(qe,_s),e(_s,kb),e(y,Ib),e(y,Ue),b(Va,Ue,null),e(Ue,Mb),e(Ue,ws),e(ws,Cb),e(y,Pb),e(y,ze),b(Sa,ze,null),e(ze,Lb),e(ze,Ts),e(Ts,Ab),e(y,Nb),e(y,Be),b(Oa,Be,null),e(Be,jb),e(Be,Es),e(Es,Fb),e(y,Vb),e(y,We),b(Ra,We,null),e(We,Sb),e(We,xs),e(xs,Ob),e(y,Rb),e(y,Xe),b(qa,Xe,null),e(Xe,qb),e(Xe,Ds),e(Ds,Ub),e(y,zb),e(y,q),b(Ua,q,null),e(q,Bb),e(q,ks),e(ks,Wb),e(q,Xb),e(q,Is),e(Is,Hb),e(y,Kb),e(y,He),b(za,He,null),e(He,Gb),e(He,Ms),e(Ms,Yb),e(y,Jb),e(y,Ke),b(Ba,Ke,null),e(Ke,Qb),e(Ke,Cs),e(Cs,Zb),e(y,eh),e(y,Ge),b(Wa,Ge,null),e(Ge,th),e(Ge,Ps),e(Ps,ah),e(y,oh),e(y,Ye),b(Xa,Ye,null),e(Ye,rh),e(Ye,Ls),e(Ls,nh),e(y,sh),e(y,Je),b(Ha,Je,null),e(Je,lh),e(Je,Ka),e(Ka,dh),e(Ka,As),e(As,ch),e(Ka,ih),e(y,ph),e(y,Qe),b(Ga,Qe,null),e(Qe,mh),e(Qe,Ns),e(Ns,bh),e(y,hh),e(y,U),b(Ya,U,null),e(U,uh),e(U,js),e(js,gh),e(U,fh),e(U,Ja),e(Ja,yh),e(Ja,Fs),e(Fs,vh),e(Ja,$h),e(y,_h),e(y,Ze),b(Qa,Ze,null),e(Ze,wh),e(Ze,Vs),e(Vs,Th),e(y,Eh),e(y,et),b(Za,et,null),e(et,xh),e(et,eo),e(eo,Dh),e(eo,Ss),e(Ss,kh),e(eo,Ih),e(y,Mh),e(y,z),b(to,z,null),e(z,Ch),e(z,Os),e(Os,Ph),e(z,Lh),e(z,Rs),e(Rs,Ah),e(y,Nh),e(y,tt),b(ao,tt,null),e(tt,jh),e(tt,qs),e(qs,Fh),e(y,Vh),e(y,at),b(oo,at,null),e(at,Sh),e(at,Us),e(Us,Oh),e(y,Rh),e(y,ot),b(ro,ot,null),e(ot,qh),e(ot,zs),e(zs,Uh),e(y,zh),e(y,rt),b(no,rt,null),e(rt,Bh),e(rt,Bs),e(Bs,Wh),e(y,Xh),e(y,B),b(so,B,null),e(B,Hh),e(B,Ws),e(Ws,Kh),e(B,Gh),e(B,Xs),e(Xs,Yh),e(y,Jh),e(y,nt),b(lo,nt,null),e(nt,Qh),e(nt,Hs),e(Hs,Zh),e(y,eu),e(y,Hr),b(co,Hr,null),e(y,tu),e(y,Kr),b(io,Kr,null),e(y,au),e(y,L),b(po,L,null),e(L,ou),e(L,Ks),e(Ks,ru),e(L,nu),e(L,mo),e(mo,su),e(mo,Gs),e(Gs,lu),e(mo,du),e(L,cu),e(L,ie),e(ie,iu),e(ie,Ys),e(Ys,pu),e(ie,mu),e(ie,Js),e(Js,bu),e(ie,hu),e(L,uu),b(st,L,null),e(y,gu),e(y,lt),b(bo,lt,null),e(lt,fu),e(lt,Qs),e(Qs,yu),e(y,vu),e(y,dt),b(ho,dt,null),e(dt,$u),e(dt,Zs),e(Zs,_u),e(y,wu),e(y,ct),b(uo,ct,null),e(ct,Tu),e(ct,go),e(go,Eu),e(go,el),e(el,xu),e(go,Du),k(n,Yd,D),k(n,pe,D),e(pe,it),e(it,tl),b(fo,tl,null),e(pe,ku),e(pe,al),e(al,Iu),k(n,Jd,D),k(n,_,D),b(yo,_,null),e(_,Mu),e(_,ol),e(ol,Cu),e(_,Pu),e(_,rl),e(rl,Lu),e(_,Au),e(_,nl),e(nl,Nu),e(_,ju),e(_,vo),e(vo,Fu),e(vo,sl),e(sl,Vu),e(vo,Su),e(_,Ou),e(_,pt),e(pt,ll),e(ll,Ru),e(pt,qu),e(pt,dl),e(dl,Uu),e(pt,zu),e(_,Bu),e(_,W),b($o,W,null),e(W,Wu),e(W,cl),e(cl,Xu),e(W,Hu),e(W,me),e(me,Ku),e(me,il),e(il,Gu),e(me,Yu),e(me,pl),e(pl,Ju),e(me,Qu),e(_,Zu),e(_,mt),b(_o,mt,null),e(mt,eg),e(mt,ml),e(ml,tg),e(_,ag),e(_,bt),b(wo,bt,null),e(bt,og),e(bt,To),e(To,rg),e(To,bl),e(bl,ng),e(To,sg),e(_,lg),e(_,ht),b(Eo,ht,null),e(ht,dg),e(ht,be),e(be,cg),e(be,hl),e(hl,ig),e(be,pg),e(be,ul),e(ul,mg),e(be,bg),e(_,hg),e(_,ut),b(xo,ut,null),e(ut,ug),e(ut,gl),e(gl,gg),e(_,fg),e(_,Gr),b(Do,Gr,null),e(_,yg),e(_,gt),b(ko,gt,null),e(gt,vg),e(gt,fl),e(fl,$g),e(_,_g),e(_,ft),b(Io,ft,null),e(ft,wg),e(ft,yl),e(yl,Tg),e(_,Eg),e(_,yt),b(Mo,yt,null),e(yt,xg),e(yt,vl),e(vl,Dg),e(_,kg),e(_,vt),b(Co,vt,null),e(vt,Ig),e(vt,$l),e($l,Mg),e(_,Cg),e(_,$t),b(Po,$t,null),e($t,Pg),e($t,_l),e(_l,Lg),e(_,Ag),e(_,_t),b(Lo,_t,null),e(_t,Ng),e(_t,wl),e(wl,jg),e(_,Fg),e(_,X),b(Ao,X,null),e(X,Vg),e(X,Tl),e(Tl,Sg),e(X,Og),e(X,El),e(El,Rg),e(_,qg),e(_,wt),b(No,wt,null),e(wt,Ug),e(wt,xl),e(xl,zg),e(_,Bg),e(_,Tt),b(jo,Tt,null),e(Tt,Wg),e(Tt,Dl),e(Dl,Xg),e(_,Hg),e(_,Et),b(Fo,Et,null),e(Et,Kg),e(Et,kl),e(kl,Gg),e(_,Yg),e(_,xt),b(Vo,xt,null),e(xt,Jg),e(xt,Il),e(Il,Qg),e(_,Zg),e(_,Dt),b(So,Dt,null),e(Dt,ef),e(Dt,Oo),e(Oo,tf),e(Oo,Ml),e(Ml,af),e(Oo,of),e(_,rf),e(_,kt),b(Ro,kt,null),e(kt,nf),e(kt,Cl),e(Cl,sf),e(_,lf),e(_,H),b(qo,H,null),e(H,df),e(H,Pl),e(Pl,cf),e(H,pf),e(H,Ll),e(Ll,mf),e(_,bf),e(_,It),b(Uo,It,null),e(It,hf),e(It,Al),e(Al,uf),e(_,gf),e(_,Mt),b(zo,Mt,null),e(Mt,ff),e(Mt,Nl),e(Nl,yf),e(_,vf),e(_,K),b(Bo,K,null),e(K,$f),e(K,jl),e(jl,_f),e(K,wf),e(K,Fl),e(Fl,Tf),e(_,Ef),e(_,Ct),b(Wo,Ct,null),e(Ct,xf),e(Ct,Vl),e(Vl,Df),e(_,kf),e(_,Pt),b(Xo,Pt,null),e(Pt,If),e(Pt,Sl),e(Sl,Mf),e(_,Cf),e(_,Lt),b(Ho,Lt,null),e(Lt,Pf),e(Lt,Ol),e(Ol,Lf),e(_,Af),e(_,At),b(Ko,At,null),e(At,Nf),e(At,Rl),e(Rl,jf),e(_,Ff),e(_,G),b(Go,G,null),e(G,Vf),e(G,ql),e(ql,Sf),e(G,Of),e(G,Ul),e(Ul,Rf),e(_,qf),e(_,Nt),b(Yo,Nt,null),e(Nt,Uf),e(Nt,zl),e(zl,zf),e(_,Bf),e(_,Yr),b(Jo,Yr,null),k(n,Qd,D),k(n,he,D),e(he,jt),e(jt,Bl),b(Qo,Bl,null),e(he,Wf),e(he,Wl),e(Wl,Xf),k(n,Zd,D),k(n,v,D),b(Zo,v,null),e(v,Hf),e(v,Xl),e(Xl,Kf),e(v,Gf),e(v,N),e(N,Yf),e(N,Hl),e(Hl,Jf),e(N,Qf),e(N,Kl),e(Kl,Zf),e(N,ey),e(N,Gl),e(Gl,ty),e(N,ay),e(v,oy),e(v,er),e(er,tr),e(tr,ry),e(tr,Yl),e(Yl,ny),e(tr,sy),e(er,ly),e(er,Jl),e(Jl,dy),e(v,cy),e(v,ar),e(ar,iy),e(ar,Ql),e(Ql,py),e(ar,my),e(v,by),e(v,or),e(or,hy),e(or,Zl),e(Zl,uy),e(or,gy),e(v,fy),e(v,ue),e(ue,yy),e(ue,ed),e(ed,vy),e(ue,$y),e(ue,td),e(td,_y),e(ue,wy),e(v,Ty),e(v,Y),b(rr,Y,null),e(Y,Ey),e(Y,ad),e(ad,xy),e(Y,Dy),e(Y,ge),e(ge,ky),e(ge,od),e(od,Iy),e(ge,My),e(ge,rd),e(rd,Cy),e(ge,Py),e(v,Ly),e(v,Ft),b(nr,Ft,null),e(Ft,Ay),e(Ft,nd),e(nd,Ny),e(v,jy),e(v,Vt),b(sr,Vt,null),e(Vt,Fy),e(Vt,lr),e(lr,Vy),e(lr,sd),e(sd,Sy),e(lr,Oy),e(v,Ry),e(v,St),b(dr,St,null),e(St,qy),e(St,fe),e(fe,Uy),e(fe,ld),e(ld,zy),e(fe,By),e(fe,dd),e(dd,Wy),e(fe,Xy),e(v,Hy),e(v,Ot),b(cr,Ot,null),e(Ot,Ky),e(Ot,cd),e(cd,Gy),e(v,Yy),e(v,Jr),b(ir,Jr,null),e(v,Jy),e(v,Rt),b(pr,Rt,null),e(Rt,Qy),e(Rt,id),e(id,Zy),e(v,ev),e(v,qt),b(mr,qt,null),e(qt,tv),e(qt,pd),e(pd,av),e(v,ov),e(v,Ut),b(br,Ut,null),e(Ut,rv),e(Ut,md),e(md,nv),e(v,sv),e(v,zt),b(hr,zt,null),e(zt,lv),e(zt,bd),e(bd,dv),e(v,cv),e(v,Bt),b(ur,Bt,null),e(Bt,iv),e(Bt,hd),e(hd,pv),e(v,mv),e(v,Wt),b(gr,Wt,null),e(Wt,bv),e(Wt,ud),e(ud,hv),e(v,uv),e(v,J),b(fr,J,null),e(J,gv),e(J,gd),e(gd,fv),e(J,yv),e(J,fd),e(fd,vv),e(v,$v),e(v,Xt),b(yr,Xt,null),e(Xt,_v),e(Xt,yd),e(yd,wv),e(v,Tv),e(v,Ht),b(vr,Ht,null),e(Ht,Ev),e(Ht,vd),e(vd,xv),e(v,Dv),e(v,Kt),b($r,Kt,null),e(Kt,kv),e(Kt,$d),e($d,Iv),e(v,Mv),e(v,Gt),b(_r,Gt,null),e(Gt,Cv),e(Gt,_d),e(_d,Pv),e(v,Lv),e(v,Yt),b(wr,Yt,null),e(Yt,Av),e(Yt,Tr),e(Tr,Nv),e(Tr,wd),e(wd,jv),e(Tr,Fv),e(v,Vv),e(v,Jt),b(Er,Jt,null),e(Jt,Sv),e(Jt,Td),e(Td,Ov),e(v,Rv),e(v,Q),b(xr,Q,null),e(Q,qv),e(Q,Ed),e(Ed,Uv),e(Q,zv),e(Q,Dr),e(Dr,Bv),e(Dr,xd),e(xd,Wv),e(Dr,Xv),e(v,Hv),e(v,Qt),b(kr,Qt,null),e(Qt,Kv),e(Qt,Dd),e(Dd,Gv),e(v,Yv),e(v,Zt),b(Ir,Zt,null),e(Zt,Jv),e(Zt,Mr),e(Mr,Qv),e(Mr,kd),e(kd,Zv),e(Mr,e2),e(v,t2),e(v,Z),b(Cr,Z,null),e(Z,a2),e(Z,Id),e(Id,o2),e(Z,r2),e(Z,Md),e(Md,n2),e(v,s2),e(v,ea),b(Pr,ea,null),e(ea,l2),e(ea,Cd),e(Cd,d2),e(v,c2),e(v,ta),b(Lr,ta,null),e(ta,i2),e(ta,Pd),e(Pd,p2),e(v,m2),e(v,aa),b(Ar,aa,null),e(aa,b2),e(aa,Ld),e(Ld,h2),e(v,u2),e(v,oa),b(Nr,oa,null),e(oa,g2),e(oa,Ad),e(Ad,f2),e(v,y2),e(v,ee),b(jr,ee,null),e(ee,v2),e(ee,Nd),e(Nd,$2),e(ee,_2),e(ee,jd),e(jd,w2),e(v,T2),e(v,ra),b(Fr,ra,null),e(ra,E2),e(ra,Fd),e(Fd,x2),e(v,D2),e(v,Qr),b(Vr,Qr,null),e(v,k2),e(v,na),b(Sr,na,null),e(na,I2),e(na,Or),e(Or,M2),e(Or,Vd),e(Vd,C2),e(Or,P2),k(n,ec,D),k(n,ye,D),e(ye,sa),e(sa,Sd),b(Rr,Sd,null),e(ye,L2),e(ye,Od),e(Od,A2),k(n,tc,D),k(n,ve,D),b(qr,ve,null),e(ve,N2),e(ve,Rd),e(Rd,j2),k(n,ac,D),k(n,$e,D),b(Ur,$e,null),e($e,F2),e($e,qd),e(qd,V2),oc=!0},p(n,[D]){const zr={};D&2&&(zr.$$scope={dirty:D,ctx:n}),st.$set(zr)},i(n){oc||(h(I.$$.fragment,n),h(ca.$$.fragment,n),h(ia.$$.fragment,n),h(pa.$$.fragment,n),h(ma.$$.fragment,n),h(ba.$$.fragment,n),h(ua.$$.fragment,n),h(ga.$$.fragment,n),h(fa.$$.fragment,n),h(ya.$$.fragment,n),h(va.$$.fragment,n),h($a.$$.fragment,n),h(_a.$$.fragment,n),h(wa.$$.fragment,n),h(Ta.$$.fragment,n),h(Ea.$$.fragment,n),h(xa.$$.fragment,n),h(Da.$$.fragment,n),h(ka.$$.fragment,n),h(Ia.$$.fragment,n),h(Ma.$$.fragment,n),h(Ca.$$.fragment,n),h(Pa.$$.fragment,n),h(Aa.$$.fragment,n),h(Na.$$.fragment,n),h(ja.$$.fragment,n),h(Fa.$$.fragment,n),h(Va.$$.fragment,n),h(Sa.$$.fragment,n),h(Oa.$$.fragment,n),h(Ra.$$.fragment,n),h(qa.$$.fragment,n),h(Ua.$$.fragment,n),h(za.$$.fragment,n),h(Ba.$$.fragment,n),h(Wa.$$.fragment,n),h(Xa.$$.fragment,n),h(Ha.$$.fragment,n),h(Ga.$$.fragment,n),h(Ya.$$.fragment,n),h(Qa.$$.fragment,n),h(Za.$$.fragment,n),h(to.$$.fragment,n),h(ao.$$.fragment,n),h(oo.$$.fragment,n),h(ro.$$.fragment,n),h(no.$$.fragment,n),h(so.$$.fragment,n),h(lo.$$.fragment,n),h(co.$$.fragment,n),h(io.$$.fragment,n),h(po.$$.fragment,n),h(st.$$.fragment,n),h(bo.$$.fragment,n),h(ho.$$.fragment,n),h(uo.$$.fragment,n),h(fo.$$.fragment,n),h(yo.$$.fragment,n),h($o.$$.fragment,n),h(_o.$$.fragment,n),h(wo.$$.fragment,n),h(Eo.$$.fragment,n),h(xo.$$.fragment,n),h(Do.$$.fragment,n),h(ko.$$.fragment,n),h(Io.$$.fragment,n),h(Mo.$$.fragment,n),h(Co.$$.fragment,n),h(Po.$$.fragment,n),h(Lo.$$.fragment,n),h(Ao.$$.fragment,n),h(No.$$.fragment,n),h(jo.$$.fragment,n),h(Fo.$$.fragment,n),h(Vo.$$.fragment,n),h(So.$$.fragment,n),h(Ro.$$.fragment,n),h(qo.$$.fragment,n),h(Uo.$$.fragment,n),h(zo.$$.fragment,n),h(Bo.$$.fragment,n),h(Wo.$$.fragment,n),h(Xo.$$.fragment,n),h(Ho.$$.fragment,n),h(Ko.$$.fragment,n),h(Go.$$.fragment,n),h(Yo.$$.fragment,n),h(Jo.$$.fragment,n),h(Qo.$$.fragment,n),h(Zo.$$.fragment,n),h(rr.$$.fragment,n),h(nr.$$.fragment,n),h(sr.$$.fragment,n),h(dr.$$.fragment,n),h(cr.$$.fragment,n),h(ir.$$.fragment,n),h(pr.$$.fragment,n),h(mr.$$.fragment,n),h(br.$$.fragment,n),h(hr.$$.fragment,n),h(ur.$$.fragment,n),h(gr.$$.fragment,n),h(fr.$$.fragment,n),h(yr.$$.fragment,n),h(vr.$$.fragment,n),h($r.$$.fragment,n),h(_r.$$.fragment,n),h(wr.$$.fragment,n),h(Er.$$.fragment,n),h(xr.$$.fragment,n),h(kr.$$.fragment,n),h(Ir.$$.fragment,n),h(Cr.$$.fragment,n),h(Pr.$$.fragment,n),h(Lr.$$.fragment,n),h(Ar.$$.fragment,n),h(Nr.$$.fragment,n),h(jr.$$.fragment,n),h(Fr.$$.fragment,n),h(Vr.$$.fragment,n),h(Sr.$$.fragment,n),h(Rr.$$.fragment,n),h(qr.$$.fragment,n),h(Ur.$$.fragment,n),oc=!0)},o(n){u(I.$$.fragment,n),u(ca.$$.fragment,n),u(ia.$$.fragment,n),u(pa.$$.fragment,n),u(ma.$$.fragment,n),u(ba.$$.fragment,n),u(ua.$$.fragment,n),u(ga.$$.fragment,n),u(fa.$$.fragment,n),u(ya.$$.fragment,n),u(va.$$.fragment,n),u($a.$$.fragment,n),u(_a.$$.fragment,n),u(wa.$$.fragment,n),u(Ta.$$.fragment,n),u(Ea.$$.fragment,n),u(xa.$$.fragment,n),u(Da.$$.fragment,n),u(ka.$$.fragment,n),u(Ia.$$.fragment,n),u(Ma.$$.fragment,n),u(Ca.$$.fragment,n),u(Pa.$$.fragment,n),u(Aa.$$.fragment,n),u(Na.$$.fragment,n),u(ja.$$.fragment,n),u(Fa.$$.fragment,n),u(Va.$$.fragment,n),u(Sa.$$.fragment,n),u(Oa.$$.fragment,n),u(Ra.$$.fragment,n),u(qa.$$.fragment,n),u(Ua.$$.fragment,n),u(za.$$.fragment,n),u(Ba.$$.fragment,n),u(Wa.$$.fragment,n),u(Xa.$$.fragment,n),u(Ha.$$.fragment,n),u(Ga.$$.fragment,n),u(Ya.$$.fragment,n),u(Qa.$$.fragment,n),u(Za.$$.fragment,n),u(to.$$.fragment,n),u(ao.$$.fragment,n),u(oo.$$.fragment,n),u(ro.$$.fragment,n),u(no.$$.fragment,n),u(so.$$.fragment,n),u(lo.$$.fragment,n),u(co.$$.fragment,n),u(io.$$.fragment,n),u(po.$$.fragment,n),u(st.$$.fragment,n),u(bo.$$.fragment,n),u(ho.$$.fragment,n),u(uo.$$.fragment,n),u(fo.$$.fragment,n),u(yo.$$.fragment,n),u($o.$$.fragment,n),u(_o.$$.fragment,n),u(wo.$$.fragment,n),u(Eo.$$.fragment,n),u(xo.$$.fragment,n),u(Do.$$.fragment,n),u(ko.$$.fragment,n),u(Io.$$.fragment,n),u(Mo.$$.fragment,n),u(Co.$$.fragment,n),u(Po.$$.fragment,n),u(Lo.$$.fragment,n),u(Ao.$$.fragment,n),u(No.$$.fragment,n),u(jo.$$.fragment,n),u(Fo.$$.fragment,n),u(Vo.$$.fragment,n),u(So.$$.fragment,n),u(Ro.$$.fragment,n),u(qo.$$.fragment,n),u(Uo.$$.fragment,n),u(zo.$$.fragment,n),u(Bo.$$.fragment,n),u(Wo.$$.fragment,n),u(Xo.$$.fragment,n),u(Ho.$$.fragment,n),u(Ko.$$.fragment,n),u(Go.$$.fragment,n),u(Yo.$$.fragment,n),u(Jo.$$.fragment,n),u(Qo.$$.fragment,n),u(Zo.$$.fragment,n),u(rr.$$.fragment,n),u(nr.$$.fragment,n),u(sr.$$.fragment,n),u(dr.$$.fragment,n),u(cr.$$.fragment,n),u(ir.$$.fragment,n),u(pr.$$.fragment,n),u(mr.$$.fragment,n),u(br.$$.fragment,n),u(hr.$$.fragment,n),u(ur.$$.fragment,n),u(gr.$$.fragment,n),u(fr.$$.fragment,n),u(yr.$$.fragment,n),u(vr.$$.fragment,n),u($r.$$.fragment,n),u(_r.$$.fragment,n),u(wr.$$.fragment,n),u(Er.$$.fragment,n),u(xr.$$.fragment,n),u(kr.$$.fragment,n),u(Ir.$$.fragment,n),u(Cr.$$.fragment,n),u(Pr.$$.fragment,n),u(Lr.$$.fragment,n),u(Ar.$$.fragment,n),u(Nr.$$.fragment,n),u(jr.$$.fragment,n),u(Fr.$$.fragment,n),u(Vr.$$.fragment,n),u(Sr.$$.fragment,n),u(Rr.$$.fragment,n),u(qr.$$.fragment,n),u(Ur.$$.fragment,n),oc=!1},d(n){t(M),n&&t(_e),n&&t(P),g(I),n&&t(Wd),n&&t(V),n&&t(Xd),n&&t(ae),g(ca),n&&t(Hd),n&&t(E),g(ia),g(pa),g(ma),g(ba),g(ua),g(ga),g(fa),g(ya),g(va),g($a),g(_a),g(wa),g(Ta),g(Ea),g(xa),g(Da),n&&t(Kd),n&&t(se),g(ka),n&&t(Gd),n&&t(y),g(Ia),g(Ma),g(Ca),g(Pa),g(Aa),g(Na),g(ja),g(Fa),g(Va),g(Sa),g(Oa),g(Ra),g(qa),g(Ua),g(za),g(Ba),g(Wa),g(Xa),g(Ha),g(Ga),g(Ya),g(Qa),g(Za),g(to),g(ao),g(oo),g(ro),g(no),g(so),g(lo),g(co),g(io),g(po),g(st),g(bo),g(ho),g(uo),n&&t(Yd),n&&t(pe),g(fo),n&&t(Jd),n&&t(_),g(yo),g($o),g(_o),g(wo),g(Eo),g(xo),g(Do),g(ko),g(Io),g(Mo),g(Co),g(Po),g(Lo),g(Ao),g(No),g(jo),g(Fo),g(Vo),g(So),g(Ro),g(qo),g(Uo),g(zo),g(Bo),g(Wo),g(Xo),g(Ho),g(Ko),g(Go),g(Yo),g(Jo),n&&t(Qd),n&&t(he),g(Qo),n&&t(Zd),n&&t(v),g(Zo),g(rr),g(nr),g(sr),g(dr),g(cr),g(ir),g(pr),g(mr),g(br),g(hr),g(ur),g(gr),g(fr),g(yr),g(vr),g($r),g(_r),g(wr),g(Er),g(xr),g(kr),g(Ir),g(Cr),g(Pr),g(Lr),g(Ar),g(Nr),g(jr),g(Fr),g(Vr),g(Sr),n&&t(ec),n&&t(ye),g(Rr),n&&t(tc),n&&t(ve),g(qr),n&&t(ac),n&&t($e),g(Ur)}}}const _0={local:"table-classes",sections:[{local:"datasets.table.Table",title:"Table"},{local:"datasets.table.InMemoryTable",title:"InMemoryTable"},{local:"datasets.table.MemoryMappedTable",title:"MemoryMappedTable"},{local:"datasets.table.ConcatenationTable",title:"ConcatenationTable"},{local:"datasets.table.concat_tables",title:"Utils"}],title:"Table Classes"};function w0(Bd){return u0(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class I0 extends p0{constructor(M){super();m0(this,M,w0,$0,b0,{})}}export{I0 as default,_0 as metadata};
