d1dZddlZddlZddlZddlZddlZddlmZddlm Z ddl Z ddl ZddlmZddlmZmZddlmZdd lmZdd lmZmZmZdd lmZmZmZm Z!dd l"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(ddl)m*Z*m+Z+m,Z,m-Z-m.Z.ddl/m0Z0ddl1m2Z2m3Z3ddl4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:dZ;e;rddlme?ej@e jAjBejCe jAjBejDe jAjBejEe jAjFejGe jAjBejHe jAjBejIe jAjFejJe jAjFejKeLejMe jAjNejOePejQePejReSiZTeUeTejV<eWedr eLeTejX<eWedre jAjNeTejY<eWedre jAjNeTejZ<eWedr ePeTej[<eWedr ePeTej\<ej]edj^j_Z`dZadZbdZcdZddZedZfd Zgd!Zhd"Zid#Zjd$ZkGd%d&elZmGd'd(ejne#ZnGd)d*ZoGd+d,ZpdS)-z Here is defined the Table class.N)Path) perf_counter)tableextension) ObjectCacheNumCache)Atom)compile_condition) flavor_ofarray_as_internalinternal_to_flavor)is_idxlazyattrSizeType NailedDict)Leaf) IsDescription DescriptionColdescr_from_dtype) NodeError HDF5ExtErrorPerformanceWarningOldIndexWarningNoSuchNodeError)get_nested_field) join_path split_path)OldIndexdefault_index_filtersdefault_auto_indexIndex IndexesDescG IndexesTableGF) show_statsz2.7float16float96float128 complex192 complex256cd|jzSNz_i_%s)_v_name)nodes ,lib/python3.11/site-packages/tables/table.py_index_name_ofr0Vs T\ !!cpt|jd}t|t|S)Nr)r _v_pathnamerr0)r.nodeParentPaths r/_index_pathname_ofr5Zs/ 011!4N ^^D%9%9 : ::r1c<tt||SN)rr5)table colpathnames r/_index_pathname_of_columnr:_s '.. < <hs X r1c`t|\}}t|t|Sr7)rrr>)nodePathr4r=s r/_index_pathname_of_rAls,)(33NH ^_X%>%> ? ??r1c<tt||Sr7)rrA) tablePathr9s r/_index_pathname_of_column_rDqs (33[ A AAr1c|jj}|jd}|d||jjzz }t ||f|jd|_t|d|dd|_d|_ dS)NrTABLE_MAX_SIZEztable chunk cacheITERSEQ_MAX_SLOTSITERSEQ_MAX_SIZEzIter sequence cacheF) _v_fileparams _v_chunkshape_v_dtypeitemsizer _chunkcacher _seqcache _dirtycache)selfrJ chunksizenslotss r/ restorecacherTus \ F"1%I $ %T]5K)K LF 3T] 355D (;!> vr1---Bxx7/666 Or1c`t|jt|d|jzd}|S)NzIndexes container for table T)new)r$ _v_parentr0r3)r8itgroups r/create_indexes_tablers< ..&)::FFFG Nr1c4t||d|z|d}|S)Nz&Indexes container for sub-description T)filtersr)r#)igroupdnameinameridgroups r/create_indexes_descrrs/058T###G Nr1c |j}|j}|j} |j} |j} |jj} | r4tt| dt|j d| jdddkrtd| j dkrtd| j dkrtd  | t|} n#t$rt!|} YnwxYw| }d }| j}|d krc|d }|D]K}|d kr|}n|d |zz } | | jd |}*#t$rt'||||}YHwxYw| j dksJt)jt-j| d f}|j}|j|kr|j}t3|||d |z||||||j| } ||j d|jdkr%||j d|jdd}nd}d| _||_|j|z |_| ||S)Nz for column 'zW' already exists. If you want to re-create it, please, try with reindex() method betterru8zDindexing 64-bit unsigned integer columns is not supported yet, sorrycz"complex columns can not be indexedr<z+multidimensional columns can not be indexed/)rzIndex for %s column) atomtitlekindoptlevelrtmp_dir expectedrows byteorder blocksizesTrF)lastrowupdate)verbose)!namer8rXdescrrqrI _get_node ValueErrorstrpathnameNotImplementedErrorr TypeErrorr[r5rrr3splitrr from_dtypera_v_expectedrowsrkr"r_set_column_indexing_add_rows_to_indexrr _indexedrows_unsaved_indexedrowsoptimize)rQrrrrrrrr8rXrrqget_noderrrrinamesrrr indexedrowss r/_column__create_indexrs 9D JE JE JE JE}&H F%(ZZZZT]1C1C1C1CEFF F  y}! *++ + zS<=== {bEFFF.(-e4455 ...&u--.G E H2~~$$ O OE{{u$ O"(g&9#C#CE#C#CDD" O O O.wugNN O ;"     ?28UDM22 3 3D(L {\!!{  D#d* !/   E t}d333  {Q.. M1ek4/GG  EK$E!&{!:E NN7N### s$=CC21C21EE&%E&ceZdZdZdZdS) _ColIndexesz1Provides a nice representation of column indexes.cnd|D}dd|zS)z3Gives a detailed Description column representation.c$g|] \}}d|d|S)z "z": r<).0kvs r/ z(_ColIndexes.__repr__..Fs-:::TQ a  Q  :::r1z{ %s}z, )r_join)rQreps r/__repr__z_ColIndexes.__repr__Cs6;:TZZ\\:::W\\#..//r1N)__name__ __module__ __qualname____doc__rr<r1r/rr@s);;00000r1rcFeZdZdZdZedZedZedZ edZ edZ edZ ed Z ed Zed Zejd Zed ZedZedZ dVfd ZfdZdZdZdZdZdZdZdZdZdZeZdZ dZ!dWd!Z"d"Z#d#Z$dXd$Z% dYd%Z&dZd&Z' d[d'Z( d[d(Z) d\d*Z*d+Z+d,Z, d]d-Z- d^d.Z.dZd/Z/d0Z0d_d1Z1d[d2Z2dXd3Z3dXd4Z4d5Z5d6Z6d7Z7d8Z8d9Z9d:Z:d;Z;d<ZZ> d[d?Z?d`d@Z@dAZAdZdBZBdCZCfdDZDfdEZEdafdF ZFdGZGdHZHdIZIdJZJdKZKdLZLdMZMdNZNdOZOdPZP dbfdQ ZQfdRZRdSZSd`fdT ZTdUZUxZVS)cTableaThis class represents heterogeneous datasets in an HDF5 file. Tables are leaves (see the Leaf class in :ref:`LeafClassDescr`) whose data consists of a unidimensional sequence of *rows*, where each row contains one or more *fields*. Fields have an associated unique *name* and *position*, with the first field having position 0. All rows have the same fields, which are arranged in *columns*. Fields can have any type supported by the Col class (see :ref:`ColClassDescr`) and its descendants, which support multidimensional data. Moreover, a field can be *nested* (to an arbitrary depth), meaning that it includes further fields inside. A field named x inside a nested field a in a table can be accessed as the field a/x (its *path name*) from the table. The structure of a table is declared by its description, which is made available in the Table.description attribute (see :class:`Table`). This class provides new methods to read, write and search table data efficiently. It also provides special Python methods to allow accessing the table as a normal sequence or array (with extended slicing supported). PyTables supports *in-kernel* searches working simultaneously on several columns using complex conditions. These are faster than selections using Python expressions. See the :meth:`Table.where` method for more information on in-kernel searches. Non-nested columns can be *indexed*. Searching an indexed column can be several times faster than searching a non-nested one. Search methods automatically take advantage of indexing where available. When iterating a table, an object from the Row (see :ref:`RowClassDescr`) class is used. This object allows to read and write data one row at a time, as well as to perform queries which are not supported by in-kernel syntax (at a much lower speed, of course). Objects of this class support access to individual columns via *natural naming* through the :attr:`Table.cols` accessor. Nested columns are mapped to Cols instances, and non-nested ones to Column instances. See the Column class in :ref:`ColumnClassDescr` for examples of this feature. Parameters ---------- parentnode The parent :class:`Group` object. .. versionchanged:: 3.0 Renamed from *parentNode* to *parentnode*. name : str The name of this node in its parent group. description An IsDescription subclass or a dictionary where the keys are the field names, and the values the type definitions. In addition, a pure NumPy dtype is accepted. If None, the table metadata is read from disk, else, it's taken from previous parameters. title Sets a TITLE attribute on the HDF5 table entity. filters : Filters An instance of the Filters class that provides information about the desired I/O filters to be applied during the life of this object. expectedrows A user estimate about the number of rows that will be on table. If not provided, the default value is ``EXPECTED_ROWS_TABLE`` (see ``tables/parameters.py``). If you plan to save bigger tables, try providing a guess; this will optimize the HDF5 B-Tree creation and management process time and memory used. chunkshape The shape of the data chunk to be read or written as a single HDF5 I/O operation. The filters are applied to those chunks of data. Its rank for tables has to be 1. If ``None``, a sensible value is calculated based on the `expectedrows` parameter (which is recommended). byteorder The byteorder of the data *on-disk*, specified as 'little' or 'big'. If this is not specified, the byteorder is that of the platform, unless you passed a recarray as the `description`, in which case the recarray byteorder will be chosen. track_times Whether time data associated with the leaf are recorded (object access time, raw data modification time, metadata change time, object birth time); default True. Semantics of these times depend on their implementation in the HDF5 library: refer to documentation of the H5O_info_t data structure. As of HDF5 1.8.15, only ctime (metadata change time) is implemented. .. versionadded:: 3.4.3 Notes ----- The instance variables below are provided in addition to those in Leaf (see :ref:`LeafClassDescr`). Please note that there are several col* dictionaries to ease retrieving information about a column directly by its path name, avoiding the need to walk through Table.description or Table.cols. .. rubric:: Table attributes .. attribute:: coldescrs Maps the name of a column to its Col description (see :ref:`ColClassDescr`). .. attribute:: coldflts Maps the name of a column to its default value. .. attribute:: coldtypes Maps the name of a column to its NumPy data type. .. attribute:: colindexed Is the column which name is used as a key indexed? .. attribute:: colinstances Maps the name of a column to its Column (see :ref:`ColumnClassDescr`) or Cols (see :ref:`ColsClassDescr`) instance. .. attribute:: colnames A list containing the names of *top-level* columns in the table. .. attribute:: colpathnames A list containing the pathnames of *bottom-level* columns in the table. These are the leaf columns obtained when walking the table description left-to-right, bottom-first. Columns inside a nested column have slashes (/) separating name components in their pathname. .. attribute:: cols A Cols instance that provides *natural naming* access to non-nested (Column, see :ref:`ColumnClassDescr`) and nested (Cols, see :ref:`ColsClassDescr`) columns. .. attribute:: coltypes Maps the name of a column to its PyTables data type. .. attribute:: description A Description instance (see :ref:`DescriptionClassDescr`) reflecting the structure of the table. .. attribute:: extdim The index of the enlargeable dimension (always 0 for tables). .. attribute:: indexed Does this table have any indexed columns? .. attribute:: nrows The current number of rows in the table. TABLEc*tj|S)z7The associated Row instance (see :ref:`RowClassDescr`).)rRowrQs r/rowz Table.rows!$'''r1c|jjS)z9The NumPy ``dtype`` that most closely matches this table.) descriptionrLrs r/rXz Table.dtypes((r1c|jfS)zThe shape of this table.)rkrs r/r[z Table.shapes }r1c$|jjjS)z+The size in bytes of each row in the table.)rrLrMrs r/rowsizez Table.rowsizes(11r1c |j|jzS)zThe size of this table's data in bytes when it is fully loaded into memory. This may be used in combination with size_on_disk to calculate the compression ratio of the data.)rkrrs r/size_in_memoryzTable.size_in_memory s zDL((r1c6||jS)zA buffer for doing I/O.)_get_container nrowsinbufrs r/_v_iobufzTable._v_iobufs""4?333r1c|jD] }t|tjs|rn!dS|d}|jD]\}}t||}||dd<|S)z,The defaults for writing in recarray format.Nr)coldfltsrr`rarbrr_r)rQcoldfltwdfltscolnameras r/ _v_wdfltszTable._v_wdfltss }++--  G'2:.. '  4$$Q'' $ 3 3 5 5   GW!&'22BBqqqEE r1cg|d}}|jD]>}t||}|jjs |jdkr||?t|S)z5The pathnames of unaligned, *unidimensional* columns.rr)r colpathnamesrflagsalignedndimrc frozenset)rQ colunalignedrarrr9carrs r/ _colunalignedzTable._colunaligned(sv !4!4Q!7!7d , 1 1K#D+66D:% 1$)q..##K000&&&r1c|j^ |jt|}|j|_|jS#t $rt |_|jcYSwxYw|jS)aAutomatically keep column indexes up to date? Setting this value states whether existing indexes should be automatically updated after an append operation or recomputed after an index-invalidating operation (i.e. removal and modification of rows). The default is true. This value gets into effect whenever a column is altered. If you don't have automatic indexing activated and you want to do an an immediate update use `Table.flush_rows_to_index()`; for an immediate reindexing of invalidated indexes, use `Table.reindex_dirty()`. This value is persistent. .. versionchanged:: 3.0 The *autoIndex* property has been renamed into *autoindex*. ) _autoindexrIrr5autorr!)rQ indexgroups r/ autoindexzTable.autoindex=s~( ? " '!\334Ft4L4LMM #-/& # ' ' '"4&&& '? "s'AA#"A#ct|} |jt|}n#t$rt |}YnwxYw||_||_dSr7)rYrIrr5rrrr)rQrrs r/rzTable.autoindex^spDzz 4//0B40H0HIIJJ 4 4 4-d33JJJ 4 s'9AAc*fdjDS)z2List of pathnames of indexed columns in the table.c.g|]}j||Sr<) colindexedr _colpnamerQs r/rz-Table.indexedcolpathnames..ls5///?9-/ ///r1)rrs`r/indexedcolpathnameszTable.indexedcolpathnamesis1////!%!2/// /r1cDtfdjDS)z5A dictionary with the indexes of the indexed columns.c3tK|]2}j||j|jfV3dSr7)rcols_f_colrqrs r/ z#Table.colindexes..ss[::("oi8:Ity'7'7 'B'B'HI::::::r1)rrrs`r/ colindexeszTable.colindexesps@::::,0,=::::: :r1c"|jjdkS)z%Whether some index in table is dirty.r)_condition_cache _nailcountrs r/ _dirtyindexeszTable._dirtyindexesws$/!33r1NrTc J|dux|_} ||_ ||_ d|_ d|_ d|_ ||jjd}||_ td|_ d|_ g|_ g|_ i|_ d|_ d|_ d|_ d|_ g|_ d|_ g|_ g|_ i|_ i|_ i|_ i|_ i|_ i|_ d|_ d|_ d|_ |jjd} tA| |_! i|_" d|_# i|_$ d|_% d|_& d|_' d|_( | r6tS|tTr!tW||jj|_ n| rjtY|tYtZkrEt]|tZr0|} tW| j/|jj|_ n| rtS|tVr||_ | rK|j DtS|t`j1r*te||jj}|\|_ |_| r|j tg|x|_(}|dkr t`j45|}ntm||}t|j7x|_ }|dkr||_te|j1|jj}|\|_ |_n#tp$rYnwxYw| r|j tqd| r|tS|trt`j:fr|f} tw|}n-#tp$r tqd tY|zwxYwty|d krt{d |twd |D|_t}?||| ||| | dS) NrEXPECTED_ROWS_TABLEFCOND_CACHE_SLOTST)ptparamspythonzthe ``description`` argument is not of a supported type: ``IsDescription`` subclass, ``Description`` instance, dictionary, or structured arrayzI`chunkshape` parameter must be an integer or sequence and you passed a %srz&`chunkshape` rank (length) must be 1: c34K|]}t|VdSr7)r)rss r/rz!Table.__init__..%s(&G&Gqx{{&G&G&G&G&G&Gr1)@_v_new _v_new_title_v_new_filtersextdim _v_recarray _rabyteorderrIrJrrrkr_time64colnames _strcolnames _colenumsrKindexedrr_listoldindexesrcolnamesr colinstances coldescrscoltypes coldtypesrrr^_where_conditionrm CacheDictr_exprvars_cache_enabled_indexing_in_queries_empty_array_cacherLr rP _descflavorr`dictrtyper issubclasscolumnsrarXrr recrjr sizerintintegerrerhrsuper__init__)rQ parentnoderrrrrrvr_log track_timesr max_slotsrtupflavornparrayrk __class__s r/r:zTable.__init__|s (t33 c?!&%2 K; =  %-45JKL+Da[[ 6 2!..M!H 7-$%!E!3C N   " B? =@H $K! &-.@A )) 4 43!F,0)F"$$ 1   MF  +:k400 +*;4>4F4M O O OD    +d;''4 +>+>>>$[-@@? KMME*5=4>4F4M O O OD    +Z [99 +*D   :4#++rx00 :&{0:0B0IKKK693 $"3  :4#+ :,5k,B,BB 6X%% fll;77GG/ VDDG%-gl%;%;; U199'.D$&w}0:0B0IKKK693 $"3"3    "  34#+233 3  H:)*sBJ&788 +(]  >":..  > > >*,0,<,<=>>> >:!## j$.J"1222!&&G&GJ&G&G&G!G!GD  T3D$ & & & & &sL++ L87L8<N *N6c|jdc|_|_tt ||j|_|j|j}}|jjD]}| |||<|j rd|j D|_ dSt|}||jv}d}|jdD]}|j}|rt#||} | |jv} | |j |<| ru|j |} | j} t'| t(rd} d}|j|n-| jr|jn d} d|j |<| rd|_|r*t7jd|jd|jt:|jr.| j|_|j |jz |_!|j"|_#dSdS)Nci|]}|dS)Fr<)rcpns r/ z+Table._g_post_init_hook..>sGGGcsEGGGr1Frr2Ttable ``z`` has column indexes with PyTables 1.x format. Unfortunately, this format is not supported in PyTables 2.x series. Note that you can use the ``ptrepack`` utility in order to recreate the indexes. The 1.x indexed columns found are: )$r0_flavorr9_g_post_init_hookColsrr r' _v_pathnames_g_colrrrr5rI_f_walkr3r:rqr`rr%rcrrrnailr$warningswarnr nelementsrrkrrr)rQr'r r9indexesgrouppathr oldindexescolobjr indexnamer$columnindexobjrBs r/rJzTable._g_post_init_hook*sB*.)94& d& !!###t/00 ". d +8 A AK(, K(@(@L % % ; GGT5FGGGDO F .d33!T\1 &..E.:: $ $F(G 15dGDD #t|3+2( 9!Y--g66F%|H!(H559"'%) ,33G<<<<$>9 166888+0( $#  ! MM !!!4#7#7 9   ! ! ! < - ( 2D (, T5F(FD %"nDOOO  - -r1cB|jj}|j}|d}|dkr||z}|||jdzz}nd}|j||jdkr |jd}|dkr7d}|d|z}||kr$t jd|j|fzt|S)z?1222r1cv|}||jvr |j|Stjd|x|j|<}|S)NrrZ)r/raempty)rQrXrarrs r/_getemptyarrayzTable._getemptyarraysQ $) ) )*3/ / XAS999 :D # Jr1c8tj||jS)zJGet the appropriate buffer for data depending on table nestedness.rZ)rar`rL)rQr[s r/rzTable._get_containers xe4=9999r1cPfd|jdDS)z/Returns a list containing 'type_' column names.c4g|]}|jk |jSr<)r2r3)rrUtype_s r/rz-Table._get_type_col_names..s3)));%''"'''r1r)rrN)rQrfs `r/_get_type_col_nameszTable._get_type_col_namess?))))".66u==))) )r1cxi}|jdD]}|jdkr|j||j<|S)z@Return mapping from enumerated column names to `Enum` instances.renum)rrNrrir3)rQenumMaprUs r/ _get_enum_mapzTable._get_enum_mapsK&..u55 : :F{f$$.4k*+r1c|jjd}t|jj|kr$t jd|j|fzt|j [| |j |j |_ t|j |j krt|j |_ |j +||j |j|j|_ |jt"j|_|||j|jjpdt.|_d|_ d|_ ||_|jjdrP|jj}t;|jdD]\}}d|z}|||j|jS) zCreate a new table on disk. MAX_COLUMNSztable ``%s`` is exceeding the recommended maximum number of columns (%d); be ready to see PyTables asking for *lots* of memory and possibly slow I/ONrPYTABLES_SYS_ATTRSrrGz FIELD_%d_FILL) rIrJrhr_v_namesrPrQr3rr_g_fix_byteorder_datar rrK_calc_chunkshaperrsys_cache_description_data _create_tablerrcomplib obversion _v_objectidr^r_v_attrs _g__setattrrprNdflt)rQ maxColumnsset_attrrrU fieldnames r/ _g_createzTable._g_creates \(7  ) * *Z 7 7 M(,0+;Z*HI#  $ $ $   '#99$:J:>:K M MD 4#$$t';;;'*4+;'<'<$   %!%!6!6$dlDL"B"BD  > ! ]DN $$&&& --  t|39r9FF //11 < 3 4 1}0H&t'7'?'?U'?'K'KLL 1 1 6+a/ FK0000r1c |\|_}}|j|_|jj }t |||jj|_|dkr,| |j|j |j |_ n|f|_ | |_ |jjdrd|jdvrd}|jj}|jdD]W}|j}d|z}||} | | |_n/t)jd |d |jd |jd |j} |dz }X|jdD]B} | jD]8} | j| }t1|t2r|j| j|j<9C||jS)zOpens a table from disk and read the metadata on it. Creates an user description on the flight to easy the access to the actual data. )validaterrrn FIELD_0_FILLrrrrGz FIELD_%s_FILLNz'could not load default value for the ``z`` column of table ``z ``; using ``z `` insteadrr) _get_inforwrkrrI _isPTFilerrJrrqrrKr^rrx_f_list __getattr__rNr3rzrPrQro _v_colobjectsr`r_v_dfltsr-rs) rQrrRrrget_attrobjcolrr}defvalrrs r/_g_openz Table._g_opens48>>3C3C0+y#z|--&{X04 0CEEE >>!%!6!6$dlDL"B"BD  #,D //11 < 3 4 I!6!6u!=!====4".66E6BBF$0G /! 3I%Xi00F)&,  *1$2B2B2B*0+++ '7888 "(FAA"-55=5IIIIE %II!&!4T!:%fc22I=C[EN6>:I $$&&&r1ct|jj|_d|jD|_|d|_|d|_| |_ |jdD]@}|j }||j |<|j |j|<|j|j|<|j|j|<A|jj|_dS)aCache some data which is already in the description. Some information is extracted from `self.description` to build some useful (but redundant) structures: * `self.colnames` * `self.colpathnames` * `self.coldescrs` * `self.coltypes` * `self.coldtypes` * `self.coldflts` * `self._v_dtype` * `self._time64colnames` * `self._strcolnames` * `self._colenums` c<g|]}t|d|jS)ro)hasattrr3)rrs r/rz1Table._cache_description_data..Ds:--- #3 ++- O---r1time64stringrrGN)listrror&rNrrgr!r"rkr#r3r(r2r)rXr*rzrrL)rQrUrs r/rszTable._cache_description_data0s&T-677 --'+'7'?'?'A'A--- $77AA 44X>>++--&..E.:: 1 1F(G&,DN7 #%+[DM' "&,lDN7 #%+[DM' " "(1 r1c tjt|d|jS#t $rt d|jd|dwxYw)zGet the instance of the column with the given `colpathname`. If the column does not exist in the table, a `KeyError` is raised. rrH"`` does not have a column named ````) functoolsreducegetattrrrAttributeErrorKeyErrorr3)rQr9s r/_get_column_instancezTable._get_column_instance[s} >#**3//1ACC C > > >("... =>> > >s 25&AcX|jsdS|jd|_dS)zMForce queries not to use indexing. *Use only for testing.* NF)r.rrOrs r/_disable_indexing_in_queriesz"Table._disable_indexing_in_queriesls90  F ""$$$,1)))r1cX|jrdS|jd|_dS)zIAllow queries to use indexing. *Use only for testing.* NT)r.runnailrs r/_enable_indexing_in_queriesz!Table._enable_indexing_in_querieszs7  ,  F $$&&&,0)))r1rc|j}||vrXt|dkrt|ddD]}||=t|dd}d|jD}|||<n||}ii} }|"t j|} | j}| j} |j } |j |j } } i}|D]Q}| ||vr ||}n=|| vr | |}n0| ||vr ||}n!| || vr | |}ntd|zt|drz|jd dd krtd |z|j| us |j| krt%d |d | d|jjd ddkrtd|znst|drt+d|zt-|t(r(t/j|d}nt/j|}|||<S|S)aGet the variables required by the `expression`. A new dictionary defining the variables used in the `expression` is returned. Required variables are first looked up in the `uservars` mapping, then in the set of top-level columns of the table. Unknown variables cause a `NameError` to be raised. When `uservars` is `None`, the local and global namespace where the API callable which uses this method is called is sought instead. This mechanism will not work as expected if this method is not used *directly* from an API callable. To disable this mechanism, just specify a mapping as `uservars`. Nested columns and columns from other tables are not allowed (`TypeError` and `ValueError` are raised, respectively). Also, non-column variable values are converted to NumPy arrays. `depth` specifies the depth of the frame in order to reach local or global variables. N zevalc@g|]}|dvr|tjjv|S))NoneFalseTrue)r| expressions functions)rrs r/rz-Table._required_expr_vars..s@AAA&???r~'??????r1zname ``%s`` is not definedrrr<z[variable ``%s`` refers to a multidimensional column, not yet supported in conditions, sorry variable ``z3`` refers to a column which is not part of table ``rrzvariable ``%s`` refers to a 64-bit unsigned integer column, not yet supported in conditions, sorry; please use regular Python selections_v_colpathnameszDvariable ``%s`` refers to a nested column, not allowed in conditionsascii)r-rhrcompileco_namesrr _getframef_locals f_globalsr'rIr3 NameErrorrr[r _table_file _table_pathrrXrrr`raasarrayencode)rQ expressionuservarsdepth exprvarscachercexprexprvars user_locals user_globals user_framer'tblfiletblpathreqvarsrvals r/_required_expr_varszTable._required_expr_varss0, ] * *=!!C''m,,SbS1))A%a((J F;;EAAu~AAAH)1M* % %$Z0H%'\  u--J$-K%/L( <)9) ) C#xsm $$"3'!c[&8&8!#&!c\&9&9"3' $>????!===#)'*ssCINNN%<==== #8__eHoo("8__eHoo(h(HEs #AB+++Cc|j}|||}||}|r||S|\}}}}} t t t || } g} |D]`} || } | jj}t|| | <|j r3|j | j r!| j js| | at!| } t#|| | }t%|jt%|st+d|d|||<||S)aYCompile the `condition` and extract usable index conditions. This method returns an instance of ``CompiledCondition``. See the ``compile_condition()`` function in the ``conditions`` module for more information about the compilation process. This method makes use of the condition cache when possible. z0there are no columns taking part in condition ``r)rrgetwith_replaced_varsr1rziprXr2_nxtype_from_nptyper.rrrqrrrcrr set parameters intersectionr)rQrr condcacherrr&rrrtypemap indexedcolsrrcoltypes r/_compile_conditionzTable._compile_condition s) )))X>>==))  9..x88 8?F;Hh( tC(334455  , ,G7#CinG27;GG 1 , 5 ,>Aio ,""7+++ ,, $YEE8&''44S]]CC C*6?iiBCC C& '**8444r1c||d||}fd|jD}t|S)aCWill a query for the condition use indexing? The meaning of the condition and *condvars* arguments is the same as in the :meth:`Table.where` method. If condition can use indexing, this method returns a frozenset with the path names of the columns whose index is usable. Otherwise, it returns an empty list. This method is mainly intended for testing. Keep in mind that changing the set of indexed columns or their dirtiness may make this method return different values for the same arguments at different times. rc*g|]}|jSr<)r)rrrs r/rz1Table.will_query_use_indexing..Ss NNNc8C=)NNNr1)rrindex_variablesr)rQrrridxcolss ` r/will_query_use_indexingzTable.will_query_use_indexingAs^++Ixq+II**9h??NNNNX5MNNN!!!r1c4||||||S)aIterate over values fulfilling a condition. This method returns a Row iterator (see :ref:`RowClassDescr`) which only selects rows in the table that satisfy the given condition (an expression-like string). The condvars mapping may be used to define the variable names appearing in the condition. condvars should consist of identifier-like strings pointing to Column (see :ref:`ColumnClassDescr`) instances *of this table*, or to other values (which will be converted to arrays). A default set of condition variables is provided where each top-level, non-nested column with an identifier-like name appears. Variables in condvars override the default ones. When condvars is not provided or None, the current local and global namespace is sought instead of condvars. The previous mechanism is mostly intended for interactive usage. To disable it, just specify a (maybe empty) mapping as condvars. If a range is supplied (by setting some of the start, stop or step parameters), only the rows in that range and fulfilling the condition are used. The meaning of the start, stop and step parameters is the same as for Python slices. When possible, indexed columns participating in the condition will be used to speed up the search. It is recommended that you place the indexed columns as left and out in the condition as possible. Anyway, this method has always better performance than regular Python selections on the table. You can mix this method with regular Python selections in order to support even more complex queries. It is strongly recommended that you pass the most restrictive condition as the parameter to this method if you want to achieve maximum performance. .. warning:: When in the middle of a table row iterator, you should not use methods that can change the number of rows in the table (like :meth:`Table.append` or :meth:`Table.remove_rows`) or unexpected errors will happen. Examples -------- :: passvalues = [ row['col3'] for row in table.where('(col1 > 0) & (col2 <= 20)', step=5) if your_function(row['col2']) ] print("Values that pass the cuts:", passvalues) .. note:: A special care should be taken when the query condition includes string literals. Let's assume that the table ``table`` has the following structure:: class Record(IsDescription): col1 = StringCol(4) # 4-character String of bytes col2 = IntCol() col3 = FloatCol() The type of "col1" corresponds to strings of bytes. Any condition involving "col1" should be written using the appropriate type for string literals in order to avoid :exc:`TypeError`\ s. The code below will fail with a :exc:`TypeError`:: condition = 'col1 == "AAAA"' for record in table.where(condition): # TypeError in Python3 # do something with "record" The reason is that in Python 3 "condition" implies a comparison between a string of bytes ("col1" contents) and a unicode literal ("AAAA"). The correct way to write the condition is:: condition = 'col1 == b"AAAA"' .. versionchanged:: 3.0 The start, stop and step parameters now behave like in slice. )_where)rQrrrrrs r/wherez Table.whereVsx{{9htTBBBr1c trt}trtd|||||\}}}||krd|_d|_t gS||d||}|j r@t||||||}t|tj sd|_d|_|Snd}fd|jD} |j| |jf|_t#j|} trtd|| ||||S) z(Low-level counterpart of `self.where()`.zEntering table._whereFNrc g|] }| Sr<r<)rparamrs r/rz Table._where..sAAAEAAAr1zExiting table._where)r)r\r]r%_process_range_readr^r+rirrrnrr`rarbrfunctionkwargsrr_iter) rQrrrrrrrrargsrs ` r/rz Table._wheresw  77D  6 . 5 5 5"66udDIId D==#DO$(D !88O++Ixq+II**9h??  % ,h 8UD$HHHh 33 #((,%  HAAAAX-@AAA!)!2D(/ J &&  5 -t 4 4 4yydXy>>>r1c|d||||||D}d|_t|dkr|d|ddz} }| |z t|krWt jt j|| t j|k} | r||| |S| ||S)ayRead table data fulfilling the given *condition*. This method is similar to :meth:`Table.read`, having their common arguments and return values the same meanings. However, only the rows fulfilling the *condition* are included in the result. The meaning of the other arguments is the same as in the :meth:`Table.where` method. cg|] }|j Sr<nrowrps r/rz$Table.read_where..,GGGQ!&GGGr1Nrrfield) _g_check_openrr+rhraalltruearangerjreadread_coordinates) rQrrrrrrcoordscstartcstopinc_seqs r/ read_wherezTable.read_wheres GG++i5$EEGGG $ v;;??"1IvbzA~EFv~V,,*Ife,,0@0@@BBA99VU%9@@@$$VU333r1c~||jd|jD}|j}d} |||||||} n||||} | D]+} |D] } | | || <|| dz } ,|| S)aAppend rows fulfilling the condition to the dstTable table. dstTable must be capable of taking the rows resulting from the query, i.e. it must have columns with the expected names and compatible types. The meaning of the other arguments is the same as in the :meth:`Table.where` method. The number of rows appended to dstTable is returned as a result. .. versionchanged:: 3.0 The *whereAppend* method has been renamed into *append_where*. cg|]}|Sr<r<)rcolNames r/rz&Table.append_where..s===G===r1rNr) rrI_check_writablerrriterrowsrcflush) rQdstTablerrrrrcolNamesdstRowrksrcRowssrcRowrs r/ append_wherezTable.append_wheres  ((*** >=4+<===  kk)XudDIIGGmmE466G  F# 2 2"(/w MMOOO QJEE r1Fc |d||||||D}tj|t}d|_|rtj|}t||jS)a^Get the row coordinates fulfilling the given condition. The coordinates are returned as a list of the current flavor. sort means that you want to retrieve the coordinates ordered. The default is to not sort them. The meaning of the other arguments is the same as in the :meth:`Table.where` method. cg|] }|j Sr<rrs r/rz(Table.get_where_list..,rr1rWN) rrrarjrr+sortr r@)rQrrrrrrrs r/get_where_listzTable.get_where_lists GG++i5$EEGGG&111 $  %WV__F!&$+666r1c t|dstd|ddd\}}}||kst|dkrt gSt j|}|||||S)z+Iterate over a sequence of row coordinates. __getitem__z=Wrong 'sequence' parameter type. Only sequences are suported.Nrr)rr_process_rangerhrirrr)rQsequencerrrrs r/rlzTable.itersequence5sx// -,-- -#11$dCCd DLLc(mmq0088O &&yyd8y<<'* * / / /)77D,,,.// / /s $&A c.||S)aGet a column from the table. If a column called name exists in the table, it is read and returned as a NumPy object. If it does not exist, a KeyError is raised. Examples -------- :: narray = table.col('var2') That statement is equivalent to:: narray = table.read(field='var2') Here you can see how this method can be used as a shorthand for the :meth:`Table.read` method. r)r)rQrs r/rz Table.cols,yyty$$$r1c|t|rytj|}||jkrt d|dkr ||jz }|||dzd\}}}||||dSt|trA||j |j |j \}}}||||St|ttfvst|t jr||dSt d|)a{Get a row or a range of rows from the table. If key argument is an integer, the corresponding table row is returned as a record of the current flavor. If key is a slice, the range of rows determined by it is returned as a structured array of the current flavor. In addition, NumPy-style point selections are supported. In particular, if key is a list of row coordinates, the set of rows determined by it is returned. Furthermore, if key is an array of boolean values, only the coordinates where key is True are returned. Note that for the latter to work it is necessary that key list would contain exactly as many rows as the table has. Examples -------- :: record = table[4] recarray = table[4:1000:2] recarray = table[[4,1000]] # only retrieves rows 4 and 1000 recarray = table[[True, False, ..., True]] Those statements are equivalent to:: record = table.read(start=4)[0] recarray = table.read(start=4, stop=1000, step=2) recarray = table.read_coordinates([4,1000]) recarray = table.read_coordinates([True, False, ..., True]) Here, you can see how indexing can be used as a shorthand for the :meth:`Table.read` and :meth:`Table.read_coordinates` methods. Index out of rangerrNInvalid index or slice: )rroperatorrqrk IndexErrorrrr`slicerrrr2rrerarbrD)rQrrrrs r/rzTable.__getitem__sJJ  #;; A.%%Cdj   !5666Qwwtz!"&"5"5c37A"F"F UD$99UD$//2 2 U # # A"&"5"5 38SX#/#/ UD$99UD$// / #YY4- ' ':c2:+F+F '))#t44 4???@@ @r1c||jt|rZt j|}||jkrtd|dkr ||jz }|||dzd|gSt|trB| |j |j |j\}}}|||||St|t t"fvst|t$jr|||Std|)aSet a row or a range of rows in the table. It takes different actions depending on the type of the *key* parameter: if it is an integer, the corresponding table row is set to *value* (a record or sequence capable of being converted to the table structure). If *key* is a slice, the row slice determined by it is set to *value* (a record array or sequence capable of being converted to the table structure). In addition, NumPy-style point selections are supported. In particular, if key is a list of row coordinates, the set of rows determined by it is set to value. Furthermore, if key is an array of boolean values, only the coordinates where key is True are set to values from value. Note that for the latter to work it is necessary that key list would contain exactly as many rows as the table has. Examples -------- :: # Modify just one existing row table[2] = [456,'db2',1.2] # Modify two existing rows rows = numpy.rec.array([[457,'db1',1.2],[6,'de2',1.3]], formats='i4,a3,f8') table[1:30:2] = rows # modify a table slice table[[1,3]] = rows # only modifies rows 1 and 3 table[[True,False,True]] = rows # only modifies rows 0 and 2 Which is equivalent to:: table.modify_rows(start=2, rows=[456,'db2',1.2]) rows = numpy.rec.array([[457,'db1',1.2],[6,'de2',1.3]], formats='i4,a3,f8') table.modify_rows(start=1, stop=3, step=2, rows=rows) table.modify_coordinates([1,3,2], rows) table.modify_coordinates([True, False, True], rows) Here, you can see how indexing can be used as a shorthand for the :meth:`Table.modify_rows` and :meth:`Table.modify_coordinates` methods. rKrrrL)rrIrrrMrqrkrN modify_rowsr`rOrrrrr2rrerarbmodify_coordinates)rQrrrrrs r/ __setitem__zTable.__setitem__sE^  $$&&& #;; A.%%Cdj   !5666Qwwtz!##Cq!eW== = U # # A"&"5"5 38SX#/#/ UD$##E4u== = #YY4- ' ':c2:+F+F '**366 6???@@ @r1c4||||||jrR|xj|z c_d|_|jr|ddS||j dSdS)z,Update the indexes after a flushing of rows.TF_lastrowN) _open_append_append_records _close_appendr$rrPrflush_rows_to_index_mark_columns_as_dirtyr)rQwbufRAlenrowss r/_save_buffered_rowszTable._save_buffered_rowsNs &!!! W%%%  < ?  % % 0 % %#D ~ ?((%(88888++D,=>>>>> ? ?r1cH||j|jst ddt |dr|jjs|j|jkr|}n t|}|dkrt||}tj ||j}n5#t$r(}t!dt#|d|d d }~wwxYw|jd }|d kr|||d Sd S) a(Append a sequence of rows to the end of the table. The rows argument may be any object which can be converted to a structured array compliant with the table structure (otherwise, a ValueError is raised). This includes NumPy structured arrays, lists of tuples or array records, and a string or Python buffer. Examples -------- :: import tables as tb class Particle(tb.IsDescription): name = tb.StringCol(16, pos=1) # 16-character String lati = tb.IntCol(pos=2) # integer longi = tb.IntCol(pos=3) # integer pressure = tb.Float32Col(pos=4) # float (single-precision) temperature = tb.FloatCol(pos=5) # double (double-precision) fileh = tb.open_file('test4.h5', mode='w') table = fileh.create_table(fileh.root, 'table', Particle, "A table") # Append several rows in only one call table.append([("Particle: 10", 10, 0, 10 * 10, 10**2), ("Particle: 11", 11, -1, 11 * 11, 11**2), ("Particle: 12", 12, -2, 12 * 12, 12**2)]) fileh.close() z.You cannot append rows to a non-chunked table.F)h5btrXrrWzProws parameter cannot be converted into a recarray object compliant with table ''. The error was: <>Nr)rrIr_chunkedrrr _v_is_nestedrXr r rar5rjrL Exceptionrrr[r^)rQrowsr\iflavorexcr]s r/rcz Table.append_sfF  $$&&&} N@uNNN N D' " " K$1 K dj((FF K#D//h&&,T7;;Dd$-@@ K K K j:=d))))SSS"JKKK K,q/ Q;;  $ $VW 5 5 5 5 5 ;s6A C C4 #C//C4ct t|}|dkrt||}t|dr(|jdkrt j|g|j}n&tj||j}n2#t$r%}td|j j d|dd}~wwxYw|S) z*Try to convert the object into a recarray.rr[r<rWzOObject cannot be converted into a recarray object compliant with table format 'rarbN) r r rr[rarjrLr5rerr_v_nested_descr)rQobjrgrecarrrhs r/_conv_to_recarrzTable._conv_to_recarrs FnnG(""'W55sG$$ @b 3%t}===c?? F F F*#.>>>EFF F F  sBB B5 B00B5c|tdS||}t|}t||krtd||}t|dkr||||||jt|S)a8Modify a series of rows in positions specified in coords. The values in the selected rows will be modified with the data given in rows. This method returns the number of rows modified. The possible values for the rows argument are the same as in :meth:`Table.append`. Nr@The value has not enough elements to fill-in the specified range)rr>rhrrm_update_elements_reindexr)rQrrflcoordsrls r/rRzTable.modify_coordinatess <A;; &&v..f++ t99w  344 4%%d++ v;;??  ! !'66 : : : d'(((   r1c|d}|tdS|d}|dkrtd|dkrtd||t|dz |zzdz}||||\}}}||jkrt dtt |||}t||krtd||}t|}||z|jkrt d|||||| |j t|S)aModify a series of rows in the slice [start:stop:step]. The values in the selected rows will be modified with the data given in rows. This method returns the number of rows modified. Should the modification exceed the length of the table, an IndexError is raised before changing data. The possible values for the rows argument are the same as in :meth:`Table.append`. Nrr#'start' must have a positive value.1'step' must have a value greater or equal than 1.AThis modification will exceed the length of the table. Giving up.z9The value has different elements than the specified range) rrrhrrkrNr,rm_update_recordsrqr)rQrrrrfrkrlr]s r/rQzTable.modify_rowss <D <A;;  =E 199BCC C !88CEE E <CIIMT11A5D"11%tDDd $*  566 6E%t,,-- t99  /00 0%%d++f++ 7?TZ ' '122 2 UD$777 d'(((   r1c|d}t|tstd|j|t dS|d}|dkrt d|dkrt d||}|jj |j g} t|drE|j j dkr5tj|| d}nt%|}t'||}n5#t($r(} t d t|d | d d} ~ wwxYw|}|jd krd|_||t/|dz |zzdz}||||\}}}||jkrt5dt/t7|||} t/|| krt d||||} t;| |} || dd<||||| ||gt | S)aModify one single column in the row slice [start:stop:step]. The colname argument specifies the name of the column in the table to be modified with the data given in column. This method returns the number of rows modified. Should the modification exceed the length of the table, an IndexError is raised before changing data. The *column* argument may be any object which can be converted to a (record) array compliant with the structure of the column to be modified (otherwise, a ValueError is raised). This includes NumPy (record) arrays, lists of scalars, tuples or array records, and a string or Python buffer. Nrz)The 'colname' parameter must be a string.rrtrurXVrWz\column parameter cannot be converted into a ndarray object compliant with specified column 'rarbr<rrvro) r`rrrIrrrrrrj_v_posrrXrrar5rjrr r resqueezer[rhrrkrNr,r8rrwrq) rQrrrrWrrrrgrhrk mod_recarrmod_cols r/ modify_columnzTable.modify_column s" <D'3'' IGHH H $$&&& >A;;  =E 199BCC C !88CEE E**733!1&-@A Ovw'' )>)@)@ J J%*J)**733Cqyyy$($;$;#UE8D%<%J%J  % % 2 % %    *  r1c|j|j}|j}|jj|z}||z } ||z|z dz} || krA|||||zd|g|| |z } ||z }|| kA|rK||jkr@||||jd|g|| |j|z z } | S)z(Add more elements to the existing index.rr) r rMrq slicesizesortedrkrcr8append_last_row) rQrrrkrrrqrstartLRrrs r/rzTable._add_rows_to_index s    ))/O ,$y0o u}y(1,nn LLGWy%8!WEEF     9 $K y G nn  0w++  ! !GTZG<<= "    4:/ /Kr1c||||\}}}||||}||jt |S)a^Remove a range of rows in the table. If only start is supplied, that row and all following will be deleted. If a range is supplied, i.e. both the start and stop parameters are passed, all the rows in the range are removed. .. versionchanged:: 3.0 The start, stop and step parameters now behave like in slice. .. seealso:: remove_row() Parameters ---------- start : int Sets the starting row to be removed. It accepts negative values meaning that the count starts from the end. A value of 0 means the first row. stop : int Sets the last row to be removed to stop-1, i.e. the end point is omitted (in the Python range() tradition). Negative values are also accepted. If None all rows after start will be removed. step : int The step size between rows to remove. .. versionadded:: 3.0 Examples -------- Removing rows from 5 to 10 (excluded):: t.remove_rows(5, 10) Removing all rows starting from the 10th:: t.remove_rows(10) Removing the 6th row:: t.remove_rows(6, 7) .. note:: removing a single row can be done using the specific :meth:`remove_row` method. )r _remove_rowsrqrr)rQrrrrks r/ remove_rowszTable.remove_rows s[b#11%tDDd!!%t44 d'(((r1c:|||dzdS)aRemoves a row from the table. Parameters ---------- n : int The index of the row to remove. .. versionadded:: 3.0 Examples -------- Remove row 15:: table.remove_row(15) Which is equivalent to:: table.remove_rows(15, 16) .. warning:: This is not equivalent to:: table.remove_rows(15) r)rrN)r)rQns r/ remove_rowzTable.remove_row s'< qq1u-----r1ct|j|d|jvrt j||jd<dSdS)Nr)r9_g_update_dependentr _g_update_table_location__dict__rr)rQrBs r/rzTable._g_update_dependent> se ##%%% **4000 DM ! !#1#5d#;#;DM%  " !r1ct|}t|| |j|}|j}t |}|||dS#t$rYdSwxYw)z]Move this node in the hierarchy. This overloads the Node._g_move() method. N)r5r9_g_moverIrrr0r)rQ newparentnewname itgpathnamer newigroupnewinamerBs r/rz Table._g_moveH s)..   7+++ 1l,,[99GI%d++H OOIx 0 0 0 0 0     DD sA<< B  B ct|} |j|}|dd|_n#t $rYnwxYwt ||dS)NT) recursiveF)r5rIr _f_remover$rr9 _g_remove)rQrforcerrrBs r/rzTable._g_remove^ s(..  !l,,[99G     - - - DLL     D  )U+++++sA AAc|j}t|||}}||krdS|j|||<t ||_dS)z3Mark the referred column as indexed or non-indexed.N)rrYrclearmaxrr$)rQr9r$r isindexed wasindexeds r/rzTable._set_column_indexingl so_ $W z+/F:  " " F ##%%%"+ ;:,,..// r1ct|dksJ|jr<|j|j}}|D]-}||r!||}d|j_,dSdS)z+Mark column indexes in `colnames` as dirty.rTN)rhr$rr rMrqrr)rQr&rr rrs r/r[zTable._mark_columns_as_dirtyy s}8}}q    < +# J# + +g&+++g..C&*CIO  + + + +r1c |jr{|j|j}}g}|D]@}||r6||}d|j_||A|jr|r|dd|_ dSdS)z=Re-index columns in `colnames` if automatic indexing is true.TrrN) r$rr rMrqrrrcr _do_reindexrP)rQr&rr  colstoindexrrs r/rqzTable._reindex s < $# JK# 0 0g&0++g..C&*CIO&&w///~ -+ -  t ,,,#D    $ $r1cd}|jD]6\}}|r/|j|}||}7|dkr||_|j|z |_t|S)z2Common code for `reindex()` and `reindex_dirty()`.r) rr_r rMrrrkrr)rQrrrrrindexcols r/rzTable._do_reindex s %)_%:%:%<%< : : !Wj :9++G44&22599 ?? +D (, [(@D % $$$r1c2|ddS)zRecompute all the existing indexes in the table. This can be useful when you suspect that, for any reason, the index information for columns is no longer valid and want to rebuild the indexes on it. FrNrrs r/reindexz Table.reindex s! u%%%%%r1c2|ddS)aCRecompute the existing indexes in table, *if* they are dirty. This can be useful when you have set :attr:`Table.autoindex` (see :class:`Table`) to false for the table and you want to update the indexes after a invalidating index operation (:meth:`Table.remove_rows`, for example). TrNrrs r/ reindex_dirtyzTable.reindex_dirty s! t$$$$$r1c||||||dS|j}|}|dkr | }|dz|dz}}||||} t||||zD]U} | ||zz} | |kr|} | || | |} n | | | |} || } || V|dS)zCopy rows from self to objectNrr)_g_copy_rows_optimrrr,rrcr)rQobjectrrrrrlenbufabssteprqstart2stop2rfrs r/ _g_copy_rowszTable._g_copy_rows s  >  # #FE4 > > > F !88eG(EAI4E  **68<Generate index in `other` table for every indexed column here.N)rrrr) r'r`rrrq create_indexrrr)rQotheroldcolsnewcolsr oldcolindexed oldcolindexnewcols r/_g_prop_indexeszTable._g_prop_indexes s ,e.@ C CG77+V44 C ' 0 ;  C")'"2"8K$W-F''(- 8L + 3T(CCC  C Cr1c | dd} | dd} | dd} ||||| du\}}}tt|||}t |||j||||| }|||||| | |j|jz}| r|j r| |||fS)z2Private part of Leaf.copy() for each kind of leaf.rN propindexesFrr )rrrrvr<) poprrhr,rrrrkrr$r)rQgrouprrrrrrrvr<rrrrrknewtabler.s r/_g_copy_with_statszTable._g_copy_with_stats s Hd++jj66 ::j%00"66 4FdN7<<dE%t,,--d&6e!(u$."$$$ (E4vxHHH("22  +4< +   * * *&!!r1c >tj||||fi|S)aCopy this table and return the new one. This method has the behavior and keywords described in :meth:`Leaf.copy`. Moreover, it recognises the following additional keyword arguments. Parameters ---------- sortby If specified, and sortby corresponds to a column with an index, then the copy will be sorted by this index. If you want to ensure a fully sorted order, the index must be a CSI one. A reverse sorted copy can be achieved by specifying a negative value for the step keyword. If sortby is omitted or None, the original table order is used. checkCSI If true and a CSI index does not exist for the sortby column, an error will be raised. If false (the default), it does nothing. You can use this flag in order to explicitly check for the existence of a CSI index. propindexes If true, the existing indexes in the source table are propagated (created) to the new one. If false (the default), the indexes are not propagated. )r9r@)rQrr overwrite createparentsrrBs r/r@z Table.copy s::uww| w =DD > >)M 2 2 2 1 1 1ffffP>252525h""""*)-*.\C\C\C\C|%?%?%?%?N:>/344446?C15%%%%N=B3777770===.333,+0/3::::<9=0444448',',',',R4EEEENG4G4G4G4R    D7777 ///&%%%0:A:A:AxDADADAL???"A6A6A6F2 ! ! !D5!5!5!5!n9=+/OOOOb:>+/JJJJX0:6666p...@<<<<<11111, , , , , , , 0 0 0 + + +$$$$ % % % & & & % % %4( C C C"""6???r1c|j}|j|d<|j|d<||d<|j|d<|jj|d<|jD]>}||jvrt|||||< t||j |||<?dS)Nrr_v_desc _v_colnamesr) rrIr3rorrL_v_typesrrKr)rQr8descmyDictrs r/r:z Cols.__init__ s"'-"'"3 y $ }$)$5$B !M E EDt}$$%eT488t #E4+=d+CDDt  E Er1c|j}|j|d<|j|d<|jD]}|||dS)>Updates the location information about the associated `table`.rrN)rrIr3rr)rQr8rrs r/rzCols._g_update_table_location s]"'-"'"3' < s>>?? ?r1c|j}|j}t|rStj|}||krt d|dkr||z }|||dzd\}}}nRt|tr+||j |j |j \}}}ntd||j j}|dkr|||||dS||||||dS) aSet a row or a range of rows in a table or nested column. If key argument is an integer, the corresponding row is set to value. If key is a slice, the range of rows determined by it is set to value. Examples -------- :: table.cols[4] = record table.cols.Info[4:1000:2] = recarray Those statements are equivalent to:: table.modify_rows(4, rows=record) table.modify_column(4, 1000, 2, colname='Info', column=recarray) Here you can see how a mix of natural naming, indexing and slicing can be used as shorthands for the :meth:`Table.modify_rows` and :meth:`Table.modify_column` methods. rKrrrr)rf)rrWN)rrkrrMrqrNrr`rOrrrrrr3rQr) rQrrr8rkrrrrs r/rSzCols.__setitem__M sF4   #;; @.%%Ce|| !5666Qwwu "'"6"6sC!GQ"G"G UD$$ U # # @"'"6"6 38SX#/#/ UD$$>s>>?? ?<+ r>>   eT4e  < < < < <   tT8E  C C C C Cr1c|jD]]}||}t|tr||j|=I|^|jdSr7)rrMr`rcloserrr)rQrrUs r/rz Cols._g_close s~# " "C[[%%F&&)) " M#&&!!!! r1c |jj}|rd|z}|jd|d|jjdt |jdS)*The string representation for this object..r (z), z columns)rr3rrBrrhr)rQ descpathnames r/__str__z Cols.__str__ sp|/  .-L%33L33N+33t'((333 4r1c X|g}|jD]}t||jj}||jjvr8|jj|}|jjf|jj|jz}nd}d}| d|d||d|dd |dzS)1A detailed string representation for this object.rr<z r, ) ) rrrBrr _v_dtypesrrkr[rcr)rQlinesr classnametcolr[s r/rz Cols.__repr__ s $ C CDd++5>It|---|-d3,.L*4067% LLAdAAiAAA$AAA B B B Byy$&&r1N)rrrrrrr:rrr rMrrSrrrr<r1r/rKrK s&&P@@X@ E E E < < <%%% $$$88@8@8@t2C2C2Ch    4 4 4'''''r1rKc*eZdZdZedZedZedZedZ edZ edZ edZ ed Z d Zd Zd Zd ZdZdZ ddZ ddZdZdZdZdZdZdZdZdS)raAccessor for a non-nested column in a table. Each instance of this class is associated with one *non-nested* column of a table. These instances are mainly used to read and write data from the table columns using item access (like the Cols class - see :ref:`ColsClassDescr`), but there are a few other associated methods to deal with indexes. .. rubric:: Column attributes .. attribute:: descr The Description (see :ref:`DescriptionClassDescr`) instance of the parent table or nested column. .. attribute:: name The name of the associated column. .. attribute:: pathname The complete pathname of the associated column (the same as Column.name if the column is not inside a nested column). Parameters ---------- table The parent table instance name The name of the column that is associated with this object descr The parent description object c:|jj|jjS)z6The NumPy dtype that most closely matches this column.)rrrbasers r/rXz Column.dtype sz#DI.33r1c0|jj|jS)z+The PyTables type of the column (a string).)rrrrs r/r2z Column.type sz"49--r1c@|j|jSr)rrrrs r/r8z Column.table s))$*:;;;r1ct|j|j} |j|}n#t $rd}YnwxYw|S)zxThe Index instance (see :ref:`IndexClassDescr`) associated with this column (None if the column is not indexed).N)rDrrrrr)rQ indexPathrqs r/rqz Column.index s^/t/?OO  $..y99EE   EEE  s7 AAc0|jj|jSr7)rrrrs r/ _itemtypezColumn._itemtype sz#DI..r1cV|jjf|jj|jjzS)zThe shape of this column.)r8rkrrrr[rs r/r[z Column.shape s&  "TZ%9$)%D%JJJr1c|jdSdS)z/True if the column is indexed, false otherwise.NFT)rqrs r/rzColumn.is_indexed s : 54r1cdS)z]"The dimension along which iterators work. Its value is 0 (i.e. the first dimension).rr<rs r/maindimzColumn.maindim s qr1c|j|_|j|_||_ |j|j|_ ||_dSr7)rIrr3rrrrr)rQr8rrs r/r:zColumn.__init__ sJ = , 0+D1=  E  * *r1c6|j|_|j|_dS)rN)rIrr3r)rQr8s r/rzColumn._g_update_table_location s!= ,r1c|jjS)zqGet the number of elements in the column. This matches the length in rows of the parent table. )r8rkrs r/rzColumn.__len__ szr1ch|j}t|trt|dkr|d}t |rt j|}||jkrtd|dkr ||jz }| ||dzd\}}}| ||||j dSt|trG| |j |j|j\}}}| ||||j St!d|z)aGet a row or a range of rows from a column. If key argument is an integer, the corresponding element in the column is returned as an object of the current flavor. If key is a slice, the range of elements determined by it is returned as an array of the current flavor. Examples -------- :: print("Column handlers:") for name in table.colnames: print(table.cols._f_col(name)) print("Select table.cols.name[1]-->", table.cols.name[1]) print("Select table.cols.name[1:2]-->", table.cols.name[1:2]) print("Select table.cols.name[:]-->", table.cols.name[:]) print("Select table.cols._f_col('name')[:]-->", table.cols._f_col('name')[:]) The output of this for a certain arbitrary table is:: Column handlers: /table.cols.name (Column(), string, idx=None) /table.cols.lati (Column(), int32, idx=None) /table.cols.longi (Column(), int32, idx=None) /table.cols.vector (Column(2,), int32, idx=None) /table.cols.matrix2D (Column(2, 2), float64, idx=None) Select table.cols.name[1]--> Particle: 11 Select table.cols.name[1:2]--> ['Particle: 11'] Select table.cols.name[:]--> ['Particle: 10' 'Particle: 11' 'Particle: 12' 'Particle: 13' 'Particle: 14'] Select table.cols._f_col('name')[:]--> ['Particle: 10' 'Particle: 11' 'Particle: 12' 'Particle: 13' 'Particle: 14'] See the :file:`examples/table2.py` file for a more complete example. rrrKz*'%s' key type is not valid in this context)r8r`rerhrrMrqrkrNrrrrOrrrr)rQrr8rrrs r/rzColumn.__getitem__ s<V  c5 ! ! c#hh!mma&C #;; D.%%Cek!! !5666Qwwu{""'"6"6sC!GQ"G"G UD$::eT4??B B U # # D"'"6"6 38SX#/#/ UD$::eT4?? ?rArDrTrrrrr1rrrKrr<r1r/r\s*&&  &&&&&&44444444))))))DDDDDDDDDDFFFFFFFFFFFFLLLLLLLLLLLL-,,,,,''''''''  "!!!!!!  HdGR] Hbm Hbm Hbm!Hbm Ir}!Ir}"Ir}"JJ $L'M7Iu" #BG 72y,&+ # 72y;&(m&: # 72z<')}'; $ 72|1)0 & 72|1)0 &bhxx{{##). """;;; ===@@@ BBB   NNNb[[[|00000$000T)OT)OT)OT)OT)ON $T)OT)OT)OnRJ'J'J'J'J'J'J'J'Zrrrrrrrrrrr1