a 鴫j@srUdZddlmZddlmZddlZddlmZmZddl Z ddl Z ddl Z ddl m Z ddlmZmZmZmZmZmZmZddlZddlZddlmZmZmZmZdd lmZm Z!dd l"m#Z#dd l$m%Z%dd l&m'Z'dd l(m)Z)ddl*m+Z+ddl,m-Z-m.Z.m/Z/m0Z0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAddlBmCZCddlDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOddlPmQZQmRZRmSZSddlTmUZUddlVmWmXZYddlZm[Z[m\Z\ddl]m^Z_m`Z`ddlambZbddlcmdZdmeZeddlfmgZgddlhmiZimjZjerddlkmlZlmmZmmnZnddlompZpdd lqmrZrmsZsmtZtdd!lumvZvmwZwmxZxmyZymzZzm{Z{m|Z|m}Z}dd"lcm~Z~d#Zd$Zd%d&Zd'd(d)d*d+Zd,d-Ze[Zd.d/d0d1Zd2Zd3ed4<d5Zd3ed6<d7Zd3ed8<d9d9d:d:d;ZeEdgiZdZd3ed?<ed@@ejdAdBeejdCejdDdeegdEdCWdn1sv0YdadBadFdGZddKd(dLd(dMd'dNd'dNdOdPdQd(d(dRdSdTdUZddKd(d(dWdMdMdXdNdMdY dZd[Zd\d\dNd]d^d_ZGd`dadaZGdbdcdcZGdddedeZGdfdgdgeZGdhdidieZGdjdkdkeZGdldmdmeZGdndodoZGdpdqdqeZGdrdsdseZGdtdudueZGdvdwdweZGdxdydyeZGdzd{d{eZGd|d}d}eZGd~ddeZGdddeZGdddeZGdddeZGdddeZddddddddZdddddZeddddNddddZedddRdNddddZddddNddddZd(dd(d(dedddZd(d(d(ddddZd(dddddZdd(d(ddddZdd(d(ddddZdd(d(d(dddZd(d(d(dddZd(dNdddZd(dd(dddZd(d(dddZddddZGdddZdS)zY High level interface to PyTables for reading and writing pandas data structures to disk ) annotations)suppressN)datetzinfo)dedent) TYPE_CHECKINGAnyCallableFinalLiteralcastoverload)config get_optionusing_copy_on_writeusing_string_dtype)libwriters)is_string_array) timezones) HAS_PYARROW)import_optional_dependency) patch_pickle)AttributeConflictWarningClosedFileErrorIncompatibilityWarningPerformanceWarningPossibleDataLossError)cache_readonly)find_stack_level) ensure_object is_bool_dtypeis_complex_dtype is_list_likeis_string_dtypeneeds_i8_conversion)CategoricalDtypeDatetimeTZDtypeExtensionDtype PeriodDtype)array_equivalent) DataFrame DatetimeIndexIndex MultiIndex PeriodIndex RangeIndexSeries StringDtypeTimedeltaIndexconcatisna) Categorical DatetimeArray PeriodArray)BaseStringArray) PyTablesExprmaybe_expression)array extract_array) ensure_index) ArrayManager BlockManager)stringify_path)adjoin pprint_thing)HashableIteratorSequence) TracebackType)ColFileNode) AnyArrayLike ArrayLikeAxisIntDtypeArgFilePathSelfShapenpt)Blockz0.15.2UTF-8cCst|tjr|d}|S)z(if we have bytes, decode them to unicoderT) isinstancenpbytes_decode)srZQ/var/www/html/laksyashrimp/venv/lib/python3.9/site-packages/pandas/io/pytables.py_ensure_decodeds  r\ str | Nonestr)encodingreturncCs|dur t}|SN)_default_encodingr_rZrZr[_ensure_encodingsrdcCst|trt|}|S)z Ensure that an index / column name is a str (python 3); otherwise they may be np.string dtype. Non-string dtypes are passed through unchanged. https://github.com/pandas-dev/pandas/issues/13492 )rUr^namerZrZr[ _ensure_strs rgint scope_levelcsV|dt|ttfr*fdd|D}nt|r>t|d}|dusNt|rR|SdS)z Ensure that the where is a Term or a list of Term. This makes sure that we are capturing the scope of variables that are passed create the terms here with a frame_level=2 (we are 2 levels down) cs0g|](}|durt|r(t|ddn|qS)Nrkri)r;Term).0termlevelrZr[ sz _ensure_term..riN)rUlisttupler;rllen)whererjrZror[ _ensure_terms   rvz where criteria is being ignored as this version [%s] is too old (or not-defined), read the file in and write it out to a new file to upgrade (with the copy_to method) r incompatibility_doczu the [%s] attribute of the existing index is [%s] which conflicts with the new [%s], resetting the attribute to None attribute_conflict_docz your performance may suffer as PyTables will pickle object types that it cannot map directly to c-types [inferred_type->%s,key->%s] [items->%s] performance_docfixedtable)frztr{z; : boolean drop ALL nan rows when appending to a table dropna_docz~ : format default format writing format, if None, then put will default to 'fixed' and append will default to 'table' format_doczio.hdfZ dropna_tableF)Z validatordefault_format)rzr{NcCsLtdurHddl}|att|jjdkaWdn1s>0YtS)Nrstrict) _table_modtablesrAttributeErrorfileZ_FILE_OPEN_POLICY!_table_file_open_policy_is_strict)rrZrZr[_tabless  raTrzFilePath | HDFStoreDataFrame | Series int | Noneboolint | dict[str, int] | None bool | None Literal[True] | list[str] | NoneNone) path_or_bufkeyvaluemode complevelcomplibappendformatindex min_itemsizedropna data_columnserrorsr_r`c s|r$ f dd}n f dd}t|}t|trt||||d}||Wdq1s0Yn||dS)z+store this object, close it if we opened itc s|j d S)N)rrrnan_reprrrr_)rstore rrr_rrrrrrrrZr[szto_hdf..c s|j d S)N)rrrrrrr_rputrrrZr[r+s)rrrN)rArUr^HDFStore)rrrrrrrrrrrrrrr_r|rrZrr[to_hdf s   (rrzstr | list | Nonezlist[str] | None) rrrrustartstopcolumnsiterator chunksizec  Ks|dvrtd|d|dur,t|dd}t|trN|jsDtd|} d} ntt|}t|tshtd zt j |} Wnt tfyd} Yn0| st d |d t|f||d | } d } zt|dur| }t|dkrtd|d}|ddD]}t||stdq|j}| j||||||| | dWStt tfyt|tstt| Wdn1s0YYn0dS)a> Read from the store, close it if we opened it. Retrieve pandas object stored in file, optionally based on where criteria. .. warning:: Pandas uses PyTables for reading and writing HDF5 files, which allows serializing object-dtype data with pickle when using the "fixed" format. Loading pickled data received from untrusted sources can be unsafe. See: https://docs.python.org/3/library/pickle.html for more. Parameters ---------- path_or_buf : str, path object, pandas.HDFStore Any valid string path is acceptable. Only supports the local file system, remote URLs and file-like objects are not supported. If you want to pass in a path object, pandas accepts any ``os.PathLike``. Alternatively, pandas accepts an open :class:`pandas.HDFStore` object. key : object, optional The group identifier in the store. Can be omitted if the HDF file contains a single pandas object. mode : {'r', 'r+', 'a'}, default 'r' Mode to use when opening the file. Ignored if path_or_buf is a :class:`pandas.HDFStore`. Default is 'r'. errors : str, default 'strict' Specifies how encoding and decoding errors are to be handled. See the errors argument for :func:`open` for a full list of options. where : list, optional A list of Term (or convertible) objects. start : int, optional Row number to start selection. stop : int, optional Row number to stop selection. columns : list, optional A list of columns names to return. iterator : bool, optional Return an iterator object. chunksize : int, optional Number of rows to include in an iteration when using an iterator. **kwargs Additional keyword arguments passed to HDFStore. Returns ------- object The selected object. Return type depends on the object stored. See Also -------- DataFrame.to_hdf : Write a HDF file from a DataFrame. HDFStore : Low-level access to HDF files. Notes ----- When ``errors="surrogatepass"``, ``pd.options.future.infer_string`` is true, and PyArrow is installed, if a UTF-16 surrogate is encountered when decoding to UTF-8, the resulting dtype will be ``pd.StringDtype(storage="python", na_value=np.nan)``. Examples -------- >>> df = pd.DataFrame([[1, 1.0, 'a']], columns=['x', 'y', 'z']) # doctest: +SKIP >>> df.to_hdf('./store.h5', 'data') # doctest: +SKIP >>> reread = pd.read_hdf('./store.h5') # doctest: +SKIP )rr+rzmode zG is not allowed while performing a read. Allowed modes are r, r+ and a.Nrkriz&The HDFStore must be open for reading.Fz5Support for generic buffers has not been implemented.zFile z does not exist)rrTrz]Dataset(s) incompatible with Pandas data types, not table, or no datasets found in HDF5 file.z?key must be provided when HDF5 file contains multiple datasets.)rurrrrr auto_close) ValueErrorrvrUris_openOSErrorrAr^NotImplementedErrorospathexists TypeErrorFileNotFoundErrorgroupsrt_is_metadata_of _v_pathnameselect LookupErrorrrclose)rrrrrurrrrrkwargsrrrrZcandidate_only_groupZgroup_to_checkrZrZr[read_hdfBsjV           (rrJ)group parent_groupr`cCsF|j|jkrdS|}|jdkrB|j}||kr:|jdkr:dS|j}qdS)zDCheck if a given group is a metadata group for a given parent_group.FrkmetaT)Z_v_depthZ _v_parent_v_name)rrcurrentparentrZrZr[rs  rc@s6eZdZUdZded<ded<ddd d d d d dZddddZeddZeddddZ ddddZ dd dddZ dd dddZ dddd Z dd dd!d"Zd#dd$d%Zddd&d'Zd(dd)d*Zd+d,d-d d.d/d0Zddd2d3d4d5Zd6dd7d8Zd9dd:d;Zddd d<d=d>Zd dd?d@Zed ddAdBZdd d dCdDdEZdddFdGZddd d d dHdIdJZddd d dKdLdMZdddd d dNdOdPZdd d d dQdRdSZdddVd d d dWdXdd d d dY dZd[Zddd dd\d]Z dddVd^d d dWd d_dXdd d` dadbZ!ddcd d dddedfZ"ddd dgd dhdidjZ#dkddldmZ$dddodpdqdrZ%ddsddtduZ&ddvddwdxZ'ddd d d d ddzd{d|Z(ddd}d~Z)d dddZ*dddddZ+dddddvdddZ,dddVd^d d dWd d dd d d ddZ-ddddZ.dd ddddZ/dddddZ0dS)raS Dict-like IO interface for storing pandas objects in PyTables. Either Fixed or Table format. .. warning:: Pandas uses PyTables for reading and writing HDF5 files, which allows serializing object-dtype data with pickle when using the "fixed" format. Loading pickled data received from untrusted sources can be unsafe. See: https://docs.python.org/3/library/pickle.html for more. Parameters ---------- path : str File path to HDF5 file. mode : {'a', 'w', 'r', 'r+'}, default 'a' ``'r'`` Read-only; no data can be modified. ``'w'`` Write; a new file is created (an existing file with the same name would be deleted). ``'a'`` Append; an existing file is opened for reading and writing, and if the file does not exist it is created. ``'r+'`` It is similar to ``'a'``, but the file must already exist. complevel : int, 0-9, default None Specifies a compression level for data. A value of 0 or None disables compression. complib : {'zlib', 'lzo', 'bzip2', 'blosc'}, default 'zlib' Specifies the compression library to be used. These additional compressors for Blosc are supported (default if no compressor specified: 'blosc:blosclz'): {'blosc:blosclz', 'blosc:lz4', 'blosc:lz4hc', 'blosc:snappy', 'blosc:zlib', 'blosc:zstd'}. Specifying a compression library which is not available issues a ValueError. fletcher32 : bool, default False If applying compression use the fletcher32 checksum. **kwargs These parameters will be passed to the PyTables open_file method. Examples -------- >>> bar = pd.DataFrame(np.random.randn(10, 4)) >>> store = pd.HDFStore('test.h5') >>> store['foo'] = bar # write to HDF5 >>> bar = store['foo'] # retrieve >>> store.close() **Create or load HDF5 file in-memory** When passing the `driver` option to the PyTables open_file method through **kwargs, the HDF5 file is loaded or created in-memory and will only be written when closed: >>> bar = pd.DataFrame(np.random.randn(10, 4)) >>> store = pd.HDFStore('test.h5', driver='H5FD_CORE') >>> store['foo'] = bar >>> store.close() # only now, data is written to disk z File | None_handler^_moderNFrrr)rr fletcher32r`cKsd|vrtdtd}|dur@||jjvr@td|jjd|durX|durX|jj}t||_|durnd}||_d|_|r|nd|_ ||_ ||_ d|_ |j fd|i|dS) Nrz-format is not a defined argument for HDFStorerzcomplib only supports z compression.rrr)rrfiltersZ all_complibsZdefault_complibrA_pathrr _complevel_complib _fletcher32_filtersopen)selfrrrrrrrrZrZr[__init__7s&  zHDFStore.__init__r`cCs|jSrarrrZrZr[ __fspath__XszHDFStore.__fspath__cCs||jdusJ|jjS)zreturn the root nodeN)_check_if_openrrootrrZrZr[r[sz HDFStore.rootcCs|jSrarrrZrZr[filenamebszHDFStore.filenamercCs ||Sra)getrrrZrZr[ __getitem__fszHDFStore.__getitem__rr`cCs|||dSrar)rrrrZrZr[ __setitem__iszHDFStore.__setitem__cCs ||Sra)removerrZrZr[ __delitem__lszHDFStore.__delitem__rec CsDz ||WSttfy"Yn0tdt|jd|ddS)z$allow attribute access to get stores'z' object has no attribute 'N)rKeyErrorrrtype__name__)rrfrZrZr[ __getattr__os zHDFStore.__getattr__cCs4||}|dur0|j}|||ddfvr0dSdS)zx check for existence of this key can match the exact pathname or the pathnm w/o the leading '/' NrkTF)get_noder)rrnoderfrZrZr[ __contains__ys  zHDFStore.__contains__rhcCs t|Sra)rtrrrZrZr[__len__szHDFStore.__len__cCst|j}t|d|dS)N File path:  )rCrr)rpstrrZrZr[__repr__s zHDFStore.__repr__rPcCs|SrarZrrZrZr[ __enter__szHDFStore.__enter__ztype[BaseException] | NonezBaseException | NonezTracebackType | None)exc_type exc_value tracebackr`cCs |dSra)r)rrrrrZrZr[__exit__szHDFStore.__exit__pandas list[str])includer`cCs^|dkrdd|DS|dkrJ|jdus0Jdd|jjddd DStd |d dS) a Return a list of keys corresponding to objects stored in HDFStore. Parameters ---------- include : str, default 'pandas' When kind equals 'pandas' return pandas objects. When kind equals 'native' return native HDF5 Table objects. Returns ------- list List of ABSOLUTE path-names (e.g. have the leading '/'). Raises ------ raises ValueError if kind has an illegal value Examples -------- >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=['A', 'B']) >>> store = pd.HDFStore("store.h5", 'w') # doctest: +SKIP >>> store.put('data', df) # doctest: +SKIP >>> store.get('data') # doctest: +SKIP >>> print(store.keys()) # doctest: +SKIP ['/data1', '/data2'] >>> store.close() # doctest: +SKIP rcSsg|] }|jqSrZrrmnrZrZr[rqz!HDFStore.keys..nativeNcSsg|] }|jqSrZrrrZrZr[rqs/Table) classnamez8`include` should be either 'pandas' or 'native' but is 'r)rrZ walk_nodesr)rrrZrZr[keyss z HDFStore.keysz Iterator[str]cCs t|Sra)iterrrrZrZr[__iter__szHDFStore.__iter__zIterator[tuple[str, list]]ccs|D]}|j|fVqdS)z' iterate on key->group N)rr)rgrZrZr[itemss zHDFStore.items)rr`cKst}|j|krR|jdvr$|dvr$n(|dvrL|jrLtd|jd|jd||_|jr`||jr|jdkrtj|j|j|j d|_ t r|jrd }t ||j |j|jfi||_d S) a9 Open the file in the specified mode Parameters ---------- mode : {'a', 'w', 'r', 'r+'}, default 'a' See HDFStore docstring or tables.open_file for info about modes **kwargs These parameters will be passed to the PyTables open_file method. )rw)rr)rzRe-opening the file [z ] with mode [z] will delete the current file!r)rzGCannot open HDF5 file, which is already opened, even in read-only mode.N)rrrrrrrFiltersrrrrr open_filer)rrrrmsgrZrZr[rs*    z HDFStore.opencCs|jdur|jd|_dS)z0 Close the PyTables file handle N)rrrrZrZr[rs  zHDFStore.closecCs|jdurdSt|jjS)zF return a boolean indicating whether the file is open NF)rrZisopenrrZrZr[rs zHDFStore.is_open)fsyncr`cCsT|jdurP|j|rPtt t|jWdn1sF0YdS)a Force all buffered modifications to be written to disk. Parameters ---------- fsync : bool (default False) call ``os.fsync()`` on the file handle to force writing to disk. Notes ----- Without ``fsync=True``, flushing may not guarantee that the OS writes to disk. With fsync, the operation will block until the OS claims the file has been written; however, other caching layers may still interfere. N)rflushrrrrfileno)rrrZrZr[r s    zHDFStore.flushcCsVt<||}|dur*td|d||WdS1sH0YdS)a  Retrieve pandas object stored in file. Parameters ---------- key : str Returns ------- object Same type as object stored in file. Examples -------- >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=['A', 'B']) >>> store = pd.HDFStore("store.h5", 'w') # doctest: +SKIP >>> store.put('data', df) # doctest: +SKIP >>> store.get('data') # doctest: +SKIP >>> store.close() # doctest: +SKIP NNo object named in the file)rrr _read_grouprrrrZrZr[rs  z HDFStore.get)rrrrc st||} | dur"td|dt|dd}|| fdd} t|| |j|||||d } | S) a6 Retrieve pandas object stored in file, optionally based on where criteria. .. warning:: Pandas uses PyTables for reading and writing HDF5 files, which allows serializing object-dtype data with pickle when using the "fixed" format. Loading pickled data received from untrusted sources can be unsafe. See: https://docs.python.org/3/library/pickle.html for more. Parameters ---------- key : str Object being retrieved from file. where : list or None List of Term (or convertible) objects, optional. start : int or None Row number to start selection. stop : int, default None Row number to stop selection. columns : list or None A list of columns that if not None, will limit the return columns. iterator : bool or False Returns an iterator. chunksize : int or None Number or rows to include in iteration, return an iterator. auto_close : bool or False Should automatically close the store when finished. Returns ------- object Retrieved object from file. Examples -------- >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=['A', 'B']) >>> store = pd.HDFStore("store.h5", 'w') # doctest: +SKIP >>> store.put('data', df) # doctest: +SKIP >>> store.get('data') # doctest: +SKIP >>> print(store.keys()) # doctest: +SKIP ['/data1', '/data2'] >>> store.select('/data1') # doctest: +SKIP A B 0 1 2 1 3 4 >>> store.select('/data1', where='columns == A') # doctest: +SKIP A 0 1 1 3 >>> store.close() # doctest: +SKIP Nr r rkricsj|||dS)N)rrrurread_start_stop_whererrYrZr[funcszHDFStore.select..funcrunrowsrrrrr)rrrv_create_storer infer_axes TableIteratorr get_result) rrrurrrrrrrritrZrr[r<s(@    zHDFStore.selectrrrcCs8t|dd}||}t|ts(td|j|||dS)a return the selection as an Index .. warning:: Pandas uses PyTables for reading and writing HDF5 files, which allows serializing object-dtype data with pickle when using the "fixed" format. Loading pickled data received from untrusted sources can be unsafe. See: https://docs.python.org/3/library/pickle.html for more. Parameters ---------- key : str where : list of Term (or convertible) objects, optional start : integer (defaults to None), row number to start selection stop : integer (defaults to None), row number to stop selection rkriz&can only read_coordinates with a tablerurr)rv get_storerrUrrread_coordinates)rrrurrtblrZrZr[select_as_coordinatess    zHDFStore.select_as_coordinates)rcolumnrrcCs,||}t|tstd|j|||dS)a~ return a single column from the table. This is generally only useful to select an indexable .. warning:: Pandas uses PyTables for reading and writing HDF5 files, which allows serializing object-dtype data with pickle when using the "fixed" format. Loading pickled data received from untrusted sources can be unsafe. See: https://docs.python.org/3/library/pickle.html for more. Parameters ---------- key : str column : str The column of interest. start : int or None, default None stop : int or None, default None Raises ------ raises KeyError if the column is not found (or key is not a valid store) raises ValueError if the column can not be extracted individually (it is part of a data block) z!can only read_column with a tabler"rr)rrUrr read_column)rrr"rrr rZrZr[ select_columns#  zHDFStore.select_column)rrrc  svt|dd}t|ttfr.t|dkr.|d}t|trRj||||||| dSt|ttfshtdt|sxtd|dur|d}fdd |D |} d} t | |fgt |D]\\} } | durt d | d | jstd | jd | dur | j} q| j| krtdqdd D}dd|Dfdd}t| ||| ||||| d }|jddS)a Retrieve pandas objects from multiple tables. .. warning:: Pandas uses PyTables for reading and writing HDF5 files, which allows serializing object-dtype data with pickle when using the "fixed" format. Loading pickled data received from untrusted sources can be unsafe. See: https://docs.python.org/3/library/pickle.html for more. Parameters ---------- keys : a list of the tables selector : the table to apply the where criteria (defaults to keys[0] if not supplied) columns : the columns I want back start : integer (defaults to None), row number to start selection stop : integer (defaults to None), row number to stop selection iterator : bool, return an iterator, default False chunksize : nrows to include in iteration, return an iterator auto_close : bool, default False Should automatically close the store when finished. Raises ------ raises KeyError if keys or selector is not found or keys is empty raises TypeError if keys is not a list or tuple raises ValueError if the tables are not ALL THE SAME DIMENSIONS rkrir)rrurrrrrrzkeys must be a list/tuplez keys must have a non-zero lengthNcsg|]}|qSrZ)rrmkrrZr[rq%rz/HDFStore.select_as_multiple..zInvalid table []zobject [z>] is not a table, and cannot be used in all select as multiplez,all tables must have exactly the same nrows!cSsg|]}t|tr|qSrZ)rUrrmxrZrZr[rq:rcSsh|]}|jddqSr)non_index_axesrmr}rZrZr[ =rz.HDFStore.select_as_multiple..cs*fddD}t|ddS)Ncsg|]}|jdqS)rurrrr r-)rrrrrZr[rqBsz=HDFStore.select_as_multiple..func..F)axisverify_integrity)r4 _consolidate)rrrobjs)r0rtblsrr[r?sz)HDFStore.select_as_multiple..funcrT coordinates)rvrUrrrsrtr^rrrr itertoolschainzipris_tablepathnamerpoprr)rrruselectorrrrrrrrYrr}r'Z_tblsrrrZ)r0rrr4r[select_as_multiplesd+           zHDFStore.select_as_multipleTrrrr) rrrrrrrr track_timesrr`cCsH|durtdpd}||}|j||||||||| | | | | |ddS)a Store object in HDFStore. Parameters ---------- key : str value : {Series, DataFrame} format : 'fixed(f)|table(t)', default is 'fixed' Format to use when storing object in HDFStore. Value can be one of: ``'fixed'`` Fixed format. Fast writing/reading. Not-appendable, nor searchable. ``'table'`` Table format. Write as a PyTables Table structure which may perform worse but allow more flexible operations like searching / selecting subsets of the data. index : bool, default True Write DataFrame index as a column. append : bool, default False This will force Table format, append the input data to the existing. data_columns : list of columns or True, default None List of columns to create as data columns, or True to use all columns. See `here `__. encoding : str, default None Provide an encoding for strings. track_times : bool, default True Parameter is propagated to 'create_table' method of 'PyTables'. If set to False it enables to have the same h5 files (same hashes) independent on creation time. dropna : bool, default False, optional Remove missing values. Examples -------- >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=['A', 'B']) >>> store = pd.HDFStore("store.h5", 'w') # doctest: +SKIP >>> store.put('data', df) # doctest: +SKIP Nio.hdf.default_formatrz) rrrrrrrrr_rr?r)r_validate_format_write_to_group)rrrrrrrrrrrr_rr?rrZrZr[rZs&8  z HDFStore.putc Cst|dd}z||}Wnty.Yntty@Ynbty}zJ|dur`td|||}|dur|jddWYd}~dSWYd}~n d}~00t |||r|j jddn|j std|j |||dSdS) a: Remove pandas object partially by specifying the where condition Parameters ---------- key : str Node to remove or delete rows from where : list of Term (or convertible) objects, optional start : integer (defaults to None), row number to start selection stop : integer (defaults to None), row number to stop selection Returns ------- number of rows removed (or None if not a Table) Raises ------ raises KeyError if key is not a valid store rkriNz5trying to remove a node with a non-None where clause!T recursivez7can only remove with where on objects written as tablesr) rvrrAssertionError ExceptionrrZ _f_removecomall_nonerr:delete)rrrurrrYerrrrZrZr[rs2     $zHDFStore.removezbool | list[str]r) rrrrrrrrrrr`cCsl| durtd|dur td}|dur4tdp2d}||}|j||||||||| | | | ||||ddS)a| Append to Table in file. Node must already exist and be Table format. Parameters ---------- key : str value : {Series, DataFrame} format : 'table' is the default Format to use when storing object in HDFStore. Value can be one of: ``'table'`` Table format. Write as a PyTables Table structure which may perform worse but allow more flexible operations like searching / selecting subsets of the data. index : bool, default True Write DataFrame index as a column. append : bool, default True Append the input data to the existing. data_columns : list of columns, or True, default None List of columns to create as indexed data columns for on-disk queries, or True to use all columns. By default only the axes of the object are indexed. See `here `__. min_itemsize : dict of columns that specify minimum str sizes nan_rep : str to use as str nan representation chunksize : size to chunk the writing expectedrows : expected TOTAL row size of this table encoding : default None, provide an encoding for str dropna : bool, default False, optional Do not write an ALL nan row to the store settable by the option 'io.hdf.dropna_table'. Notes ----- Does *not* check if data being appended overlaps with existing data in the table, so be careful Examples -------- >>> df1 = pd.DataFrame([[1, 2], [3, 4]], columns=['A', 'B']) >>> store = pd.HDFStore("store.h5", 'w') # doctest: +SKIP >>> store.put('data', df1, format='table') # doctest: +SKIP >>> df2 = pd.DataFrame([[5, 6], [7, 8]], columns=['A', 'B']) >>> store.append('data', df2) # doctest: +SKIP >>> store.close() # doctest: +SKIP A B 0 1 2 1 3 4 0 5 6 1 7 8 Nz>columns is not a supported keyword in append, try data_columnszio.hdf.dropna_tabler@r{)raxesrrrrrrr expectedrowsrrr_r)rrrArB)rrrrrKrrrrrrrrrLrrr_rrZrZr[rs6I  zHDFStore.appenddict)drr`c s|durtdt|ts"td||vr2tdttttjtt t }d} g} | D]0\} dur| durtd| } qh| qh| durֈj |} | t| } t| | } | | || <|dur||}|r*fdd|D}t|}|D]}||}qj||dd}| D]h\} | |krT|nd}j|d }|durfd d | Dnd}|j| |f||d |q>dS) a Append to multiple tables Parameters ---------- d : a dict of table_name to table_columns, None is acceptable as the values of one node (this will get all the remaining columns) value : a pandas object selector : a string that designates the indexable table; all of its columns will be designed as data_columns, unless data_columns is passed, in which case these are used data_columns : list of columns to create as data columns, or True to use all columns dropna : if evaluates to True, drop rows from all tables if any single row in each table has all NaN. Default False. Notes ----- axes parameter is currently not accepted Nztaxes is currently not accepted as a parameter to append_to_multiple; you can create the tables independently insteadzQappend_to_multiple must have a dictionary specified as the way to split the valuez=append_to_multiple requires a selector that is in passed dictzrz.HDFStore.append_to_multiple..rr0csi|]\}}|vr||qSrZrZrmrr)vrZr[ rz/HDFStore.append_to_multiple..)rr)rrUrMrnextrsetrangendim _AXES_MAPrrextendrK differencer-sorted get_indexertakevalues intersectionlocr<reindexr)rrNrr=rrKrrr0Z remain_keyZ remain_valuesr'orderedZorddZidxsZ valid_indexrrdcvalfilteredrZ)rUrr[append_to_multipleEsZ &    zHDFStore.append_to_multipler])roptlevelkindr`cCsBt||}|durdSt|ts.td|j|||ddS)a Create a pytables index on the table. Parameters ---------- key : str columns : None, bool, or listlike[str] Indicate which columns to create an index on. * False : Do not create any indexes. * True : Create indexes on all columns. * None : Create indexes on all columns. * listlike : Create indexes on the given columns. optlevel : int or None, default None Optimization level, if None, pytables defaults to 6. kind : str or None, default None Kind of index, if None, pytables defaults to "medium". Raises ------ TypeError: raises if the node is not a table Nz1cannot create table index on a Fixed format store)rrjrk)rrrUrr create_index)rrrrjrkrYrZrZr[create_table_indexs  zHDFStore.create_table_indexrrcCs<t||jdusJtdus(Jdd|jDS)a Return a list of all the top-level nodes. Each node returned is not a pandas storage object. Returns ------- list List of objects. Examples -------- >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=['A', 'B']) >>> store = pd.HDFStore("store.h5", 'w') # doctest: +SKIP >>> store.put('data', df) # doctest: +SKIP >>> print(store.groups()) # doctest: +SKIP >>> store.close() # doctest: +SKIP [/data (Group) '' children := ['axis0' (Array), 'axis1' (Array), 'block0_values' (Array), 'block0_items' (Array)]] NcSsPg|]H}t|tjjst|jddsHt|ddsHt|tjjr|jdkr|qS) pandas_typeNr{) rUrlinkLinkgetattr_v_attrsr{rr)rmrrZrZr[rqs  z#HDFStore.groups..)rrrr walk_groupsrrZrZr[rs zHDFStore.groupsrz*Iterator[tuple[str, list[str], list[str]]])rur`ccst||jdusJtdus(J|j|D]}t|jdddurLq4g}g}|jD]B}t|jdd}|durt |tj j r| |j q^| |j q^|jd||fVq4dS)a Walk the pytables group hierarchy for pandas objects. This generator will yield the group path, subgroups and pandas object names for each group. Any non-pandas PyTables objects that are not a group will be ignored. The `where` group itself is listed first (preorder), then each of its child groups (following an alphanumerical order) is also traversed, following the same procedure. Parameters ---------- where : str, default "/" Group where to start walking. Yields ------ path : str Full path to a group (without trailing '/'). groups : list Names (strings) of the groups contained in `path`. leaves : list Names (strings) of the pandas objects contained in `path`. Examples -------- >>> df1 = pd.DataFrame([[1, 2], [3, 4]], columns=['A', 'B']) >>> store = pd.HDFStore("store.h5", 'w') # doctest: +SKIP >>> store.put('data', df1, format='table') # doctest: +SKIP >>> df2 = pd.DataFrame([[5, 6], [7, 8]], columns=['A', 'B']) >>> store.append('data', df2) # doctest: +SKIP >>> store.close() # doctest: +SKIP >>> for group in store.walk(): # doctest: +SKIP ... print(group) # doctest: +SKIP >>> store.close() # doctest: +SKIP Nrnr)rrrrrsrqrrZ _v_childrenrarUrGrouprrrrstrip)rrurrleaveschildrnrZrZr[walks ' z HDFStore.walkz Node | NonecCs~||dsd|}|jdus(Jtdus4Jz|j|j|}Wntjjy`YdS0t|tj szJt ||S)z9return the node with the key or None if it does not existrN) r startswithrrrr exceptionsZNoSuchNodeErrorrUrJr)rrrrZrZr[r1s  zHDFStore.get_nodeGenericFixed | TablecCs8||}|dur"td|d||}||S)z| | vrj|rj| | || } t| trd} |rdd| j D} | j | | | t | dd| j dq>| j | | | j dq>| S) a; Copy the existing store to a new file, updating in place. Parameters ---------- propindexes : bool, default True Restore indexes in copied file. keys : list, optional List of keys to include in the copy (defaults to all). overwrite : bool, default True Whether to overwrite (remove and replace) existing nodes in the new store. mode, complib, complevel, fletcher32 same as in HDFStore.__init__ Returns ------- open file handle of the new store )rrrrNFcSsg|]}|jr|jqSrZ) is_indexedrfrmrrZrZr[rqyrz!HDFStore.copy..r)rrr_rc)rrrrrUrsrrrrrKrrqr_r)rrrr|rrrrr}Z new_storer'rYdatarrZrZr[copyKs6       z HDFStore.copyc Cs t|j}t|d|d}|jrt|}t|rg}g}|D]}z<||}|dur|t|j pj||t|p|dWqDt yYqDt y}z0||t|} |d| dWYd}~qDd}~00qD|t d||7}n|d7}n|d 7}|S) a Print detailed information on the store. Returns ------- str Examples -------- >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=['A', 'B']) >>> store = pd.HDFStore("store.h5", 'w') # doctest: +SKIP >>> store.put('data', df) # doctest: +SKIP >>> print(store.info()) # doctest: +SKIP >>> store.close() # doctest: +SKIP File path: store.h5 /data frame (shape->[2,2]) rrNzinvalid_HDFStore nodez[invalid_HDFStore node: r( EmptyzFile is CLOSED) rCrrrr^rrtrrr;rErFrB) rroutputZlkeysrrar'rYZdetailZdstrrZrZr[infos.     * z HDFStore.infocCs|jst|jddS)Nz file is not open!)rrrrrZrZr[rszHDFStore._check_if_open)rr`c CsLzt|}Wn6tyF}ztd|d|WYd}~n d}~00|S)zvalidate / deprecate formatsz#invalid HDFStore format specified [r(N) _FORMAT_MAPlowerrr)rrrJrZrZr[rAs (zHDFStore._validate_formatrTzDataFrame | Series | None)rr_rr`c Cs>|durt|ttfstdtt|jdd}tt|jdd}|dur|durttdusdJt|dds~t|tj j rd}d}qtdn$t|trd }nd }|dkr|d 7}d|vr.t t d }z ||} WnFt y} z,td |dt|d|| WYd} ~ n d} ~ 00| ||||dS|dur|dur|dkrt|dd} | dur| jdkrtd}n| jdkrd}nB|dkrt|dd} | dur| jdkrd}n| jdkrd}ttttttd} z | |} WnFt y,} z,td|dt|d|| WYd} ~ n d} ~ 00| ||||dS)z"return a suitable class to operateNz(value must be None, Series, or DataFramern table_typer{ frame_table generic_tablezKcannot create a storer if the object is not existing nor a value are passedseriesframe_table)rrz=cannot properly create the storer for: [_STORER_MAP] [group->,value->z ,format->r_r series_tablerrkappendable_seriesappendable_multiseriesappendable_frameappendable_multiframe)rrrrrwormz)rUr1r+rr\rqrrrrr{r SeriesFixed FrameFixedrrnlevels GenericTableAppendableSeriesTableAppendableMultiSeriesTableAppendableFrameTableAppendableMultiFrameTable WORMTable) rrrrr_rptttZ _STORER_MAPclsrJrZ _TABLE_MAPrZrZr[rs                   zHDFStore._create_storer) rrrrrrrrrr?r`cCst|ddr|dks|rdS|||}|j|||||d}|rr|jrZ|jrb|dkrb|jrbtd|jsz|n||js|rtd|j|||||| | | | | |||d t|t r|r|j |ddS) Nemptyr{rrzzCan only append to Tablesz0Compression not supported on Fixed format stores) objrKrrrrrrrLrrrr?)r) rq_identify_grouprr: is_existsrset_object_infowriterUrrl)rrrrrKrrrrrrrrLrrrr_rr?rrYrZrZr[rB$s:   zHDFStore._write_to_grouprJrcCs||}||Sra)rrr)rrrYrZrZr[r bs zHDFStore._read_group)rrr`cCsN||}|jdusJ|dur8|s8|jj|ddd}|durJ||}|S)z@Identify HDF5 group based on key, delete/create group if needed.NTrC)rr remove_node_create_nodes_and_group)rrrrrZrZr[rgs   zHDFStore._identify_groupcCsv|jdusJ|d}d}|D]P}t|s.q |}|dsD|d7}||7}||}|durl|j||}|}q |S)z,Create nodes from key and return group name.Nr)rsplitrtendswithrZ create_group)rrpathsrpnew_pathrrZrZr[rys   z HDFStore._create_nodes_and_group)rNNF)r)r)F)NNNNFNF)NNN)NN)NNNNNFNF) NTFNNNNNNrTF)NNN)NNTTNNNNNNNNNNr)NNF)NNN)r)rTNNNFT)NNrTr)NTFNNNNNNFNNNrT)1r __module__ __qualname____doc____annotations__rrpropertyrrrrrrrrrrrrrrrrrrrrr!r%r>rrrrirmrrxrrrrrrArrBr rrrZrZrZr[rs A!   *- `$+}$L=$kd('< ;5 `$>rc@speZdZUdZded<ded<ded<dddd dd d d d dZddddZd dddZdd dddZdS)raa Define the iteration interface on a table Parameters ---------- store : HDFStore s : the referred storer func : the function to execute the query where : the where of the query nrows : the rows to iterate on start : the passed start value (default is None) stop : the passed stop value (default is None) iterator : bool, default False Whether to use the default iterator. chunksize : the passed chunking value (default is 100000) auto_close : bool, default False Whether to automatically close the store at the end of iteration. rrrrr{rYNFrr)rrYrrrr`c Cs||_||_||_||_|jjrN|dur,d}|dur8d}|durD|}t||}||_||_||_d|_ |sr| dur| dur~d} t | |_ nd|_ | |_ dS)Nr順) rrYrrur:minrrrr6rhrr) rrrYrrurrrrrrrZrZr[rs,    zTableIterator.__init__rErccsv|j}|jdurtd||jkrjt||j|j}|dd|j||}|}|dust|sbq|Vq|dS)Nz*Cannot iterate until get_result is called.) rr6rrrrrrtr)rrrrrZrZr[rs  zTableIterator.__iter__cCs|jr|jdSra)rrrrrZrZr[rszTableIterator.closer5cCs|jdur4t|jtstd|jj|jd|_|S|rft|jtsLtd|jj|j|j|j d}n|j}| |j|j |}| |S)Nz0can only use an iterator or chunksize on a table)ruz$can only read_coordinates on a tabler) rrUrYrrrrur6rrrr)rr6ruresultsrZrZr[rs    zTableIterator.get_result)NNFNF)F) rrrrrrrrrrZrZrZr[rs  *rc @seZdZUdZdZded<dZded<gdZdKdd d d d d Ze ddddZ e ddddZ dd dddZ ddddZ dddddZddddZe dddd Zd!ddd"d#d$d%Zd&d'Ze d(d)Ze d*d+Ze d,d-Ze d.d/Zd0dd1d2ZdLd dd3d4Zd dd5d6Zd7dd d8d9d:ZdMd;d<Zdd d=d>d?Zd dd@dAZd ddBdCZd ddDdEZd7d dFdGdHZ d7d dFdIdJZ!dS)NIndexCola an index column description class Parameters ---------- axis : axis which I reference values : the ndarray like converted values kind : a string description of this type typ : the pytables type pos : the position in the pytables Tris_an_indexableis_data_indexable)freqtz index_nameNr^r]r)rfcnamer`cCst|tstd||_||_||_||_|p0||_||_||_ ||_ | |_ | |_ | |_ | |_| |_||_|dur|||t|jtsJt|jtsJdS)Nz`name` must be a str.)rUr^rrarktyprfrr0posrrrrer{rmetadataset_pos)rrfrarkrrr0rrrrrer{rrrZrZr[rs(   zIndexCol.__init__rhrcCs|jjSra)ritemsizerrZrZr[r<szIndexCol.itemsizecCs |jdS)N_kindrerrZrZr[ kind_attrAszIndexCol.kind_attr)rr`cCs$||_|dur |jdur ||j_dS)z,set the position of this column in the TableN)rrZ_v_pos)rrrZrZr[rEszIndexCol.set_poscCs@ttt|j|j|j|j|jf}dddt gd|DS)N,cSsg|]\}}|d|qSz->rZrTrZrZr[rqPsz%IndexCol.__repr__..)rfrr0rrk) rsmaprCrfrr0rrkjoinr9rtemprZrZr[rKs zIndexCol.__repr__objectotherr`cstfdddDS)compare 2 col itemsc3s&|]}t|dt|dkVqdSrarqrrrrZr[rRXsz"IndexCol.__eq__..)rfrr0rrOrrrZrr[__eq__VszIndexCol.__eq__cCs || Sra)rrrZrZr[__ne__]szIndexCol.__ne__cCs"t|jdsdSt|jj|jjS)z%return whether I am an indexed columnrQF)hasattrr{rqrQrr~rrZrZr[r~`s zIndexCol.is_indexed np.ndarrayz3tuple[np.ndarray, np.ndarray] | tuple[Index, Index]rar_rr`c Cst|tjsJt||jjdur2||j}t|j }t ||||}i}t|j |d<|j durtt|j |d<t }t|jdst|jtrt}n|jdkrd|vrdd}z||fi|}Wnty8} zX|dkr"td r"t| d r"tr"||fd td tjd i|}nWYd} ~ n>d} ~ 0tyld|vrXd|d<||fi|}Yn0t||j} | | fS)zV Convert the data from this selection to the appropriate pandas type. NrfrMi8c[s tj||ddd|dS)Nr)rrf)r/Z from_ordinalsrZ_rename)r*kwdsrZrZr[rs z"IndexCol.convert.. surrogatepassfuture.infer_stringsurrogates not alloweddtypepythonZstoragena_value)rUrVndarrayrrfieldsrrr\rk_maybe_convertrrr-r is_np_dtyper'r,UnicodeEncodeErrorrr^rrr2nanr_set_tzr) rrarr_rval_kindrfactoryZ new_pd_indexrJZfinal_pd_indexrZrZr[converthsR       zIndexCol.convertcCs|jS)zreturn the valuesrarrZrZr[ take_dataszIndexCol.take_datacCs|jjSra)r{rrrrZrZr[attrsszIndexCol.attrscCs|jjSrar{ descriptionrrZrZr[rszIndexCol.descriptioncCst|j|jdS)z!return my current col descriptionN)rqrrrrZrZr[colsz IndexCol.colcCs|jSzreturn my cython valuesrrrZrZr[cvaluesszIndexCol.cvaluesrEcCs t|jSra)rrarrZrZr[rszIndexCol.__iter__cCsPt|jdkrLt|tr$||j}|durL|jj|krLtj ||j d|_dS)z maybe set a string col itemsize: min_itemsize can be an integer or a dict with this columns name with an integer size stringN)rr) r\rkrUrMrrfrrr StringColr)rrrZrZr[maybe_set_sizes   zIndexCol.maybe_set_sizecCsdSrarZrrZrZr[validate_namesszIndexCol.validate_namesAppendableTable)handlerrr`cCs:|j|_||||||||dSra)r{ validate_col validate_attrvalidate_metadatawrite_metadataset_attr)rrrrZrZr[validate_and_sets    zIndexCol.validate_and_setcCs^t|jdkrZ|j}|durZ|dur*|j}|j|krTtd|d|jd|jd|jSdS)z:validate this column: return the compared against itemsizerNz#Trying to store a string with len [z] in [z)] column but this column has a limit of [zC]! Consider using min_itemsize to preset the sizes on these columns)r\rkrrrr)rrcrZrZr[rs zIndexCol.validate_col)rr`cCsB|r>t|j|jd}|dur>||jkr>td|d|jddS)Nzincompatible kind in col [ - r()rqrrrkr)rrZ existing_kindrZrZr[rs zIndexCol.validate_attrc Cs|jD]}t||d}||ji}||}||vr|dur||kr|dvrt|||f}tj|tt dd||<t ||dqt d|jd|d|d|d q|dus|dur|||<qdS) z set/update the info for this indexable with the key/value if there is a conflict raise/warn as needed N)rr stacklevelzinvalid info for [z] for [z], existing_value [z] conflicts with new value [r() _info_fieldsrq setdefaultrfrrxwarningswarnrrsetattrr)rrrridxZexisting_valuewsrZrZr[ update_infos*   zIndexCol.update_infocCs$||j}|dur |j|dS)z!set my state from the passed infoN)rrf__dict__update)rrr rZrZr[set_info s zIndexCol.set_infocCst|j|j|jdS)zset the kind for this columnN)r rrrkrrZrZr[r szIndexCol.set_attr)rr`cCsH|jdkrD|j}||j}|durD|durDt||dddsDtddS)z:validate that kind=category does not change the categoriescategoryNTZ strict_nanZ dtype_equalzEcannot append a categorical with different categories to the existing)rr read_metadatarr*r)rrZ new_metadataZ cur_metadatarZrZr[r s  zIndexCol.validate_metadatacCs|jdur||j|jdS)zset the meta dataN)rrr)rrrZrZr[r/ s zIndexCol.write_metadata) NNNNNNNNNNNNN)N)N)"rrrrrrrrrrrrrrrrr~rrrrrrrrrrrrr rrrrrZrZrZr[rsb   + @       rc@sDeZdZdZeddddZddddd d d Zd dd dZdS)GenericIndexColz:an index which is not represented in the data of the tablerrcCsdSNFrZrrZrZr[r~8 szGenericIndexCol.is_indexedrr^ztuple[Index, Index]rcCs,t|tjsJt|tt|}||fS)z Convert the data from this selection to the appropriate pandas type. Parameters ---------- values : np.ndarray nan_rep : str encoding : str errors : str )rUrVrrr0rt)rrarr_rrrZrZr[r< s  zGenericIndexCol.convertrcCsdSrarZrrZrZr[rN szGenericIndexCol.set_attrN)rrrrrr~rrrZrZrZr[r5 s rc s>eZdZdZdZdZddgZd;dddd d fd d Zedd ddZ edd ddZ dd ddZ dddddZ dd dddZ ddZeddd d!d"Zed#d$Zedd%d&d'd(Zeddd&d)d*Zed+d,Zed-d.Zed/d0Zed1d2Zd d d3d4Zd5ddd6d7d8Zd d d9d:ZZS)<DataCola3 a data holding column, by definition this is not indexable Parameters ---------- data : the actual data cname : the column name in the table to hold the data (typically values) meta : a string description of the metadata metadata : the actual metadata FrreNr^r]zDtypeArg | Noner)rfrrr`c s2tj||||||||| | | d | |_| |_dS)N) rfrarkrrrrrer{rr)superrrr)rrfrarkrrrrrer{rrrr __class__rZr[rc s zDataCol.__init__rcCs |jdS)N_dtypererrZrZr[ dtype_attr szDataCol.dtype_attrcCs |jdS)N_metarerrZrZr[ meta_attr szDataCol.meta_attrcCs@ttt|j|j|j|j|jf}dddt gd|DS)NrcSsg|]\}}|d|qSrrZrTrZrZr[rq sz$DataCol.__repr__..)rfrrrkshape) rsrrCrfrrrkrrr9rrZrZr[r s zDataCol.__repr__rrrcstfdddDS)rc3s&|]}t|dt|dkVqdSrarrrrZr[rR sz!DataCol.__eq__..)rfrrrrrrZrr[r szDataCol.__eq__rL)rr`cCs@|dus J|jdusJt|\}}||_||_t||_dSra)r_get_data_and_dtype_namer_dtype_to_kindrk)rr dtype_namerZrZr[set_data s   zDataCol.set_datacCs|jS)zreturn the datarrrZrZr[r szDataCol.take_datarH)rar`cCs|j}|j}|j}|jdkr&d|jf}t|trJ|j}|j||jj d}n~t |ds`t|t rl| |}n\t |dr||}nDt|rtj||dd}n&t|r|||}n|j||j d}|S)zW Get an appropriately typed and shaped pytables.Col object for values. rkrkrmrrr)rrrrZsizerUr6codes get_atom_datarfrrr'get_atom_datetime64get_atom_timedelta64r"rZ ComplexColr$get_atom_string)rrarrrr'atomrZrZr[ _get_atom s$      zDataCol._get_atomcCstj||ddS)Nrr%rrrrrrZrZr[r+ szDataCol.get_atom_stringz type[Col]rkr`cCsR|dr$|dd}d|d}n"|dr4d}n|}|d}tt|S)z0return the PyTables column class for this columnuintNZUIntrHperiodInt64Col)ry capitalizerqr)rrkZk4Zcol_nameZkcaprZrZr[get_atom_coltype s    zDataCol.get_atom_coltypecCs|j|d|ddS)Nr#rrr6rrrkrZrZr[r( szDataCol.get_atom_datacCstj|ddSNrr7rr4rrrZrZr[r) szDataCol.get_atom_datetime64cCstj|ddSr:r;r<rZrZr[r* szDataCol.get_atom_timedelta64cCst|jddS)Nr)rqrrrZrZr[r sz DataCol.shapecCs|jSrr"rrZrZr[r szDataCol.cvaluescCs`|r\t|j|jd}|dur2|t|jkr2tdt|j|jd}|dur\||jkr\tddS)zAvalidate that we have the same order as the existing & same dtypeNz4appended items do not match existing items in table!z@appended items dtype do not match existing items dtype in table!)rqrrrrrarrr)rrZexisting_fieldsZexisting_dtyperZrZr[r szDataCol.validate_attrr)rar_rcCst|tjsJt||jjdur.||j}|jdus.cSsg|]}t|qSrZr fromtimestamprErZrZr[rq= rrF) categoriesrevalidaterOrrr_r)#rUrVrrrrrrrrrkr\rrrerryrasarrayrrravelr-Zfloat64r5anyastyperhZcumsum_valuesr6Z from_codesr_unconvert_string_arrayra)rrarr_r convertedr rkrrrerrrIr'maskrZrZr[r sf               zDataCol.convertcCsHt|j|j|jt|j|j|j|jdus2Jt|j|j|jdS)zset the data for this columnN)r rrrarrrrrrZrZr[rf szDataCol.set_attr) NNNNNNNNNNNN)rrrrrrrrrrrrrr!r classmethodr-r+r6r(r)r*rrrrr __classcell__rZrZrr[rR sX          drc@sZeZdZdZdZddddZeddZed d d d d ZeddZ eddZ dS)DataIndexableColz+represent a data column that can be indexedTrrcCstt|jjstddS)N-cannot have non-object label DataIndexableCol)r$r-rarrrrZrZr[rs szDataIndexableCol.validate_namescCstj|dS)N)rr.r/rZrZr[r+x sz DataIndexableCol.get_atom_stringr^rHr0cCs|j|dS)Nr#r8r9rZrZr[r(| szDataIndexableCol.get_atom_datacCs tSrar;r<rZrZr[r) sz$DataIndexableCol.get_atom_datetime64cCs tSrar;r<rZrZr[r* sz%DataIndexableCol.get_atom_timedelta64N) rrrrrrrVr+r(r)r*rZrZrZr[rXn s  rXc@seZdZdZdS)GenericDataIndexableColz(represent a generic pytables data columnN)rrrrrZrZrZr[rZ srZc@seZdZUdZded<dZded<ded<ded <d ed <d Zd ed<dNd dddddddZed dddZ eddddZ eddZ dddd Z ddd!d"Z ddd#d$Zed%d&Zed'd(Zed)d*Zed+d,Zeddd-d.Zed dd/d0Zed1d2Zddd3d4Zddd5d6Zed7d8Zed dd9d:Zed;d<Zd=dd>d?ZdOdddAdBZd ddCdDZdPdEdEdFdGdHZdddIdJZdQdEdEddKdLdMZ d@S)RFixedz represent an object in my store facilitate read/write of various types of objects this is an abstract base class Parameters ---------- parent : HDFStore group : Node The group node where the table resides. r^ pandas_kindrz format_typetype[DataFrame | Series]obj_typerhrZrrFrr:rTrrJr]r)rrr_rr`cCsZt|tsJt|tdus"Jt|tjs:Jt|||_||_t||_||_ dSra) rUrrrrJrrrdr_r)rrrr_rrZrZr[r s  zFixed.__init__rcCs*|jddko(|jddko(|jddkS)Nrrk )versionrrZrZr[is_old_version szFixed.is_old_versionztuple[int, int, int]cCs`tt|jjdd}z0tdd|dD}t|dkrB|d}WntyZd}Yn0|S) zcompute and set our versionpandas_versionNcss|]}t|VqdSrarhr)rZrZr[rR rz Fixed.version...rar+)rrr)r\rqrrrrsrrtr)rrbrZrZr[rb s    z Fixed.versioncCstt|jjddS)Nrn)r\rqrrrrrZrZr[rn szFixed.pandas_typecCs^||j}|durXt|ttfrDddd|D}d|d}|jdd|d S|jS) (return a pretty representation of myselfNrcSsg|] }t|qSrZrCr)rZrZr[rq rz"Fixed.__repr__..[r(12.12z (shape->))rrrUrrrsrrn)rrYZjshaperZrZr[r s zFixed.__repr__cCst|j|j_tt|j_dS)zset my pandas type & versionN)r^r\rrn_versionrdrrZrZr[r szFixed.set_object_infocCst|}|SrarK)rZnew_selfrZrZr[r s z Fixed.copycCs|jSra)rrrZrZr[r sz Fixed.shapecCs|jjSrarrrrZrZr[r; szFixed.pathnamecCs|jjSra)rrrrZrZr[r sz Fixed._handlecCs|jjSra)rrrrZrZr[r szFixed._filterscCs|jjSra)rrrrZrZr[r szFixed._complevelcCs|jjSra)rrrrZrZr[r szFixed._fletcher32cCs|jjSra)rrrrrZrZr[r sz Fixed.attrscCsdSzset our object attributesNrZrrZrZr[ set_attrs szFixed.set_attrscCsdS)zget our object attributesNrZrrZrZr[ get_attrs szFixed.get_attrscCs|jS)zreturn my storablerrrZrZr[storable szFixed.storablecCsdSrrZrrZrZr[r szFixed.is_existscCst|jddS)Nr)rqrqrrZrZr[r sz Fixed.nrowszLiteral[True] | NonecCs|dur dSdS)z%validate against an existing storableNTrZrrZrZr[rJ szFixed.validateNcCsdS)+are we trying to operate on an old version?NrZ)rrurZrZr[validate_version szFixed.validate_versioncCs|j}|durdS|dS)zr infer the axes of my storer return a boolean indicating if we have a valid storer or not NFT)rqrp)rrYrZrZr[r s zFixed.infer_axesrrrcCs tddS)Nz>cannot read on an abstract storer: subclasses should implementrrrurrrrZrZr[r sz Fixed.readcKs tddS)Nz?cannot write on an abstract storer: subclasses should implementrurrrrZrZr[r& sz Fixed.writerrr`cCs0t|||r$|jj|jdddStddS)zs support fully deleting the node in its entirety (only) - where specification must be None TrCNz#cannot delete on an abstract storer)rGrHrrrr)rrurrrZrZr[rI+ sz Fixed.delete)rTr)N)NNNN)NNN)!rrrrrr]r:rrrcrbrnrrrrr;rrrrrrorprqrrrJrsrrrrIrZrZrZr[r[ sh                r[c@sFeZdZUdZedediZddeDZgZ de d<dd d d Z d d Z ddZ dd ddZedd ddZdd ddZdd ddZdd ddZd:dddddd Zd;dddd!d"d#d$Zdd!dd%d&d'Zdd(dd%d)d*Zddd5d6dd7d8d9ZdS)? GenericFixedza generified fixed versiondatetimer3cCsi|]\}}||qSrZrZ)rmr'rUrZrZr[rV= rzGenericFixed.r attributesr^rcCs|j|dS)N)_index_type_mapr)rrrZrZr[_class_to_aliasA szGenericFixed._class_to_aliascCst|tr|S|j|tSra)rUr_reverse_index_maprr-)raliasrZrZr[_alias_to_classD s zGenericFixed._alias_to_classcCs|tt|dd}|tkr.d dd}|}n|tkrFd dd}|}n|}i}d|vrn|d|d<|turnt}d|vrt|dtr|d d|d<n |d|d<|tusJ||fS) N index_classr|cSs>tj|j|j|d}tj|dd}|dur:|d|}|S)N)rrreUTC)r7 _simple_newrarr, tz_localize tz_convert)rarrZdtaresultrZrZr[r|S s z*GenericFixed._get_index_factory..fcSs$t|}tj||d}tj|ddS)NrBre)r)r8rr/)rarrrZparrrZrZr[r|` srrzutf-8)NN)NN) rr\rqr,r/r-r3rUbytesrX)rrrr|rrrZrZr[_get_index_factoryJ s*     zGenericFixed._get_index_factoryrcCs$|durtd|dur tddS)zE raise if any keywords are passed which are not-None Nzqcannot pass a column specification when reading a Fixed format store. this store must be selected in its entiretyzucannot pass a where specification when reading from a Fixed format store. this store must be selected in its entirety)r)rrrurZrZr[ validate_read{ szGenericFixed.validate_readrcCsdS)NTrZrrZrZr[r szGenericFixed.is_existscCs|j|j_|j|j_dSrn)r_rrrrZrZr[ro s zGenericFixed.set_attrsc CsRtt|jdd|_tt|jdd|_|jD]}t||tt|j|dq.dS)retrieve our attributesr_Nrr)rdrqrr_r\rr{r )rrrZrZr[rp s zGenericFixed.get_attrscKs |dSra)rorwrZrZr[r szGenericFixed.writeNrrc Csddl}t|j|}|j}t|dd}t||jrd|d||}t|dd} | durt|| d}ntt|dd} t|dd} | durtj | | d}n |||}| r| drt|d d} t || d d }n| d krtj |d d}|r|j S|SdS)z2read an array for the specified node (off of grouprN transposedF value_typerBrr=rTr>r@rA)rrqrrrrUZVLArraypd_arrayr\rVrryrrNT) rrrrrrrrretrrrrZrZr[ read_array s,       zGenericFixed.read_arrayr-)rrrr`cCshtt|j|d}|dkr.|j|||dS|dkrVt|j|}|j|||d}|Std|dS)N_varietymultirtregularzunrecognized index variety: )r\rqrread_multi_indexrread_index_noder)rrrrZvarietyrrrZrZr[ read_index s zGenericFixed.read_index)rrr`cCst|tr,t|j|dd|||nt|j|ddtd||j|j}|||j t |j |}|j |j _ |j|j _t|ttfr|t||j _t|tttfr|j|j _t|tr|jdurt|j|j _dS)Nrrrr)rUr.r rwrite_multi_index_convert_indexr_r write_arrayrarqrrkrrrfr,r/r~rrr3rr_get_tz)rrrrTrrZrZr[ write_index s     zGenericFixed.write_indexr.c Cst|j|d|jtt|j|j|jD]\}\}}}t|j t rNt d|d|}t |||j |j}|||jt|j|} |j| j_|| j_t| j|d|||d|} || |q,dS)N_nlevelsz=Saving a MultiIndex with an extension dtype is not supported._level_name_label)r rr enumerater9levelsr'namesrUrr(rrr_rrrarqrrkrrrf) rrrilev level_codesrf level_keyZ conv_levelr label_keyrZrZr[r s"   zGenericFixed.write_multi_indexcCst|j|d}g}g}g}t|D]l}|d|} t|j| } |j| ||d} || || j|d|} |j| ||d} || q&t|||ddS)NrrrtrT)rr'rr1) rqrrYrrrrfrr.)rrrrrrr'rrrrrrrrZrZr[r s      zGenericFixed.read_multi_indexrJ)rrrr`c Csb|||}d|jvr>t|jjdkr>tj|jj|jjd}t|jj}d}d|jvrlt|jj }t|}|j}| |\}} |dvr|t |||j |j dfdti| } nz$|t |||j |j dfi| } WntyV} zj|j dkr@td r@t| d r@tr@|t |||j |j dfdtd tjd i| } nWYd} ~ n d} ~ 00|| _ | S) NrrrBrf)rrrrrrrrr)rrrVprodrrrr\rkrgrfr_unconvert_indexr_rrrrr^rrr2r) rrrrrrkrfrrrrrJrZrZr[r sb          zGenericFixed.read_index_noderL)rrr`cCsJtd|j}|j|j||t|j|}t|j|j _ |j |j _ dS)zwrite a 0-len arrayrkN) rVrrZr create_arrayrrqr^rrrrr)rrrZarrrrZrZr[write_array_emptyN s  zGenericFixed.write_array_emptyrKz Index | None)rrrr`c Cst|dd}||jvr&|j|j||jdk}d}t|jtrHtd|s`t |dr`|j }d}d}|j durt t  tj|j}Wdn1s0Y|dur|s|jj|j|||j|j d}||dd<n |||n|jjtjkrdtj|dd} |rn,| d krn t| ||f} tj| ttd |j|j|t} | |nBt!|jd r|j"|j||#d t$|jt%|j|j&_'nt|jt(r|j"|j||j)t%|j|} t*|j+| j&_+d |jj,d| j&_'nt!|jdr2|j"|j||#d dt%|j|j&_'ntt|t-r|j|j|t} | |.t%|j|} t$|j| j&_'n&|r|||n|j"|j|||t%|j|j&_/dS)NT)Z extract_numpyrFz]Cannot store a category dtype in a HDF5 dataset that uses format="fixed". Use format="table".r)rZskipnarrrr datetime64[r(r$r@)0r=rrrr&rUrr&rrrrrrrZAtomZ from_dtypeZ create_carrayrrrrVZobject_r infer_dtyperyrrrrZcreate_vlarray ObjectAtomrrrviewr^rqrrrr'asi8rrunitr9to_numpyr) rrrrrZ empty_arrayrr,ca inferred_typer ZvlarrrrZrZr[rW sp       .     zGenericFixed.write_array)NN)NN)NN)NN)N)rrrrr,r/r}rrr{rr~rrrrrrorprrrrrrrrrrZrZrZr[ry9 s2   1&7 rycsVeZdZUdZdgZded<eddZddddd d d Zd d fdd Z Z S)rrrfrDc Cs.zt|jjfWSttfy(YdS0dSra)rtrrarrrrZrZr[r szSeriesFixed.shapeNrr1rxc Cs||||jd||d}|jd||d}zt|||jdd}Wnjty}zR|jdkrtdrt| drt rt|||jdt d t j d d }nWYd}~n d}~00|S) NrrtraF)rrfrrrrrr)rrfrr)rrrr1rfrrrr^rrr2rVr) rrurrrrrarrJrZrZr[r s.   zSeriesFixed.readrrc s<tj|fi||d|j|d||j|j_dS)Nrra)rrrrrrfrrwrrZr[r s zSeriesFixed.write)NNNN) rrrr\r{rrrrrrWrZrZrr[r s  rcsZeZdZUddgZded<eddddZdd d d d d d Zddfdd ZZ S)BlockManagerFixedrZnblocksrhz Shape | NonercCsz|j}d}t|jD]8}t|jd|d}t|dd}|dur||d7}q|jj}t|dd}|durt|d|d}ng}|||WStyYdS0dS)Nrblock_itemsrrk) rZrYrrqrZ block0_valuesrrrr)rrZrrrrrZrZr[r s"    zBlockManagerFixed.shapeNrr+rxcCs\||||d}g}t|jD]<}||kr<||fnd\}} |jd||| d} || q(|d} g} t|jD]}|d|d} |jd|d|| d}| | | }t |j ||dd d }t rt |tjrt|d d r|ttjd }| |q|t| dkrHt| dd d}tr6|}|j| d d}|St |d|ddS)Nr)NNr0rtrrrRrkFrrrTr)r)r0r)rrrr)rr_Z_get_block_manager_axisrYrZrrrrr_r+rrrUrVrrrQr2rrtr4rrrd)rrurrrZ select_axisrKrrraxrdfs blk_itemsradfoutrZrZr[r s:     zBlockManagerFixed.readrc stj|fi|t|jtr*|d}|j}|s@|}|j|j _t |j D]0\}}|dkrr|j srt d|d||qTt|j|j _t |jD]D\}}|j|j}|jd|d|j|d|d|d|qdS)Nrrz/Columns index has to be unique for fixed formatr0rR)rr)rrrU_mgrr? _as_managerZis_consolidatedZ consolidaterZrrrKZ is_uniquerrrtblocksrrr`mgr_locsrra)rrrrrrblkrrrZr[r6 s    zBlockManagerFixed.write)NNNN) rrrr{rrrrrrWrZrZrr[r s -rc@seZdZdZeZdS)rrN)rrrr\r+r_rZrZrZr[rP src seZdZUdZdZdZded<ded<dZded <d Zd ed <dddddddddddd fdd Z e ddddZ ddddZ dd d!d"Z ddd#d$Ze d%dd&d'Zd(d)d*d+d,Ze d-dd.d/Ze d%dd0d1Ze d2d3Ze d4d5Ze d6d7Ze d8d9Ze d:dd;d<Ze d-dd=d>Ze d%dd?d@Ze dAddBdCZdDddEdFZdGdHZdIddJdKZdddLdMdNZddOddPdQdRZddSdTdUZ dddVdWZ!dddXdYZ"ddddZd[Z#ddd\d]Z$e%d^d_Z&dddd`dadbZ'ddcdcdddedfdgZ(e)d%dhdidjZ*dkdlZ+ddmd%dndodpZ,e-dmd%dqdrdsZ.ddtdmdudvdwZ/dcd%dcdDdxdydzZ0ddcdcd{d|d}Z1dddcdcd~ddZ2Z3S)raa represent a table: facilitate read/write of various types of tables Attrs in Table Node ------------------- These are attributes that are store in the main table node, they are necessary to recreate these tables when read back in. index_axes : a list of tuples of the (original indexing axis and index column) non_index_axes: a list of tuples of the (original index axis and columns on a non-indexing axis) values_axes : a list of the columns which comprise the data of this table data_columns : a list of the columns that we are allowing indexing (these become single columns in values_axes) nan_rep : the string to use for nan representations for string objects levels : the names of levels metadata : the names of the metadata columns Z wide_tabler{r^r]rrkzint | list[Hashable]rTrrrNrrrJr]zlist[IndexCol] | Nonez list[tuple[AxisInt, Any]] | Nonezlist[DataCol] | Nonez list | Nonez dict | Noner) rrr_r index_axesr, values_axesrrr`c sPtj||||d|pg|_|p$g|_|p.g|_|p8g|_| pBi|_| |_dS)Nr)rrrr,rrrr) rrrr_rrr,rrrrrrZr[ru s      zTable.__init__rcCs|jddS)N_r)rrrrZrZr[table_type_short szTable.table_type_shortc Cs|t|jrd|jnd}d|d}d}|jrZddd|jD}d|d}dd d|jD}|jd |d |jd |j d |j d|d|d S)rgrr|z,dc->[r(rfcSsg|] }t|qSrZr^r)rZrZr[rq rz"Table.__repr__..ricSsg|] }|jqSrZrerrZrZr[rq rrjz (typ->z,nrows->z,ncols->z ,indexers->[rk) rrtrrrcrbrrnrrncols)rZjdcrfverZjverZ jindex_axesrZrZr[r s(  zTable.__repr__)rcCs"|jD]}||jkr|SqdS)zreturn the axis for cN)rKrf)rrrrZrZr[r s   zTable.__getitem__c Cs|dur dS|j|jkr2td|jd|jddD]}t||d}t||d}||kr6t|D]n\}}||}||krb|dkr|j|jkrtd|jdd |jd |jd td |d |d|dqbtd |d |d|dq6dS)z"validate against an existing tableNz'incompatible table_type with existing [rr()rr,rrCannot serialize the column [rz%] because its data contents are not [z] but [] object dtypezinvalid combination of [z] on appending data [z] vs current table [)rrrqrrkrrarF)rrrsvovrsaxZoaxrZrZr[rJ sJ   zTable.validatercCs t|jtS)z@the levels attribute is 1 or a list in the case of a multi-index)rUrrrrrZrZr[is_multi_index szTable.is_multi_indexrz tuple[DataFrame, list[Hashable]])rr`c Cs`t|jj}z |}Wn.tyH}ztd|WYd}~n d}~00t|tsXJ||fS)ze validate that we can store the multi-index; reset and return the new object zBduplicate names/columns in the multi-index when storing as a tableN)rGZfill_missing_namesrrZ reset_indexrrUr+)rrrZ reset_objrJrZrZr[validate_multiindex s zTable.validate_multiindexrhcCstdd|jDS)z-based on our axes, compute the expected nrowscSsg|]}|jjdqSr+)rrrmrrZrZr[rq rz(Table.nrows_expected..)rVrrrrZrZr[nrows_expected szTable.nrows_expectedcCs d|jvS)zhas this table been createdr{rrrZrZr[r szTable.is_existscCst|jddSNr{rqrrrZrZr[rq szTable.storablecCs|jS)z,return the table group (this is my storable))rqrrZrZr[r{ sz Table.tablecCs|jjSra)r{rrrZrZr[r sz Table.dtypecCs|jjSrarrrZrZr[r szTable.descriptionzitertools.chain[IndexCol]cCst|j|jSra)r7r8rrrrZrZr[rK sz Table.axescCstdd|jDS)z.the number of total columns in the values axescss|]}t|jVqdSra)rtrarrZrZr[rRrzTable.ncols..)sumrrrZrZr[rsz Table.ncolscCsdSrrZrrZrZr[ is_transposedszTable.is_transposedztuple[int, ...]cCs(ttdd|jDdd|jDS)z@return a tuple of my permutated axes, non_indexable at the frontcSsg|]}t|dqSr+rerrZrZr[rqrz*Table.data_orientation..cSsg|]}t|jqSrZ)rhr0rrZrZr[rqr)rsr7r8r,rrrZrZr[data_orientation s zTable.data_orientationzdict[str, Any]csRdddddjD}fddjD}fddjD}t|||S)z.csg|]\}}|dfqSrarZ)rmr0ra) axis_namesrZr[rqrcs&g|]}|jtjvr|j|fqSrZ)rfrXrrrErrZr[rqs)rr,rrM)rZd1Zd2Zd3rZ)rrr[ queryabless  zTable.queryablescCsdd|jDS)zreturn a list of my index colscSsg|]}|j|jfqSrZ)r0rrrZrZr[rq'rz$Table.index_cols..rrrZrZr[ index_cols$szTable.index_colsrcCsdd|jDS)zreturn a list of my values colscSsg|] }|jqSrZrrrZrZr[rq+rz%Table.values_cols..)rrrZrZr[ values_cols)szTable.values_colsrcCs|jj}|d|dS)z)return the metadata pathname for this keyz/meta/z/metarmr rZrZr[_get_metadata_path-szTable._get_metadata_pathr)rrar`cCs0|jj||t|ddd|j|j|jddS)z Write out a metadata array to the key as a fixed-format Series. Parameters ---------- key : str values : ndarray FrKr{)rr_rrN)rrrr1r_rr)rrrarZrZr[r2s  zTable.write_metadatarcCs0tt|jdd|ddur,|j||SdS)z'return the meta data array for this keyrN)rqrrrrrrZrZr[rDszTable.read_metadatacCspt|j|j_||j_||j_|j|j_|j|j_|j|j_|j|j_|j |j_ |j |j_ |j |j_ dS)zset our table type & indexablesN) r^rrrrr,rrr_rrrrrZrZr[roJs        zTable.set_attrscCst|jddpg|_t|jddp$g|_t|jddp8i|_t|jdd|_tt|jdd|_tt|jdd|_ t|jd dpg|_ d d |j D|_ d d |j D|_ dS) rr,Nrrrr_rrrcSsg|]}|jr|qSrZrrrZrZr[rq`rz#Table.get_attrs..cSsg|]}|js|qSrZrrrZrZr[rqar)rqrr,rrrrdr_r\rr indexablesrrrrZrZr[rpWszTable.get_attrscCs>|dur:|jr:tddd|jD}tj|ttddS)rrNrfcSsg|] }t|qSrZrr)rZrZr[rqgrz*Table.validate_version..r)rcrwrrbrrrr)rrur rZrZr[rscszTable.validate_versioncCsR|dur dSt|tsdS|}|D]&}|dkr4q&||vr&td|dq&dS)z validate the min_itemsize doesn't contain items that are not in the axes this needs data_columns to be defined Nrazmin_itemsize has the key [z%] which is not an axis or data_column)rUrMrr)rrqr'rZrZr[validate_min_itemsizens  zTable.validate_min_itemsizec sg}jjjtjjD]j\}\}}t|}|}|durJdnd}|d}t|d} t|||| |j||d} || qt j t |fdd| fddtjj D|S) z/create/cache the indexables if they don't existNrr)rfr0rrkrr{rrc st|tsJt}|vrt}t|}t|j}t|dd}t|dd}t|}|}t|dd} |||||||j | ||d } | S)Nrrr) rfrrarkrrr{rrr) rUr^rrXrq_maybe_adjust_namerbrrr{) rrklassr,adj_namerarrkmdrr)base_posrfdescr table_attrsrZr[r|s0    zTable.indexables..fcsg|]\}}||qSrZrZ)rmrr)r|rZr[rqrz$Table.indexables..)rr{rrrrqrrrrXrrtr\r) r _indexablesrr0rfr,rrrrk index_colrZ)rrfrr|rrr[rs2      % zTable.indexablesr0c CsV|s dS|durdS|dus(|dur8dd|jD}t|ttfsL|g}i}|dur`||d<|durp||d<|j}|D]}t|j|d}|dur"|jr|j }|j } |j } |dur| |kr| n| |d<|dur| |kr| n| |d<|jsP|j drtd |jfi|qz||jd d vrztd |d |d|dqzdS)aZ Create a pytables index on the specified columns. Parameters ---------- columns : None, bool, or listlike[str] Indicate which columns to create an index on. * False : Do not create any indexes. * True : Create indexes on all columns. * None : Create indexes on all columns. * listlike : Create indexes on the given columns. optlevel : int or None, default None Optimization level, if None, pytables defaults to 6. kind : str or None, default None Kind of index, if None, pytables defaults to "medium". Raises ------ TypeError if trying to create an index on a complex-type column. Notes ----- Cannot index Time64Col or ComplexCol. Pytables must be >= 3.0. NFTcSsg|]}|jr|jqSrZ)rrrrZrZr[rqrz&Table.create_index..rjrkcomplexzColumns containing complex values can be stored but cannot be indexed when using table format. Either use fixed format, set index=False, or do not include the columns containing complex values to data_columns when initializing the table.rrkzcolumn z/ is not a data_column. In order to read column z: you must reload the dataframe into HDFStore and include z with the data_columns argument.)rrKrUrsrrr{rqrQr~rrjrkZ remove_indexrryrrlr,r) rrrjrkkwr{rrUrZ cur_optlevelZcur_kindrZrZr[rlsR   zTable.create_indexrz9list[tuple[np.ndarray, np.ndarray] | tuple[Index, Index]]rxc CsZt||||d}|}g}|jD]2}||j|j||j|j|jd}| |q"|S)a Create the axes sniffed from the table. Parameters ---------- where : ??? start : int or None, default None stop : int or None, default None Returns ------- List[Tuple[index_values, column_values]] rrM) SelectionrrKrrrrr_rr) rrurr selectionrarrresrZrZr[ _read_axes%s   zTable._read_axesrcCs|S)zreturn the data for this objrZrrrrZrZr[ get_objectGszTable.get_objectcst|s gS|d\}|j|i}|ddkrL|rLtd|d||dur^t}n |durjg}t|trt|t|}|fdd | Dfd d |DS) zd take the input data_columns and min_itemize and create a data columns spec rrr.z"cannot use a multi-index on axis [z] with data_columns TNcs g|]}|dkr|vr|qSrrZr&)existing_data_columnsrZr[rqhsz/Table.validate_data_columns..csg|]}|vr|qSrZrZ)rmr) axis_labelsrZr[rqpr) rtrrrrrrUrMrXr\r)rrrr,r0rrZ)rrr[validate_data_columnsLs.     zTable.validate_data_columnsr+)rrJc/stts,|jj}td|dtddur:dgfddD|rzd}d d|jDt|j }|j }nd }|j } |j d ksJt |j d krtd g} |durd}tfdddD} j| } t| } |rHt | }|j|d }tt| t|dddsHttt| tt|dddrH|} | | i}t| j|d<t| j|d<| | | fd} j| } | }t|| |j|j}| |_|d| | |!||g}t |}|d ksJt | d ksJ| D]} t"| d| d q|jd k}|#||| }|$|%}|&||| |j'|\}}g}t(t)||D]\}\}}t*}d}|rt |d kr|d|vrt+}|d}|dust|t,std|r4|r4z|j'|}WnDt-t.fy0} z&td|d|j'd| WYd} ~ n d} ~ 00nd}|pFd|}!t/|!|j0||||j|j|d}"t1|!|j2}#|3|"}$t4|"j5j6}%d}&t7|"dddurt8|"j9}&d}'}(})t|"j5t:r|"j;})d}'t<|"j=>}(nt|j5t?rt,|j5}'t@|"\}*}+||#|!t||$||%|&|)|'|(|+|*d },|, | ||,|d 7}qpdd|D}-t||jA|j|j|j|| ||-| |d }.tB|dr|jC|._C|.D||r|r|.E||.S) a0 Create and return the axes. Parameters ---------- axes: list or None The names or numbers of the axes to create. obj : DataFrame The object to create axes on. validate: bool, default True Whether to validate the obj against an existing object already written. nan_rep : A value to use for string column nan_rep. data_columns : List[str], True, or None, default None Specify the columns that we want to create to allow indexing on. * True : Use all available columns. * None : Use no columns. * List[str] : Use the specified columns. min_itemsize: Dict[str, int] or None, default None The min itemsize for a column in bytes. z/cannot properly create the storer for: [group->rr(Nrcsg|]}|qSrZ)_get_axis_numberr)rrZr[rqrz&Table._create_axes..TcSsg|] }|jqSrZrSrrZrZr[rqrFrarkz.rrrrrYzIncompatible appended table [z]with existing table [Z values_block_) existing_colrrr_rrrr) rfrrarrrkrrerrrrcSsg|]}|jr|jqSrZ)rrf)rmrrZrZr[rqKr) rrr_rrr,rrrrr)FrUr+rrrrrrrrrrrrZrtrrWrKr,r*rVr<r^rrrrZ_get_axis_namerr_rr0rr r _reindex_axisrrr2_get_blocks_and_itemsrrr9rrXr^ IndexErrorr_maybe_convert_for_string_atomrarrbr-rrrfrqrrr&rerNrIrOr2rrrrrrJ)/rrKrrJrrrr table_existsZnew_infonew_non_index_axesr rZ append_axisZindexerZ exist_axisr axis_nameZ new_indexZnew_index_axesjrrrrZvaxesrrb_itemsrrfrrJnew_namedata_convertedrrrkrrrrerr rZdcsZ new_tablerZ)rKrr[ _create_axesrs0             "               zTable._create_axes)rrc Cst|jtr|d}dd}|j}tt|}t|j}||}t|r|d\} } t |  t |} |j | | dj}tt|}t|j}||}|D]:} |j | g| dj}tt|}| |j| ||q|rddt ||D} g}g}|D]}t|j}z&| |\}}||||Wqttfy|}z2dd d |D}td |d |WYd}~qd}~00q|}|}||fS) NrcsfddjDS)Ncsg|]}j|jqSrZ)rr`r)rmrmgrrZr[rqsrzFTable._get_blocks_and_items..get_blk_items..)rr rZr r[ get_blk_itemsrsz2Table._get_blocks_and_items..get_blk_itemsrrScSs"i|]\}}t|||fqSrZ)rstolist)rmbrrZrZr[rVsz/Table._get_blocks_and_items..rcSsg|] }t|qSrZrh)rmitemrZrZr[rqrz/Table._get_blocks_and_items..z+cannot match existing table structure for [z] on appending data)rUrr?rr r@rrrrtr-r]rdr\r9rsrar<rrrrr)rrrrrrr rrr0rZ new_labelsrZby_itemsZ new_blocksZ new_blk_itemsZearrrrJZjitemsrZrZr[rdsR            zTable._get_blocks_and_itemsr)rr`c s|durt|}|durNjrNtjts.JjD]}||vr4|d|q4jD]$\}}t|||fdd}qT|jdur|jD]\}} } ||| | qS)zprocess axes filtersNrcsjD]}|}|}|dus*J||krfjrH|tj}|||}j|d|S||vrtt |j }t|}t t rd|}|||}j|d|Sqt d|ddS)NrSrkzcannot find the field [z] for filtering!)Z _AXIS_ORDERSr _get_axisrunionr-rrcr>rqrarUr+r)fieldfiltoprZ axis_numberZ axis_valuesZtakersrarrrZr[process_filters"       z*Table.process_axes..process_filter) rrrrUrinsertr,rfilterr) rrrrrr0labelsrrrrrZrr[ process_axess  zTable.process_axes)rrrLr`cCs|durt|jd}d|d}dd|jD|d<|rj|durH|jpFd}tj|||pZ|jd }||d <n|jdur~|j|d <|S) z:create the description of the table from the axes & valuesNi'r{)rfrLcSsi|]}|j|jqSrZ)rrrrZrZr[rVrz,Table.create_description..r )rrrr)maxrrKrrrrr)rrrrrLrNrrZrZr[create_descriptions       zTable.create_descriptionrtc Cs|||sdSt||||d}|}|jdur|jD]D\}}}|j|||dd} ||| j |||j }qBt |S)zf select coordinates (row numbers) from a table; return the coordinates object FrNrkrt) rsrr select_coordsrrr$rrilocrar-) rrurrrZcoordsrrrrrZrZr[rs   zTable.read_coordinatesr#c Cs||sdS|dur$td|jD]}||jkr*|jsNtd|dt|jj |}| |j |j ||||j |j|jd}t|d|j}t|jj|dd} t||d| d Sq*td|d dS) zj return a single column from the table, generally only indexables are interesting FNz4read_column does not currently accept a where clausezcolumn [z=] can not be extracted individually; it is not data indexablerMrkr)rfrrz] not found in the table)rsrrrKrfrrrqr{rQrrrrr_rrrrr1r) rr"rurrrrZ col_valuesZcvsrrZrZr[r$s.      zTable.read_column)NrNNNNNN)N)NNN)NN)TNNN)N)NNN)NNN)4rrrrr\r]rrr:rrrrrrJrrrrrqr{rrrKrrrrrrrrrrorprsrrrrlrrVrrr  staticmethodrrrrr$rWrZrZrr[rU s   &'         LW"*sC7 rc@s4eZdZdZdZd dddddZdd d d ZdS) rz a write-once read-many table: this format DOES NOT ALLOW appending to a table. writing is a one-time operation the data are stored in a format that allows for searching the data on disk rNrrtcCs tddS)z[ read the indices and the indexing array, calculate offset rows and return z!WORMTable needs to implement readNrurvrZrZr[rOs zWORMTable.readrrcKs tddS)z write in a format that we can search later on (but cannot append to): write out the indices and the values using _write_array (e.g. a CArray) create an indexing table so that we can search z"WORMTable needs to implement writeNrurwrZrZr[r[szWORMTable.write)NNNN)rrrrrrrrZrZrZr[rFs rc @sheZdZdZdZddddddd d d Zddddd d dZddddddddZddddddZdS)r(support the new appendable table formatsZ appendableNFTrrr)rrrr?r`cCs|s|jr|j|jd|j||||| | d}|jD] }|q6|js|j|||| d}|| |d<|jj |jfi||j |j _ |jD]}| ||q|j || ddS)Nr{)rKrrJrrr)rrrrLr?)r)rrrrr rKrrroZ create_tablerrr write_data)rrrKrrrrrrrLrrrr?r{roptionsrZrZr[rjs4     zAppendableTable.write)rrr`cs|jj}|j}g}|rT|jD]6}t|jjdd}t|tj r| |j dddqt |r|d}|ddD] }||@}qp| }nd}dd |jD} t | } | dksJ| d d |jD} d d | D} g} t| D]2\} }|f|j|| | j}| ||q|dur d }tjt|||jd }||d}t|D]x} | |t| d||krxq|j|fdd | D|dur|ndfdd | DdqJdS)z` we form the data into a 2-d including indexes,values,mask write chunk-by-chunk rrSu1FrKrkNcSsg|] }|jqSrZ)rrrZrZr[rqrz.AppendableTable.write_data..cSsg|] }|qSrZ)rrrZrZr[rqrc Ss,g|]$}|tt|j|jdqSr)Z transposerVZrollarangerZrErZrZr[rqrrrBcsg|]}|qSrZrZrZend_iZstart_irZr[rqrcsg|]}|qSrZrZrEr(rZr[rqr)indexesrUra)rrrrr5rrOrUrVrrrQrtrOrrrreshaperrrYwrite_data_chunk)rrrrrmasksrrUr$r)nindexesrabvaluesrrUZ new_shaperowschunksrZr(r[r$sL        zAppendableTable.write_datarzlist[np.ndarray]znpt.NDArray[np.bool_] | None)r/r)rUrar`c Cs|D]}t|jsdSq|djd}|t|krFtj||jd}|jj}t|}t|D]\} } | ||| <q^t|D]\} }|||| |<q||dur|j t dd} | s|| }t|r|j ||j dS)z Parameters ---------- rows : an empty memory space where we are putting the chunk indexes : an array of the indexes mask : an array of the masks values : an array of the values NrrBFrK)rVrrrtrrrrrOrQrrOr{rr) rr/r)rUrarUrrr-rr r$rZrZr[r+s&   z AppendableTable.write_data_chunkrtcCsf|dust|sf|dur:|dur:|j}|jj|jddn(|durH|j}|jj||d}|j|S|srdS|j}t ||||d}| }t |dd }t|} | rb| } t| | dkj} t| sdg} | d| kr| | | ddkr| dd| } t| D]@} |t| | }|j||jd||jddd| } q|j| S) NTrCrtFrKrkrrH)rtrrrrr{Z remove_rowsrrrr r1Z sort_valuesdiffrrrrrr<reversedr`rY)rrurrrr{rraZ sorted_serieslnr1rZpgrr/rZrZr[rI sD      zAppendableTable.delete) NFNNNNNNFNNT)F)NNN) rrrrrrr$r+rIrZrZrZr[rds$;;,rc@s`eZdZUdZdZdZdZeZde d<e ddd d Z e dd d d Z ddddddZdS)rr#rrrar^r_rrcCs|jdjdkS)Nrrk)rr0rrZrZr[rOsz"AppendableFrameTable.is_transposedrcCs|r |j}|S)zthese are written transposed)rrrZrZr[rSszAppendableFrameTable.get_objectNrrtc s|sdSj|||d}tjrHjjddini}fddtjD}t|dkstJ|d}||d} g} tjD]\} } | j vrq|| \} }|ddkrt | }n t | }|d}|dur|j |d d jr |}|}t | t| d dd }n|j}t | t| d dd }|}|jdkrlt|tjrl|d|jdf}t|tjrzt|j||d d}Wntty}zZjdkrtdrt|drtrt|j||d tdtjdd}nWYd}~n d}~00n.t|t r$t|||d}ntj |g||d}t!rL|j"j#dksn|j$|j"k%snJ|j$|j"f|D]8}tj&j'|dd}|dvrr||(|||<qr| )|qt| dkr| d}n t*| dd}t+|||d}j,|||d}|S)Nrrcs"g|]\}}|jdur|qSr+r)rmrrrrZr[rqprz-AppendableFrameTable.read..rkrr.rTZinplacerfreFrrrrrr)rrrrrrLr)r^rrS)rr)-rsrrrtr,rrrrKrr-r. from_tuples set_namesrrqrrZrUrVrr*rr+rrrr^rrr2rZ _from_arraysrrrkZdtypesrOr{rrQrr4rr)rrurrrrrZindsindrframesrrZ index_valsrrQrraZindex_Zcols_rrJr"rrrZrr[rZs          "    zAppendableFrameTable.read)NNNN)rrrrr\rrZr+r_rrrrVrrrZrZrZr[rGs  rcsteZdZdZdZdZdZeZe ddddZ e dd d d Z dd dfdd Z dddddfdd ZZS)rr#rrrarrcCsdSrrZrrZrZr[rsz#AppendableSeriesTable.is_transposedrcCs|SrarZrrZrZr[rsz AppendableSeriesTable.get_objectNrc s@t|ts|jpd}||}tjf||jd|dS)+we are going to write this as a frame tablerarrN)rUr+rfZto_framerrrr)rrrrrfrrZr[rs   zAppendableSeriesTable.writerr1rxcs|j}|durB|rBt|jts"J|jD]}||vr(|d|q(tj||||d}|rj|j|jdd|jdddf}|j dkrd|_ |S)Nrr/Tr4ra) rrUrrrrrr set_indexr!rf)rrurrrrrrYrrZr[rs   zAppendableSeriesTable.read)N)NNNN)rrrrr\rrZr1r_rrrVrrrrWrZrZrr[rs rcs.eZdZdZdZdZddfdd ZZS)rr#rrrrc sb|jpd}||\}|_t|jts*Jt|j}||t||_tj fd|i|dS)r9rarN) rfrrrUrrrr-rrr)rrrrfZnewobjrQrrZr[rs    z AppendableMultiSeriesTable.write)rrrrr\rrrWrZrZrr[rsrc@speZdZUdZdZdZdZeZde d<e ddd d Z e d d Z d dddZ eddZd dddZdS)rz:a table that read/writes the generic pytables table formatrrrazlist[Hashable]rr^rcCs|jSra)r\rrZrZr[rn szGenericTable.pandas_typecCst|jddp|jSrrrrZrZr[rqszGenericTable.storablercCsLg|_d|_g|_dd|jD|_dd|jD|_dd|jD|_dS)rNcSsg|]}|jr|qSrZrrrZrZr[rqrz*GenericTable.get_attrs..cSsg|]}|js|qSrZrrrZrZr[rqrcSsg|] }|jqSrZrerrZrZr[rqr)r,rrrrrrrrZrZr[rps zGenericTable.get_attrsc Cs|j}|d}|durdnd}tdd|j||d}|g}t|jD]^\}}t|tsZJt||}||}|durzdnd}t |||g||j||d} | | qD|S)z0create the indexables from the table descriptionrNrr)rfr0r{rr)rfrrarr{rr) rrrr{rZ_v_namesrUr^rqrZr) rrNrrrrrrr,rfrZrZr[rs.     zGenericTable.indexablescKs tddS)Nz cannot write on an generic tableru)rrrZrZr[rCszGenericTable.writeN)rrrrr\rrZr+r_rrrnrqrprrrrZrZrZr[rs    #rcsfeZdZdZdZeZdZe dZ e ddddZ dd dfd d Z dd d dfdd ZZS)rza frame with a multi-indexrraz ^level_\d+$r^rcCsdS)NZappendable_multirZrrZrZr[rOsz*AppendableMultiFrameTable.table_type_shortNrc s||durg}n|dur |j}||\}|_t|jts@J|jD]}||vrF|d|qFtjf||d|dS)NTrr:) rrrrrUrrrrr)rrrrrrrZr[rTs  zAppendableMultiFrameTable.writerrtcsDtj||||d}|j}|jfdd|jjD|_|S)Nr/cs g|]}j|rdn|qSra) _re_levelssearch)rmrfrrZr[rqlrz2AppendableMultiFrameTable.read..)rrr;rrr6r)rrurrrrrrr[r`s  zAppendableMultiFrameTable.read)N)NNNN)rrrrrr+r_rZrecompiler<rrrrrWrZrZrr[rGs rr+rMr-)rr0rr`cCs||}t|}|dur"t|}|dus4||rB||rB|St|}|durlt|j|dd}||stddg|j}|||<|jt|}|S)NF)sort) rr>equalsuniquerbslicerZrcrs)rr0rrrZslicerrZrZr[rrs   rrz str | tzinfo)rr`cCst|}|S)z+for a tz-aware type, return an encoded zone)rZ get_timezone)rzonerZrZr[rs rznp.ndarray | Indexr,)rarr?r`cCsdSrarZrarr?rZrZr[rsrrcCsdSrarZrErZrZr[rszstr | tzinfo | Noneznp.ndarray | DatetimeIndexcCst|tr0|jdus"|j|ks"J|jdur0|S|dur|t|trJ|j}n d}|}t|}t||d}|d|}n|rtj |dd}|S)a coerce the values to a DatetimeIndex if tz is set preserve the input shape if possible Parameters ---------- values : ndarray or Index tz : str or tzinfo coerce : if we do not have a passed timezone, coerce to M8[ns] ndarray NrerM8[ns]rB) rUr,rrfrOr\rrrVrN)rarr?rfrZrZr[rs    )rfrr_rr`c Cst|tsJ|j}t|\}}t|}t|}t|j dsTt |j sTt |j rzt ||||t |ddt |dd|dSt|trtdtj|dd} t|} | dkrtjd d | Dtjd }t ||dt|d S| d krt| ||}|j j} t ||d t| |d S| dvr2t |||||dSt|tjrL|j tksPJ|dksbJ|t}t |||||d SdS)Niurr)rarkrrrrzMultiIndex not supported here!FrrcSsg|] }|qSrZ) toordinalrErZrZr[rqrz"_convert_index..rB)rr)integerZfloating)rarkrrr)rUr^rfrrrXr-rrrr%r!rrqr.rrrVrNZint32rZ Time32Col_convert_string_arrayrrrrr) rfrr_rrrTr rkr,rrarrZrZr[rs^             r)rkr_rr`cCs|dr,|dkrt|}qt||}n|dkr>t|}n|dkrztjdd|Dtd}Wqtytjdd|Dtd}Yq0nT|dvrt|}n@|d vrt|d||d }n&|d krt|d }ntd ||S)Nr=r@rcSsg|]}t|qSrZrCrErZrZr[rqrz$_unconvert_index..rBcSsg|]}t|qSrZrFrErZrZr[rqr)rIfloatrrrMrrzunrecognized index type ) ryr,rr3rVrNrrrS)rrkr_rrrZrZr[rs*      rrLr)rfr.rcCst|jtr|}|jtkr"|Sttj|}|jj}t j |dd} | dkrTt d| dkrdt d| dksx|dksx|St |} | } || | <|r| rt||jkrtd t j | dd} | dkr2t| jd D]X} | | } t j | dd} | dkrt|| kr|| nd | }t d |d | dqt| ||| j}|j}t|trxt||pt|dptd }t|pd |}|dur||}|dur||kr|}|jd|dd}|S)NFrrz+[date] is not implemented as a table columnrzz>too many timezones in this block, create separate data columnsrrz8NaN representation is too large for existing column sizerzNo.rz2] because its data contents are not [string] but [rraz|SrK)rUrr2rrr rVrrfrrrr5rrPrtrrrYrrJr*rMrhrrrrQ)rfr.rrrr_rrr rrUrrrZerror_column_labelr rZecirZrZr[r"sV         r)rr_rr`cCsbt|r.t|dddj||j|j}t|}t dt |}t j |d|d}|S)a Take a string-like that is object dtype and coerce to a fixed size string type. Parameters ---------- data : np.ndarray[object] encoding : str errors : str Handler for encoding errors. Returns ------- np.ndarray[fixed-length-string] Fr)rrrkSrB)rtr1rOr^encoderRr*rr r libwritersmax_len_string_arrayrVrN)rr_rensuredrrZrZr[rJqs rJcCs|j}tj|td}t|rtt|}d|}t |dt rrt |ddj j ||dd}|}d|j_n|j|ddjtdd}|d urd }t||||S) a* Inverse of _convert_string_array. Parameters ---------- data : np.ndarray[fixed-length-string] nan_rep : the storage repr of NaN encoding : str errors : str Handler for encoding errors. Returns ------- np.ndarray[object] Decoded data. rBUrFrKr)rrTNr)rrVrNrOrrtrNrOr rUrr1r^rXrflagsZ writeablerQZ!string_array_replace_from_nan_repr*)rrr_rrrrZserrZrZr[rSs    rS)rarr_rcCs6t|tsJt|t|r2t|||}||}|Sra)rUr^r _need_convert_get_converter)rarr_rconvrZrZr[rs  rrkr_rcsLdkrddSdvr$fddSdkr:fddStddS)Nr=cSstj|ddS)NrFrBrVrNr*rZrZr[rrz _get_converter..cstj|dS)NrBrWrXr#rZr[rrrcst|ddS)NrM)rSrXrrZr[rsz invalid kind )rrVrZ)r_rrkr[rTs rTr0cCs|dvsd|vrdSdS)N)r=rr=TFrZr#rZrZr[rSsrSz Sequence[int])rfrbr`cCslt|tst|dkrtd|ddkrh|ddkrh|ddkrhtd|}|rh|d}d|}|S) z Prior to 0.10.1, we named values blocks like: values_block_0 an the name values_0, adjust the given name if necessary. Parameters ---------- name : str version : Tuple[int, int, int] Returns ------- str z6Version is incorrect, expected sequence of 3 integers.rrkr`razvalues_block_(\d+)Zvalues_)rUr^rtrr>r=r)rfrbr$grprZrZr[rs$   r) dtype_strr`cCst|}|drd}n|dr(d}n|dr8d}n|drHd}n||drX|}nl|drhd }n\|d rxd }nL|d rd }n<|d rd}n,|d krd }n|dkrd}ntd|d|S)zA Find the "kind" string describing the given dtype name. )rrrrKr)rhr1rIr= timedeltar@rrr3rr^zcannot interpret dtype of [r()r\ryr)r[rkrZrZr[rs2         rr"cCsvt|tr|j}t|jtr.d|jjd}n|jj}|jjdvrTt | d}nt|t rd|j }t |}||fS)zJ Convert the passed data into a storable form and a dtype string. rr(ZmMr) rUr6r'rr'rrfrkrVrNrr/r)rr rZrZr[rs     rc@s>eZdZdZddddddddZd d Zd d Zd dZdS)rz Carries out a selection operation on a tables.Table object. Parameters ---------- table : a Table object where : list of Terms (or convertible to) start, stop: indices to start and/or stop selection Nrrr)r{rrr`cCsV||_||_||_||_d|_d|_d|_d|_t|rt t t j |dd}|dvrt |}|jt jkr|j|j}}|durd}|dur|jj}t ||||_nNt|jjt jr|jdur||jks|jdur||jkrt d||_Wdn1s0Y|jdurR|||_|jdurR|j\|_|_dS)NFr)rIbooleanrz3where must have index locations >= start and < stop)r{rurr conditionrZtermsr6r#rrrrrVrNrZbool_rr' issubclassrrIrPgenerateevaluate)rr{rurrinferredrZrZr[r6sD     &   zSelection.__init__c Cs|dur dS|j}zt|||jjdWSty|}z:d|}td|d|d}t||WYd}~n d}~00dS)z'where can be a : dict,list,tuple,stringN)rr_rz- The passed where expression: a* contains an invalid variable reference all of the variable references must be a reference to an axis (e.g. 'index' or 'columns'), or a data_column The currently defined references are: z ) r{rr:r_ NameErrorrrrr)rrurrJZqkeysrrZrZr[r`cs  zSelection.generatecCsX|jdur(|jjj|j|j|jdS|jdurB|jj|jS|jjj|j|jdS)( generate the selection Nrt) r^r{Z read_whererrrr6rrrrZrZr[rzs  zSelection.selectcCs|j|j}}|jj}|dur$d}n|dkr4||7}|durB|}n|dkrR||7}|jdurx|jjj|j||ddS|jdur|jSt ||S)rdNrT)rrr@) rrr{rr^Zget_where_listrr6rVr')rrrrrZrZr[r s"  zSelection.select_coords)NNN)rrrrrr`rr rZrZrZr[r*s- r) rNNFNTNNNNrrT) NrrNNNNFN)N)F)F)F)r __future__r contextlibrrrzrrr7rr>textwraprtypingrrr r r r r rnumpyrVZpandas._configrrrrZ pandas._libsrrrNZpandas._libs.librZpandas._libs.tslibsrZ pandas.compatrZpandas.compat._optionalrZpandas.compat.pickle_compatrZ pandas.errorsrrrrrZpandas.util._decoratorsrZpandas.util._exceptionsrZpandas.core.dtypes.commonr r!r"r#r$r%Zpandas.core.dtypes.dtypesr&r'r(r)Zpandas.core.dtypes.missingr*rr+r,r-r.r/r0r1r2r3r4r5Zpandas.core.arraysr6r7r8Zpandas.core.arrays.string_r9Zpandas.core.commoncorecommonrGZ pandas.core.computation.pytablesr:r;Zpandas.core.constructionr<rr=Zpandas.core.indexes.apir>Zpandas.core.internalsr?r@Zpandas.io.commonrAZpandas.io.formats.printingrBrCcollections.abcrDrErFtypesrGrrHrIrJZpandas._typingrKrLrMrNrOrPrQrRrSrlrbr\rdrgrlrvrwrrxryrr[r~rZ config_prefixZregister_optionZis_boolZis_one_of_factoryrrrrrrrrrrrrXrZr[ryrrrrrrrrrrrrrrrrrrJrSrrTrSrrrrrZrZrZr[s>   $          4     (          &,: #(p8-2gxdz1C,'@O* #