a
    ï½„gW´ ã                   @  sR  U d Z ddlmZ ddlmZ ddlZddlmZmZ ddl	Z	ddl
Z
ddlZddlmZ ddlmZmZmZmZmZmZmZ ddlZddlZddlmZmZmZmZ dd	lmZm Z! dd
l"m#Z# ddl$m%Z% ddl&m'Z' ddl(m)Z) ddl*m+Z+m,Z,m-Z-m.Z.m/Z/ ddl0m1Z1 ddl2m3Z3 ddl4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z: ddl;m<Z<m=Z=m>Z>m?Z? ddl@mAZA ddlBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZL ddlMmNZNmOZOmPZP ddlQmR  mSZT ddlUmVZVmWZW ddlXmYZY ddlZm[Z[ ddl\m]Z]m^Z^ ddl_m`Z` ddlambZbmcZc e�rvddldmeZemfZfmgZg ddlhmiZi ddljmkZkmlZlmmZm ddlnmoZompZpmqZqmrZrmsZsmtZtmuZumvZv dd l\mwZw d!Zxd"Zyd#d$„ Zzd%d&d'œd(d)„Z{d*d+„ Z|eVZ}d,d-œd.d/„Z~d0Zd1e€d2< d3Z�d1e€d4< d5Z‚d1e€d6< d7d7d8d8d9œZƒeCdgiZ„d:Z…d1e€d;< d<Z†d1e€d=< e ‡d>¡�@ ejˆd?d@e…ej‰dA� ejˆdBde†e Šg dC¢¡dA� W d  ƒ n1 �sV0    Y  da‹d@aŒdDdE„ Z�dÀdId&dJd&dKd%dLd%dLdMdNdOd&d&dPdQœdRdS„ZŽdÁdId&d&dUdKdKdVdLdKdWœ	dXdY„Z�dZdZdLd[œd\d]„Z�G d^d_„ d_ƒZ‘G d`da„ daƒZ’G dbdc„ dcƒZ“G ddde„ dee“ƒZ”G dfdg„ dge“ƒZ•G dhdi„ die•ƒZ–G djdk„ dke–ƒZ—G dldm„ dmƒZ˜G dndo„ doe˜ƒZ™G dpdq„ dqe™ƒZšG drds„ dse™ƒZ›G dtdu„ due›ƒZœG dvdw„ dwe˜ƒZ�G dxdy„ dye�ƒZžG dzd{„ d{e�ƒZŸG d|d}„ d}eŸƒZ G d~d„ de ƒZ¡G d€d�„ d�e¡ƒZ¢G d‚dƒ„ dƒe ƒZ£G d„d…„ d…e ƒZ¤dÂd†d‡dˆd†d‰œdŠd‹„Z¥dŒd�dŽœd�d�„Z¦edÃd‘d�dLd’d“œd”d•„ƒZ§edÄd‘dPdLd–d“œd—d•„ƒZ§dÅd‘d˜dLd™d“œdšd•„Z§d&dˆd&d&dcd›œdœd�„Z¨d&d&d&d‘džœdŸd „Z©d&d¡d¢d£œd¤d¥„Zªd–d&d&d–d¦œd§d¨„Z«d–d&d&d–d¦œd©dª„Z¬d–d&d&d&d«œd¬d­„Z­d&d&d&d®œd¯d°„Z®d&dLd±œd²d³„Z¯d&d´d&dµœd¶d·„Z°d&d&d¸œd¹dº„Z±d¡d»œd¼d½„Z²G d¾d¿„ d¿ƒZ³dS )ÆzY
High level interface to PyTables for reading and writing pandas data structures
to disk
é    )Úannotations)ÚsuppressN)ÚdateÚtzinfo)Údedent)ÚTYPE_CHECKINGÚAnyÚCallableÚFinalÚLiteralÚcastÚoverload)ÚconfigÚ
get_optionÚusing_copy_on_writeÚusing_pyarrow_string_dtype)ÚlibÚwriters)Úis_string_array)Ú	timezones)Úimport_optional_dependency)Úpatch_pickle)ÚAttributeConflictWarningÚClosedFileErrorÚIncompatibilityWarningÚPerformanceWarningÚPossibleDataLossError)Úcache_readonly)Úfind_stack_level)Úensure_objectÚis_bool_dtypeÚis_complex_dtypeÚis_list_likeÚis_string_dtypeÚneeds_i8_conversion)ÚCategoricalDtypeÚDatetimeTZDtypeÚExtensionDtypeÚPeriodDtype)Úarray_equivalent)
Ú	DataFrameÚDatetimeIndexÚIndexÚ
MultiIndexÚPeriodIndexÚ
RangeIndexÚSeriesÚTimedeltaIndexÚconcatÚisna)ÚCategoricalÚDatetimeArrayÚPeriodArray)ÚPyTablesExprÚmaybe_expression)Úextract_array)Úensure_index)ÚArrayManagerÚBlockManager)Ústringify_path)ÚadjoinÚpprint_thing)ÚHashableÚIteratorÚSequence)ÚTracebackType)ÚColÚFileÚNode)ÚAnyArrayLikeÚ	ArrayLikeÚAxisIntÚDtypeArgÚFilePathÚSelfÚShapeÚnpt)ÚBlockz0.15.2úUTF-8c                 C  s   t | tjƒr|  d¡} | S )z(if we have bytes, decode them to unicoderP   )Ú
isinstanceÚnpÚbytes_Údecode)Ús© rV   úU/home/yuhw/wc/wire-cell-python/wcpy/lib/python3.9/site-packages/pandas/io/pytables.pyÚ_ensure_decodedŒ   s    
rX   ú
str | NoneÚstr)ÚencodingÚreturnc                 C  s   | d u rt } | S ©N)Ú_default_encoding©r[   rV   rV   rW   Ú_ensure_encoding“   s    r`   c                 C  s   t | tƒrt| ƒ} | 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
    )rQ   rZ   ©ÚnamerV   rV   rW   Ú_ensure_str›   s    
rc   Úint©Úscope_levelc                   sV   |d ‰ t | ttfƒr*‡ fdd„| D ƒ} nt| ƒr>t| ˆ d�} | du sNt| ƒrR| S dS )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)
    é   c                   s0   g | ](}|d urt |ƒr(t|ˆ d d�n|‘qS )Nrg   re   )r8   ÚTerm)Ú.0Úterm©ÚlevelrV   rW   Ú
<listcomp>µ   s   þz _ensure_term.<locals>.<listcomp>re   N)rQ   ÚlistÚtupler8   rh   Úlen)Úwhererf   rV   rk   rW   Ú_ensure_termª   s    	
þrr   z¨
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_docÚfixedÚtable)Úfrv   Útrw   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_doczio.hdfZdropna_tableF)Ú	validatorÚdefault_format)rv   rw   Nc                  C  sL   t d u rHdd l} | a ttƒ� | jjdkaW d   ƒ n1 s>0    Y  t S )Nr   Ústrict)Ú
_table_modÚtablesr   ÚAttributeErrorÚfileZ_FILE_OPEN_POLICYÚ!_table_file_open_policy_is_strict)r€   rV   rV   rW   Ú_tablesî   s    

ÿ r„   ÚaTr~   zFilePath | HDFStoreúDataFrame | Seriesú
int | NoneÚboolúint | dict[str, int] | Noneúbool | Noneú Literal[True] | list[str] | NoneÚNone)Úpath_or_bufÚkeyÚvalueÚmodeÚ	complevelÚcomplibÚappendÚformatÚindexÚmin_itemsizeÚdropnaÚdata_columnsÚerrorsr[   r\   c              
     sš   |r$‡ ‡‡‡‡‡‡‡‡‡	f
dd„}n‡ ‡‡‡‡‡‡‡‡‡	f
dd„}t | ƒ} t| tƒrŽt| |||d��}||ƒ W d  ƒ q–1 s‚0    Y  n|| ƒ dS )z+store this object, close it if we opened itc                   s   | j ˆˆ	ˆˆˆˆˆˆ ˆˆd�
S )N)r”   r•   r–   Únan_repr—   r˜   r™   r[   )r“   ©Ústore©
r˜   r—   r[   r™   r”   r•   rŽ   r–   rš   r�   rV   rW   Ú<lambda>  s   özto_hdf.<locals>.<lambda>c                   s   | j ˆˆ	ˆˆˆˆˆ ˆˆˆd�
S )N)r”   r•   r–   rš   r˜   r™   r[   r—   ©Úputr›   r�   rV   rW   rž   %  s   ö)r�   r‘   r’   N)r=   rQ   rZ   ÚHDFStore)r�   rŽ   r�   r�   r‘   r’   r“   r”   r•   r–   rš   r—   r˜   r™   r[   rx   rœ   rV   r�   rW   Úto_hdf  s     
ÿ(r¢   Úrzstr | list | Nonezlist[str] | None)	r�   r�   r™   rq   ÚstartÚstopÚcolumnsÚiteratorÚ	chunksizec
                 K  s–  |dvrt d|› d�ƒ‚|dur,t|dd�}t| tƒrN| jsDtdƒ‚| }d}ntt| ƒ} t| tƒshtd	ƒ‚zt	j
 | ¡}W n tt fy’   d}Y n0 |s¨td
| › d�ƒ‚t| f||dœ|
¤Ž}d}zt|du �r| ¡ }t|ƒdkrêt dƒ‚|d }|dd… D ]}t||ƒsþt dƒ‚qþ|j}|j|||||||	|d�W S  t ttf�y�   t| tƒ�sŠttƒ� | ¡  W d  ƒ n1 �s€0    Y  ‚ Y n0 dS )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.

    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
    )r£   úr+r…   zmode zG is not allowed while performing a read. Allowed modes are r, r+ and a.Nrg   re   z&The HDFStore must be open for reading.Fz5Support for generic buffers has not been implemented.zFile z does not exist)r�   r™   Tr   z]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.)rq   r¤   r¥   r¦   r§   r¨   Ú
auto_close)Ú
ValueErrorrr   rQ   r¡   Úis_openÚOSErrorr=   rZ   ÚNotImplementedErrorÚosÚpathÚexistsÚ	TypeErrorÚFileNotFoundErrorÚgroupsrp   Ú_is_metadata_ofÚ_v_pathnameÚselectÚLookupErrorr   r�   Úclose)r�   rŽ   r�   r™   rq   r¤   r¥   r¦   r§   r¨   Úkwargsrœ   rª   r±   r´   Zcandidate_only_groupZgroup_to_checkrV   rV   rW   Úread_hdf<  sj    O
ÿ

ÿ

ÿ
ÿø

(r»   rF   )ÚgroupÚparent_groupr\   c                 C  sF   | j |j krdS | }|j dkrB|j}||kr:|jdkr:dS |j}qdS )zDCheck if a given group is a metadata group for a given parent_group.Frg   ÚmetaT)Z_v_depthZ	_v_parentÚ_v_name)r¼   r½   ÚcurrentÚparentrV   rV   rW   rµ   ×  s    
rµ   c                   @  s6  e Zd ZU dZded< ded< d•dd	d
ddœdd„Zddœdd„Zedd„ ƒZeddœdd„ƒZ	ddœdd„Z
dddœdd„Zdddœdd„Zddœdd „Zdd
dœd!d"„Zd#dœd$d%„Zddœd&d'„Zd(dœd)d*„Zd+d,d-dd.œd/d0„Zd–dd2d3œd4d5„Zd6dœd7d8„Zd9dœd:d;„Zd—ddd<œd=d>„Zddœd?d@„Zed
dœdAdB„ƒZd˜d
ddCœdDdE„ZddœdFdG„Zd™dd
d	d
dHœdIdJ„Zdšdd	d	dKœdLdM„Zd›ddd	d	dNœdOdP„Zdœd
d	d
dQœdRdS„Zd�ddVd
d
d	dWdXdd
d
ddYœdZd[„Zdždddœd\d]„Z dŸddVd^d
d	dWd	d_dXddd`œdadb„Z!d dcd
dddœdedf„Z"d¡dd	dgddhœdidj„Z#dkdœdldm„Z$d¢ddodpœdqdr„Z%ddsdœdtdu„Z&ddvdœdwdx„Z'd£dd
d	d
d
d dzœd{d|„Z(ddœd}d~„Z)ddœdd€„Z*ddd�œd‚dƒ„Z+d¤d…dddvd†œd‡dˆ„Z,d¥ddVd^d
d	dWd	d
dd
dd‰œdŠd‹„Z-dŒd�œdŽd�„Z.dd
dŒd�œd‘d’„Z/ddŒdœd“d”„Z0dS )¦r¡   aS	  
    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Ú_handlerZ   Ú_moder…   NFr‡   rˆ   rŒ   )r�   r‘   Ú
fletcher32r\   c                 K  s²   d|v rt dƒ‚tdƒ}|d ur@||jjvr@t d|jj› d�ƒ‚|d u rX|d urX|jj}t|ƒ| _|d u rnd}|| _d | _|r‚|nd| _	|| _
|| _d | _| jf d|i|¤Ž d S )	Nr”   z-format is not a defined argument for HDFStorer€   zcomplib only supports z compression.r…   r   r�   )r«   r   ÚfiltersZall_complibsZdefault_complibr=   Ú_pathrÃ   rÂ   Ú
_complevelÚ_complibÚ_fletcher32Ú_filtersÚopen)Úselfr°   r�   r‘   r’   rÄ   rº   r€   rV   rV   rW   Ú__init__*  s&    	ÿ
zHDFStore.__init__©r\   c                 C  s   | j S r]   ©rÆ   ©rÌ   rV   rV   rW   Ú
__fspath__K  s    zHDFStore.__fspath__c                 C  s   |   ¡  | jdusJ ‚| jjS )zreturn the root nodeN)Ú_check_if_openrÂ   ÚrootrÐ   rV   rV   rW   rÓ   N  s    zHDFStore.rootc                 C  s   | j S r]   rÏ   rÐ   rV   rV   rW   ÚfilenameU  s    zHDFStore.filename©rŽ   c                 C  s
   |   |¡S r]   )Úget©rÌ   rŽ   rV   rV   rW   Ú__getitem__Y  s    zHDFStore.__getitem__©rŽ   r\   c                 C  s   |   ||¡ d S r]   rŸ   )rÌ   rŽ   r�   rV   rV   rW   Ú__setitem__\  s    zHDFStore.__setitem__c                 C  s
   |   |¡S r]   )Úremover×   rV   rV   rW   Ú__delitem___  s    zHDFStore.__delitem__ra   c              	   C  sD   z|   |¡W S  ttfy"   Y n0 tdt| ƒj› d|› d�ƒ‚dS )z$allow attribute access to get storesú'z' object has no attribute 'N)rÖ   ÚKeyErrorr   r�   ÚtypeÚ__name__)rÌ   rb   rV   rV   rW   Ú__getattr__b  s    ÿzHDFStore.__getattr__c                 C  s4   |   |¡}|dur0|j}|||dd… fv r0dS dS )zx
        check for existence of this key
        can match the exact pathname or the pathnm w/o the leading '/'
        Nrg   TF)Úget_noder¶   )rÌ   rŽ   Únoderb   rV   rV   rW   Ú__contains__l  s    
zHDFStore.__contains__rd   c                 C  s   t |  ¡ ƒS r]   )rp   r´   rÐ   rV   rV   rW   Ú__len__x  s    zHDFStore.__len__c                 C  s   t | jƒ}t| ƒ› d|› d�S )Nú
File path: Ú
)r?   rÆ   rß   )rÌ   ÚpstrrV   rV   rW   Ú__repr__{  s    
zHDFStore.__repr__rL   c                 C  s   | S r]   rV   rÐ   rV   rV   rW   Ú	__enter__  s    zHDFStore.__enter__ztype[BaseException] | NonezBaseException | NonezTracebackType | None)Úexc_typeÚ	exc_valueÚ	tracebackr\   c                 C  s   |   ¡  d S r]   )r¹   )rÌ   rë   rì   rí   rV   rV   rW   Ú__exit__‚  s    zHDFStore.__exit__Úpandasú	list[str])Úincluder\   c                 C  s^   |dkrdd„ |   ¡ D ƒS |dkrJ| jdus0J ‚dd„ | jjddd	�D ƒS td
|› d�ƒ‚dS )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
        rï   c                 S  s   g | ]
}|j ‘qS rV   ©r¶   ©ri   ÚnrV   rV   rW   rm   ©  ó    z!HDFStore.keys.<locals>.<listcomp>ÚnativeNc                 S  s   g | ]
}|j ‘qS rV   rò   ró   rV   rV   rW   rm   ­  s   ú/ÚTable)Ú	classnamez8`include` should be either 'pandas' or 'native' but is 'rÝ   )r´   rÂ   Z
walk_nodesr«   )rÌ   rñ   rV   rV   rW   ÚkeysŠ  s    ÿ
ÿzHDFStore.keyszIterator[str]c                 C  s   t |  ¡ ƒS r]   )Úiterrú   rÐ   rV   rV   rW   Ú__iter__´  s    zHDFStore.__iter__zIterator[tuple[str, list]]c                 c  s   |   ¡ D ]}|j|fV  qdS )z'
        iterate on key->group
        N)r´   r¶   )rÌ   ÚgrV   rV   rW   Úitems·  s    zHDFStore.items)r�   r\   c                 K  s¾   t ƒ }| j|krR| jdv r$|dv r$n(|dv rL| jrLtd| j› d| j› d�ƒ‚|| _| jr`|  ¡  | jrŠ| jdkrŠt ƒ j| j| j| j	d�| _
tr | jr d	}t|ƒ‚|j| j| jfi |¤Ž| _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.
        )r…   Úw)r£   r©   )rÿ   zRe-opening the file [z] with mode [z] will delete the current file!r   )rÄ   zGCannot open HDF5 file, which is already opened, even in read-only mode.N)r„   rÃ   r¬   r   rÆ   r¹   rÇ   ÚFiltersrÈ   rÉ   rÊ   rƒ   r«   Ú	open_filerÂ   )rÌ   r�   rº   r€   ÚmsgrV   rV   rW   rË   ¾  s*    
ÿÿ
ÿzHDFStore.openc                 C  s   | j dur| j  ¡  d| _ dS )z0
        Close the PyTables file handle
        N)rÂ   r¹   rÐ   rV   rV   rW   r¹   ë  s    

zHDFStore.closec                 C  s   | j du rdS t| j jƒS )zF
        return a boolean indicating whether the file is open
        NF)rÂ   rˆ   ZisopenrÐ   rV   rV   rW   r¬   ó  s    
zHDFStore.is_open)Úfsyncr\   c                 C  sT   | j durP| j  ¡  |rPttƒ�  t | j  ¡ ¡ W d  ƒ n1 sF0    Y  dS )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)rÂ   Úflushr   r­   r¯   r  Úfileno)rÌ   r  rV   rV   rW   r  ü  s
    


zHDFStore.flushc                 C  sV   t ƒ �< |  |¡}|du r*td|› d�ƒ‚|  |¡W  d  ƒ S 1 sH0    Y  dS )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
        NúNo object named ú in the file)r   râ   rÞ   Ú_read_group©rÌ   rŽ   r¼   rV   rV   rW   rÖ     s
    
zHDFStore.get)rŽ   r§   r¨   rª   c	                   st   |   |¡}	|	du r"td|› d�ƒ‚t|dd�}|  |	¡‰ˆ ¡  ‡ ‡fdd„}
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  rg   re   c                   s   ˆj | ||ˆ d�S )N)r¤   r¥   rq   r¦   ©Úread©Ú_startÚ_stopÚ_where©r¦   rU   rV   rW   Úfuncy  s    zHDFStore.select.<locals>.func©rq   Únrowsr¤   r¥   r§   r¨   rª   )râ   rÞ   rr   Ú_create_storerÚ
infer_axesÚTableIteratorr  Ú
get_result)rÌ   rŽ   rq   r¤   r¥   r¦   r§   r¨   rª   r¼   r  ÚitrV   r  rW   r·   /  s(    @

özHDFStore.select©rŽ   r¤   r¥   c                 C  s8   t |dd�}|  |¡}t|tƒs(tdƒ‚|j|||d�S )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
        rg   re   z&can only read_coordinates with a table©rq   r¤   r¥   )rr   Ú
get_storerrQ   rø   r²   Úread_coordinates)rÌ   rŽ   rq   r¤   r¥   ÚtblrV   rV   rW   Úselect_as_coordinatesŒ  s
    

zHDFStore.select_as_coordinates)rŽ   Úcolumnr¤   r¥   c                 C  s,   |   |¡}t|tƒstdƒ‚|j|||d�S )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 table©r  r¤   r¥   )r  rQ   rø   r²   Úread_column)rÌ   rŽ   r  r¤   r¥   r  rV   rV   rW   Úselect_column¬  s    #

zHDFStore.select_column)r§   r¨   rª   c
                   sv  t |dd�}t|ttfƒr.t|ƒdkr.|d }t|tƒrRˆj||ˆ|||||	d�S t|ttfƒshtdƒ‚t|ƒsxtdƒ‚|du rˆ|d }‡fdd	„|D ƒ‰ˆ 	|¡}
d}t
 |
|fgtˆ|ƒ¡D ]\\}}|du ràtd
|› d�ƒ‚|jsøtd|j› d�ƒ‚|du �r
|j}qÀ|j|krÀtdƒ‚qÀdd	„ ˆD ƒ}dd„ |D ƒ ¡ ‰ ‡ ‡‡fdd„}tˆ|
||||||||	d�
}|jdd�S )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
        rg   re   r   )rŽ   rq   r¦   r¤   r¥   r§   r¨   rª   zkeys must be a list/tuplez keys must have a non-zero lengthNc                   s   g | ]}ˆ   |¡‘qS rV   )r  ©ri   ÚkrÐ   rV   rW   rm     rõ   z/HDFStore.select_as_multiple.<locals>.<listcomp>zInvalid table [ú]zobject [z>] is not a table, and cannot be used in all select as multiplez,all tables must have exactly the same nrows!c                 S  s   g | ]}t |tƒr|‘qS rV   )rQ   rø   ©ri   ÚxrV   rV   rW   rm   -  rõ   c                 S  s   h | ]}|j d  d  ’qS ©r   )Únon_index_axes©ri   ry   rV   rV   rW   Ú	<setcomp>0  rõ   z.HDFStore.select_as_multiple.<locals>.<setcomp>c                   s*   ‡ ‡‡‡fdd„ˆD ƒ}t |ˆdd� ¡ S )Nc                   s   g | ]}|j ˆˆˆ ˆd �‘qS )©rq   r¦   r¤   r¥   r
  r*  )r  r  r  r¦   rV   rW   rm   5  s   ÿz=HDFStore.select_as_multiple.<locals>.func.<locals>.<listcomp>F)ÚaxisÚverify_integrity)r2   Ú_consolidate)r  r  r  Zobjs)r-  r¦   Útblsr  rW   r  2  s    þz)HDFStore.select_as_multiple.<locals>.funcr  T©Úcoordinates)rr   rQ   rn   ro   rp   rZ   r·   r²   r«   r  Ú	itertoolsÚchainÚziprÞ   Úis_tableÚpathnamer  Úpopr  r  )rÌ   rú   rq   Úselectorr¦   r¤   r¥   r§   r¨   rª   rU   r  ry   r$  Z_tblsr  r  rV   )r-  r¦   rÌ   r0  rW   Úselect_as_multipleÔ  sd    +
ø
 ÿ


özHDFStore.select_as_multipleTr~   r†   r‰   r‹   )rŽ   r�   r•   r“   r‘   r–   r˜   r™   Útrack_timesr—   r\   c                 C  sH   |du rt dƒpd}|  |¡}| j|||||||||	|
||||d� dS )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
            <https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#query-via-data-columns>`__.
        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
        Núio.hdf.default_formatrv   )r”   r•   r“   r’   r‘   r–   rš   r˜   r[   r™   r;  r—   )r   Ú_validate_formatÚ_write_to_group)rÌ   rŽ   r�   r”   r•   r“   r’   r‘   r–   rš   r˜   r[   r™   r;  r—   rV   rV   rW   r    M  s&    8
òzHDFStore.putc              
   C  sâ   t |dd�}z|  |¡}W n† ty.   ‚ Y nt ty@   ‚ Y nb ty  } zJ|dur`tdƒ|‚|  |¡}|durŒ|jdd� W Y d}~dS W Y d}~n
d}~0 0 t 	|||¡rÀ|j
jdd� n|jsÎtdƒ‚|j|||d�S dS )	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

        rg   re   Nz5trying to remove a node with a non-None where clause!T©Ú	recursivez7can only remove with where on objects written as tablesr  )rr   r  rÞ   ÚAssertionErrorÚ	Exceptionr«   râ   Z	_f_removeÚcomÚall_noner¼   r6  Údelete)rÌ   rŽ   rq   r¤   r¥   rU   Úerrrã   rV   rV   rW   rÛ   ™  s2    ÿþ
$ÿzHDFStore.removezbool | list[str]rŠ   )rŽ   r�   r•   r“   r‘   r–   r¨   r—   r˜   r™   r\   c                 C  sl   |	durt dƒ‚|du r tdƒ}|du r4tdƒp2d}|  |¡}| j|||||||||
|||||||d� dS )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
            <https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#query-via-data-columns>`__.
        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_columnszio.hdf.dropna_tabler<  rw   )r”   Úaxesr•   r“   r’   r‘   r–   rš   r¨   Úexpectedrowsr—   r˜   r[   r™   )r²   r   r=  r>  )rÌ   rŽ   r�   r”   rG  r•   r“   r’   r‘   r¦   r–   rš   r¨   rH  r—   r˜   r[   r™   rV   rV   rW   r“   Ò  s6    Iÿ
ðzHDFStore.appendÚdict)Údr—   r\   c                   s¬  |durt dƒ‚t|tƒs"tdƒ‚||vr2tdƒ‚ttttˆjƒƒtt	t
ˆƒ ƒ ƒƒ}d}	g }
| ¡ D ]0\}‰ ˆ du rŽ|	durˆtdƒ‚|}	qh|
 ˆ ¡ qh|	durÖˆj| }| t|
ƒ¡}t| |¡ƒ}| |¡||	< |du ræ|| }|�r*‡fdd„| ¡ D ƒ}t|ƒ}|D ]}| |¡}�qˆj| ‰| dd¡}| ¡ D ]h\}‰ ||k�rT|nd}ˆjˆ |d	�}|du�r†‡ fd
d„| ¡ D ƒnd}| j||f||dœ|¤Ž �q>dS )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 dictz<append_to_multiple can only have one value in d that is Nonec                 3  s    | ]}ˆ | j d d�jV  qdS )Úall)ÚhowN)r—   r•   )ri   Úcols)r�   rV   rW   Ú	<genexpr>ƒ  rõ   z.HDFStore.append_to_multiple.<locals>.<genexpr>r–   ©r-  c                   s   i | ]\}}|ˆ v r||“qS rV   rV   ©ri   rŽ   r�   )ÚvrV   rW   Ú
<dictcomp>“  rõ   z/HDFStore.append_to_multiple.<locals>.<dictcomp>)r˜   r–   )r²   rQ   rI  r«   Únextrû   ÚsetÚrangeÚndimÚ	_AXES_MAPrß   rþ   ÚextendrG  Ú
differencer,   ÚsortedÚget_indexerÚtakeÚvaluesÚintersectionÚlocr8  Úreindexr“   )rÌ   rJ  r�   r9  r˜   rG  r—   rº   r-  Z
remain_keyZremain_valuesr$  ÚorderedZorddZidxsZvalid_indexr•   r–   ÚdcÚvalÚfilteredrV   )rQ  r�   rW   Úappend_to_multiple8  sZ    ÿ
ÿÿ&ÿ

ÿýzHDFStore.append_to_multiplerY   )rŽ   ÚoptlevelÚkindr\   c                 C  sB   t ƒ  |  |¡}|du rdS t|tƒs.tdƒ‚|j|||d� dS )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)r¦   rf  rg  )r„   r  rQ   rø   r²   Úcreate_index)rÌ   rŽ   r¦   rf  rg  rU   rV   rV   rW   Úcreate_table_index™  s    

zHDFStore.create_table_indexrn   c                 C  s<   t ƒ  |  ¡  | jdusJ ‚tdus(J ‚dd„ | j ¡ D ƒS )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)]]
        Nc                 S  sP   g | ]H}t |tjjƒst|jd dƒsHt|ddƒsHt |tjjƒr|jdkr|‘qS )Úpandas_typeNrw   )	rQ   r   ÚlinkÚLinkÚgetattrÚ_v_attrsrw   rø   r¿   )ri   rý   rV   rV   rW   rm   Û  s   ùz#HDFStore.groups.<locals>.<listcomp>)r„   rÒ   rÂ   r   Úwalk_groupsrÐ   rV   rV   rW   r´   Á  s    þzHDFStore.groupsr÷   z*Iterator[tuple[str, list[str], list[str]]])rq   r\   c                 c  s¼   t ƒ  |  ¡  | jdusJ ‚tdus(J ‚| j |¡D ]‚}t|jddƒdurLq4g }g }|j ¡ D ]B}t|jddƒ}|du r”t	|tj
jƒr | |j¡ q^| |j¡ q^|j d¡||fV  q4dS )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
        Nrj  r÷   )r„   rÒ   rÂ   r   ro  rm  rn  Z_v_childrenr]  rQ   r¼   ÚGroupr“   r¿   r¶   Úrstrip)rÌ   rq   rý   r´   ÚleavesÚchildrj  rV   rV   rW   Úwalkè  s     'zHDFStore.walkzNode | Nonec                 C  s~   |   ¡  | d¡sd| }| jdus(J ‚tdus4J ‚z| j | j|¡}W n tjjy`   Y dS 0 t|tj	ƒszJ t
|ƒƒ‚|S )z9return the node with the key or None if it does not existr÷   N)rÒ   Ú
startswithrÂ   r   râ   rÓ   Ú
exceptionsZNoSuchNodeErrorrQ   rF   rß   )rÌ   rŽ   rã   rV   rV   rW   râ   $  s    
zHDFStore.get_nodeúGenericFixed | Tablec                 C  s8   |   |¡}|du r"td|› d�ƒ‚|  |¡}| ¡  |S )z<return the storer object for a key, raise if not in the fileNr  r  )râ   rÞ   r  r  )rÌ   rŽ   r¼   rU   rV   rV   rW   r  4  s    

zHDFStore.get_storerrÿ   )r�   Úpropindexesr‘   rÄ   Ú	overwriter\   c	              	   C  sÎ   t |||||d�}	|du r&t|  ¡ ƒ}t|ttfƒs:|g}|D ]Š}
|  |
¡}|dur>|
|	v rj|rj|	 |
¡ |  |
¡}t|tƒr¶d}|r–dd„ |j	D ƒ}|	j
|
||t|ddƒ|jd� q>|	j|
||jd� q>|	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
        )r�   r’   r‘   rÄ   NFc                 S  s   g | ]}|j r|j‘qS rV   )Ú
is_indexedrb   ©ri   r…   rV   rV   rW   rm   l  rõ   z!HDFStore.copy.<locals>.<listcomp>r˜   )r•   r˜   r[   r_   )r¡   rn   rú   rQ   ro   r  rÛ   r·   rø   rG  r“   rm  r[   r    )rÌ   r‚   r�   rx  rú   r’   r‘   rÄ   ry  Z	new_storer$  rU   Údatar•   rV   rV   rW   Úcopy>  s6    
ÿ




ûzHDFStore.copyc           
      C  s
  t | jƒ}t| ƒ› d|› d�}| jrþt|  ¡ ƒ}t|ƒrôg }g }|D ]œ}z<|  |¡}|dur‚| t |j	pj|ƒ¡ | t |p|dƒ¡ W qD t
y˜   ‚ Y qD tyÞ } z0| |¡ t |ƒ}	| d|	› d�¡ W Y d}~qDd}~0 0 qD|td||ƒ7 }n|d7 }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
        <class 'pandas.io.pytables.HDFStore'>
        File path: store.h5
        /data    frame    (shape->[2,2])
        ræ   rç   Nzinvalid_HDFStore nodez[invalid_HDFStore node: r%  é   ÚEmptyzFile is CLOSED)r?   rÆ   rß   r¬   rZ  rú   rp   r  r“   r7  rA  rB  r>   )
rÌ   r°   ÚoutputZlkeysrú   r]  r$  rU   ÚdetailZdstrrV   rV   rW   Úinfoy  s.    


*
zHDFStore.infoc                 C  s   | j st| j› d�ƒ‚d S )Nz file is not open!)r¬   r   rÆ   rÐ   rV   rV   rW   rÒ   ®  s    zHDFStore._check_if_open)r”   r\   c              
   C  sL   zt | ¡  }W n6 tyF } ztd|› d�ƒ|‚W Y d}~n
d}~0 0 |S )zvalidate / deprecate formatsz#invalid HDFStore format specified [r%  N)Ú_FORMAT_MAPÚlowerrÞ   r²   )rÌ   r”   rF  rV   rV   rW   r=  ²  s
    (zHDFStore._validate_formatrP   zDataFrame | Series | None)r�   r[   r™   r\   c              
   C  s>  |durt |ttfƒstdƒ‚tt|jddƒƒ}tt|jddƒƒ}|du r¶|du r’tƒ  tdusdJ ‚t|ddƒs~t |tj	j
ƒrˆd}d}q¶tdƒ‚n$t |tƒr¢d	}nd
}|dkr¶|d7 }d|v�r.ttdœ}z|| }	W nF t�y }
 z,td|› dt|ƒ› d|› �ƒ|
‚W Y d}
~
n
d}
~
0 0 |	| |||d�S |du �rÈ|du�rÈ|dk�r†t|ddƒ}|du�rÈ|jdk�rtd}n|jdk�rÈd}nB|dk�rÈt|ddƒ}|du�rÈ|jdk�r¸d}n|jdk�rÈd}ttttttdœ}z|| }	W nF t�y, }
 z,td|› dt|ƒ› d|› �ƒ|
‚W Y d}
~
n
d}
~
0 0 |	| |||d�S )z"return a suitable class to operateNz(value must be None, Series, or DataFramerj  Ú
table_typerw   Úframe_tableÚgeneric_tablezKcannot create a storer if the object is not existing nor a value are passedÚseriesÚframeÚ_table)rˆ  r‰  z=cannot properly create the storer for: [_STORER_MAP] [group->ú,value->z	,format->©r[   r™   Úseries_tabler•   rg   Úappendable_seriesÚappendable_multiseriesÚappendable_frameÚappendable_multiframe)r‡  rŽ  r�  r�  r‘  Úwormz<cannot properly create the storer for: [_TABLE_MAP] [group->)rQ   r0   r*   r²   rX   rm  rn  r„   r   rw   rø   ÚSeriesFixedÚ
FrameFixedrÞ   rß   ÚnlevelsÚGenericTableÚAppendableSeriesTableÚAppendableMultiSeriesTableÚAppendableFrameTableÚAppendableMultiFrameTableÚ	WORMTable)rÌ   r¼   r”   r�   r[   r™   ÚptÚttZ_STORER_MAPÚclsrF  r•   Z
_TABLE_MAPrV   rV   rW   r  ¼  s˜    ÿÿ


ÿÿÿÿý





úÿÿÿÿýzHDFStore._create_storer)rŽ   r�   r•   r“   r‘   r–   r¨   r—   r™   r;  r\   c                 C  sÎ   t |dd ƒr|dks|rd S |  ||¡}| j|||||d�}|rr|jrZ|jrb|dkrb|jrbtdƒ‚|jsz| ¡  n| ¡  |jsŒ|rŒtdƒ‚|j||||||	|
||||||d� t|t	ƒrÊ|rÊ|j
|d� d S )	NÚemptyrw   rŒ  rv   zCan only append to Tablesz0Compression not supported on Fixed format stores)ÚobjrG  r“   r’   r‘   rÄ   r–   r¨   rH  r—   rš   r˜   r;  )r¦   )rm  Ú_identify_groupr  r6  Ú	is_existsr«   Úset_object_infoÚwriterQ   rø   rh  )rÌ   rŽ   r�   r”   rG  r•   r“   r’   r‘   rÄ   r–   r¨   rH  r—   rš   r˜   r[   r™   r;  r¼   rU   rV   rV   rW   r>    s:    

ózHDFStore._write_to_grouprF   ©r¼   c                 C  s   |   |¡}| ¡  | ¡ S r]   )r  r  r  )rÌ   r¼   rU   rV   rV   rW   r  U  s    
zHDFStore._read_group)rŽ   r“   r\   c                 C  sN   |   |¡}| jdusJ ‚|dur8|s8| jj|dd� d}|du rJ|  |¡}|S )z@Identify HDF5 group based on key, delete/create group if needed.NTr?  )râ   rÂ   Úremove_nodeÚ_create_nodes_and_group)rÌ   rŽ   r“   r¼   rV   rV   rW   r¡  Z  s    

zHDFStore._identify_groupc                 C  sv   | j dusJ ‚| d¡}d}|D ]P}t|ƒs.q |}| d¡sD|d7 }||7 }|  |¡}|du rl| j  ||¡}|}q |S )z,Create nodes from key and return group name.Nr÷   )rÂ   Úsplitrp   Úendswithrâ   Zcreate_group)rÌ   rŽ   Úpathsr°   ÚpÚnew_pathr¼   rV   rV   rW   r§  l  s    


z HDFStore._create_nodes_and_group)r…   NNF)rï   )r…   )F)NNNNFNF)NNN)NN)NNNNNFNF)NTFNNNNNNr~   TF)NNN)NNTTNNNNNNNNNNr~   )NNF)NNN)r÷   )rÿ   TNNNFT)NNrP   r~   )NTFNNNNNNFNNNr~   T)1rà   Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__rÍ   rÑ   ÚpropertyrÓ   rÔ   rØ   rÚ   rÜ   rá   rä   rå   ré   rê   rî   rú   rü   rþ   rË   r¹   r¬   r  rÖ   r·   r  r"  r:  r    rÛ   r“   re  ri  r´   rt  râ   r  r}  r‚  rÒ   r=  r  r>  r  r¡  r§  rV   rV   rV   rW   r¡   å  s  
A    ú!

*-        ÷`   û$  û+        ö}            ñ$L=               î$k   ùd   û('<       ÷;5    ú`               í$>r¡   c                   @  sp   e Zd ZU dZded< ded< ded< dddd
dd
ddœdd„Zddœdd„Zddœdd„Zdd
dœdd„ZdS )r  aa  
    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.
    r‡   r¨   r¡   rœ   rw  rU   NFrˆ   rŒ   )rœ   rU   r§   r¨   rª   r\   c                 C  sš   || _ || _|| _|| _| jjrN|d u r,d}|d u r8d}|d u rD|}t||ƒ}|| _|| _|| _d | _	|sr|	d urŠ|	d u r~d}	t
|	ƒ| _nd | _|
| _d S )Nr   é † )rœ   rU   r  rq   r6  Úminr  r¤   r¥   r2  rd   r¨   rª   )rÌ   rœ   rU   r  rq   r  r¤   r¥   r§   r¨   rª   rV   rV   rW   rÍ   š  s,    
zTableIterator.__init__rA   rÎ   c                 c  sv   | j }| jd u rtdƒ‚|| jk rjt|| j | jƒ}|  d d | j||… ¡}|}|d u st|ƒsbq|V  q|  ¡  d S )Nz*Cannot iterate until get_result is called.)	r¤   r2  r«   r¥   r³  r¨   r  rp   r¹   )rÌ   rÀ   r¥   r�   rV   rV   rW   rü   Ä  s    

zTableIterator.__iter__c                 C  s   | j r| j ¡  d S r]   )rª   rœ   r¹   rÐ   rV   rV   rW   r¹   Ô  s    zTableIterator.closer1  c                 C  sŠ   | j d ur4t| jtƒstdƒ‚| jj| jd�| _| S |rft| jtƒsLtdƒ‚| jj| j| j| j	d�}n| j}|  
| j| j	|¡}|  ¡  |S )Nz0can only use an iterator or chunksize on a table)rq   z$can only read_coordinates on a tabler  )r¨   rQ   rU   rø   r²   r  rq   r2  r¤   r¥   r  r¹   )rÌ   r2  rq   ÚresultsrV   rV   rW   r  Ø  s    
ÿzTableIterator.get_result)NNFNF)F)	rà   r­  r®  r¯  r°  rÍ   rü   r¹   r  rV   rV   rV   rW   r  ‚  s   
	     õ*r  c                   @  s¦  e Zd ZU dZdZded< dZded< g d¢ZdKdd	d
dœdd„Ze	ddœdd„ƒZ
e	ddœdd„ƒZdd
dœdd„Zddœdd„Zdddœdd„Zddœdd„Ze	ddœdd „ƒZd!ddd"d#œd$d%„Zd&d'„ Ze	d(d)„ ƒZe	d*d+„ ƒZe	d,d-„ ƒZe	d.d/„ ƒZd0dœd1d2„ZdLd
dœd3d4„Zd
dœd5d6„Zd7dd
d8œd9d:„ZdMd;d<„Zdd
d=œd>d?„Zd
dœd@dA„Zd
dœdBdC„Zd
dœdDdE„Zd7d
dFœdGdH„Z d7d
dFœdIdJ„Z!dS )NÚIndexCola  
    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

    Trˆ   Úis_an_indexableÚis_data_indexable)ÚfreqÚtzÚ
index_nameNrZ   rY   rŒ   )rb   Úcnamer\   c                 C  s    t |tƒstdƒ‚|| _|| _|| _|| _|p0|| _|| _|| _	|| _
|	| _|
| _|| _|| _|| _|| _|d ur||  |¡ t | jtƒsŒJ ‚t | jtƒsœJ ‚d S )Nz`name` must be a str.)rQ   rZ   r«   r]  rg  Útyprb   r»  r-  Úposr¸  r¹  rº  ra  rw   r¾   ÚmetadataÚset_pos)rÌ   rb   r]  rg  r¼  r»  r-  r½  r¸  r¹  rº  ra  rw   r¾   r¾  rV   rV   rW   rÍ     s(    


zIndexCol.__init__rd   rÎ   c                 C  s   | j jS r]   )r¼  ÚitemsizerÐ   rV   rV   rW   rÀ  /  s    zIndexCol.itemsizec                 C  s   | j › d�S )NÚ_kindra   rÐ   rV   rV   rW   Ú	kind_attr4  s    zIndexCol.kind_attr)r½  r\   c                 C  s$   || _ |dur | jdur || j_dS )z,set the position of this column in the TableN)r½  r¼  Z_v_pos)rÌ   r½  rV   rV   rW   r¿  8  s    zIndexCol.set_posc                 C  s@   t tt| j| j| j| j| jfƒƒ}d dd„ t	g d¢|ƒD ƒ¡S )Nú,c                 S  s   g | ]\}}|› d |› �‘qS ©z->rV   rP  rV   rV   rW   rm   C  s   ÿz%IndexCol.__repr__.<locals>.<listcomp>)rb   r»  r-  r½  rg  )
ro   Úmapr?   rb   r»  r-  r½  rg  Újoinr5  ©rÌ   ÚtemprV   rV   rW   ré   >  s    ÿþÿzIndexCol.__repr__Úobject©Úotherr\   c                   s   t ‡ ‡fdd„dD ƒƒS )úcompare 2 col itemsc                 3  s&   | ]}t ˆ|d ƒt ˆ |d ƒkV  qd S r]   ©rm  r{  ©rË  rÌ   rV   rW   rN  K  s   ÿz"IndexCol.__eq__.<locals>.<genexpr>)rb   r»  r-  r½  ©rK  ©rÌ   rË  rV   rÎ  rW   Ú__eq__I  s    þzIndexCol.__eq__c                 C  s   |   |¡ S r]   )rÑ  rÐ  rV   rV   rW   Ú__ne__P  s    zIndexCol.__ne__c                 C  s"   t | jdƒsdS t| jj| jƒjS )z%return whether I am an indexed columnrM  F)Úhasattrrw   rm  rM  r»  rz  rÐ   rV   rV   rW   rz  S  s    zIndexCol.is_indexedú
np.ndarrayz3tuple[np.ndarray, np.ndarray] | tuple[Index, Index]©r]  r[   r™   r\   c           
      C  s  t |tjƒsJ t|ƒƒ‚|jjdur2|| j  ¡ }t| j	ƒ}t
||||ƒ}i }t| jƒ|d< | jdurtt| jƒ|d< t}t |jd¡s’t |jtƒr˜t}n|jdkr²d|v r²dd„ }z||fi |¤Ž}W n2 tyø   d|v räd|d< ||fi |¤Ž}Y n0 t|| jƒ}	|	|	fS )zV
        Convert the data from this selection to the appropriate pandas type.
        Nrb   r¸  ÚMÚi8c                 [  s    t j| | dd ¡d� |d ¡S )Nr¸  )r¸  rb   )r.   Zfrom_ordinalsrÖ   Z_rename)r'  ÚkwdsrV   rV   rW   rž   {  s   ÿýz"IndexCol.convert.<locals>.<lambda>)rQ   rR   Úndarrayrß   ÚdtypeÚfieldsr»  r}  rX   rg  Ú_maybe_convertrº  r¸  r,   r   Úis_np_dtyper&   r+   r«   Ú_set_tzr¹  )
rÌ   r]  rš   r[   r™   Úval_kindrº   ÚfactoryZnew_pd_indexZfinal_pd_indexrV   rV   rW   Úconvert[  s0    

ÿzIndexCol.convertc                 C  s   | j S )zreturn the values©r]  rÐ   rV   rV   rW   Ú	take_data�  s    zIndexCol.take_datac                 C  s   | j jS r]   )rw   rn  rÐ   rV   rV   rW   Úattrs‘  s    zIndexCol.attrsc                 C  s   | j jS r]   ©rw   ÚdescriptionrÐ   rV   rV   rW   ræ  •  s    zIndexCol.descriptionc                 C  s   t | j| jdƒS )z!return my current col descriptionN)rm  ræ  r»  rÐ   rV   rV   rW   Úcol™  s    zIndexCol.colc                 C  s   | j S ©zreturn my cython valuesrâ  rÐ   rV   rV   rW   Úcvaluesž  s    zIndexCol.cvaluesrA   c                 C  s
   t | jƒS r]   )rû   r]  rÐ   rV   rV   rW   rü   £  s    zIndexCol.__iter__c                 C  sP   t | jƒdkrLt|tƒr$| | j¡}|durL| jj|k rLtƒ j	|| j
d�| _dS )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)rÀ  r½  )rX   rg  rQ   rI  rÖ   rb   r¼  rÀ  r„   Ú	StringColr½  )rÌ   r–   rV   rV   rW   Úmaybe_set_size¦  s
    
zIndexCol.maybe_set_sizec                 C  s   d S r]   rV   rÐ   rV   rV   rW   Úvalidate_names³  s    zIndexCol.validate_namesÚAppendableTable)Úhandlerr“   r\   c                 C  s:   |j | _ |  ¡  |  |¡ |  |¡ |  |¡ |  ¡  d S r]   )rw   Úvalidate_colÚvalidate_attrÚvalidate_metadataÚwrite_metadataÚset_attr)rÌ   rï  r“   rV   rV   rW   Úvalidate_and_set¶  s    


zIndexCol.validate_and_setc                 C  s^   t | jƒdkrZ| j}|durZ|du r*| j}|j|k rTtd|› d| j› d|j› d�ƒ‚|jS dS )z:validate this column: return the compared against itemsizerê  Nz#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)rX   rg  rç  rÀ  r«   r»  )rÌ   rÀ  ÚcrV   rV   rW   rð  ¾  s    
ÿþÿzIndexCol.validate_col)r“   r\   c                 C  sB   |r>t | j| jd ƒ}|d ur>|| jkr>td|› d| j› d�ƒ‚d S )Nzincompatible kind in col [ú - r%  )rm  rä  rÂ  rg  r²   )rÌ   r“   Zexisting_kindrV   rV   rW   rñ  Ñ  s    ÿzIndexCol.validate_attrc                 C  sÈ   | j D ]¼}t| |dƒ}| | ji ¡}| |¡}||v rª|durª||krª|dv r„t|||f }tj|tt	ƒ d� d||< t
| |dƒ qÂtd| j› d|› d|› d|› d�	ƒ‚q|dusº|dur|||< qdS )	z
        set/update the info for this indexable with the key/value
        if there is a conflict raise/warn as needed
        N)r¸  rº  ©Ú
stacklevelzinvalid info for [z] for [z], existing_value [z] conflicts with new value [r%  )Ú_info_fieldsrm  Ú
setdefaultrb   rÖ   rt   ÚwarningsÚwarnr   r   Úsetattrr«   )rÌ   r‚  rŽ   r�   ÚidxZexisting_valueÚwsrV   rV   rW   Úupdate_infoÚ  s*    

ÿÿþÿzIndexCol.update_infoc                 C  s$   |  | j¡}|dur | j |¡ dS )z!set my state from the passed infoN)rÖ   rb   Ú__dict__Úupdate)rÌ   r‚  rÿ  rV   rV   rW   Úset_infoù  s    zIndexCol.set_infoc                 C  s   t | j| j| jƒ dS )zset the kind for this columnN)rþ  rä  rÂ  rg  rÐ   rV   rV   rW   rô  ÿ  s    zIndexCol.set_attr)rï  r\   c                 C  sH   | j dkrD| j}| | j¡}|durD|durDt||ddd�sDtdƒ‚dS )z:validate that kind=category does not change the categoriesÚcategoryNT©Z
strict_nanZdtype_equalzEcannot append a categorical with different categories to the existing)r¾   r¾  Úread_metadatar»  r)   r«   )rÌ   rï  Znew_metadataZcur_metadatarV   rV   rW   rò  	  s    
ÿþÿýÿzIndexCol.validate_metadatac                 C  s   | j dur| | j| j ¡ dS )zset the meta dataN)r¾  ró  r»  )rÌ   rï  rV   rV   rW   ró  	  s    
zIndexCol.write_metadata)NNNNNNNNNNNNN)N)N)"rà   r­  r®  r¯  r¶  r°  r·  rú  rÍ   r±  rÀ  rÂ  r¿  ré   rÑ  rÒ  rz  rá  rã  rä  ræ  rç  ré  rü   rì  rí  rõ  rð  rñ  r  r  rô  rò  ró  rV   rV   rV   rW   rµ  ò  sb   
             ñ+2




	rµ  c                   @  sD   e Zd ZdZeddœdd„ƒZddddd	œd
d„Zddœdd„ZdS )ÚGenericIndexColz:an index which is not represented in the data of the tablerˆ   rÎ   c                 C  s   dS ©NFrV   rÐ   rV   rV   rW   rz  	  s    zGenericIndexCol.is_indexedrÔ  rZ   ztuple[Index, Index]rÕ  c                 C  s,   t |tjƒsJ t|ƒƒ‚tt|ƒƒ}||fS )zÛ
        Convert the data from this selection to the appropriate pandas type.

        Parameters
        ----------
        values : np.ndarray
        nan_rep : str
        encoding : str
        errors : str
        )rQ   rR   rÙ  rß   r/   rp   )rÌ   r]  rš   r[   r™   r•   rV   rV   rW   rá  !	  s    zGenericIndexCol.convertrŒ   c                 C  s   d S r]   rV   rÐ   rV   rV   rW   rô  3	  s    zGenericIndexCol.set_attrN)rà   r­  r®  r¯  r±  rz  rá  rô  rV   rV   rV   rW   r  	  s
   r  c                      s>  e Zd ZdZdZdZddgZd;dddd	d
œ‡ fdd„Zeddœdd„ƒZ	eddœdd„ƒZ
ddœdd„Zdddœdd„Zdd	dœdd„Zdd„ Zeddd œd!d"„ƒZed#d$„ ƒZedd%d&œd'd(„ƒZeddd&œd)d*„ƒZed+d,„ ƒZed-d.„ ƒZed/d0„ ƒZed1d2„ ƒZd	dœd3d4„Zd5ddd6œd7d8„Zd	dœd9d:„Z‡  ZS )<Ú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
    Fr¹  ra  NrZ   rY   zDtypeArg | NonerŒ   )rb   r»  rÚ  r\   c                   s2   t ƒ j|||||||||	|
|d� || _|| _d S )N)rb   r]  rg  r¼  r½  r»  r¹  ra  rw   r¾   r¾  )ÚsuperrÍ   rÚ  r|  )rÌ   rb   r]  rg  r¼  r»  r½  r¹  ra  rw   r¾   r¾  rÚ  r|  ©Ú	__class__rV   rW   rÍ   H	  s    õzDataCol.__init__rÎ   c                 C  s   | j › d�S )NÚ_dtypera   rÐ   rV   rV   rW   Ú
dtype_attrh	  s    zDataCol.dtype_attrc                 C  s   | j › d�S )NÚ_metara   rÐ   rV   rV   rW   Ú	meta_attrl	  s    zDataCol.meta_attrc                 C  s@   t tt| j| j| j| j| jfƒƒ}d dd„ t	g d¢|ƒD ƒ¡S )NrÃ  c                 S  s   g | ]\}}|› d |› �‘qS rÄ  rV   rP  rV   rV   rW   rm   w	  s   ÿz$DataCol.__repr__.<locals>.<listcomp>)rb   r»  rÚ  rg  Úshape)
ro   rÅ  r?   rb   r»  rÚ  rg  r  rÆ  r5  rÇ  rV   rV   rW   ré   p	  s    ÿÿþÿzDataCol.__repr__rÉ  rˆ   rÊ  c                   s   t ‡ ‡fdd„dD ƒƒS )rÌ  c                 3  s&   | ]}t ˆ|d ƒt ˆ |d ƒkV  qd S r]   rÍ  r{  rÎ  rV   rW   rN  	  s   ÿz!DataCol.__eq__.<locals>.<genexpr>)rb   r»  rÚ  r½  rÏ  rÐ  rV   rÎ  rW   rÑ  }	  s    þzDataCol.__eq__rH   )r|  r\   c                 C  s@   |d usJ ‚| j d u sJ ‚t|ƒ\}}|| _|| _ t|ƒ| _d S r]   )rÚ  Ú_get_data_and_dtype_namer|  Ú_dtype_to_kindrg  )rÌ   r|  Ú
dtype_namerV   rV   rW   Úset_data„	  s    zDataCol.set_datac                 C  s   | j S )zreturn the data©r|  rÐ   rV   rV   rW   rã  Ž	  s    zDataCol.take_datarD   )r]  r\   c                 C  sÌ   |j }|j}|j}|jdkr&d|jf}t|tƒrJ|j}| j||j j	d�}n~t
 |d¡s`t|tƒrl|  |¡}n\t
 |d¡r„|  |¡}nDt|ƒr¢tƒ j||d d�}n&t|ƒr¸|  ||¡}n| j||j	d�}|S )zW
        Get an appropriately typed and shaped pytables.Col object for values.
        rg   ©rg  rÖ  Úmr   ©rÀ  r  )rÚ  rÀ  r  rV  ÚsizerQ   r4   ÚcodesÚget_atom_datarb   r   rÝ  r&   Úget_atom_datetime64Úget_atom_timedelta64r!   r„   Z
ComplexColr#   Úget_atom_string)rž  r]  rÚ  rÀ  r  r  ÚatomrV   rV   rW   Ú	_get_atom’	  s$    


zDataCol._get_atomc                 C  s   t ƒ j||d d�S )Nr   r  ©r„   rë  ©rž  r  rÀ  rV   rV   rW   r   ²	  s    zDataCol.get_atom_stringz	type[Col]©rg  r\   c                 C  sR   |  d¡r$|dd… }d|› d�}n"|  d¡r4d}n| ¡ }|› d�}ttƒ |ƒS )z0return the PyTables column class for this columnÚuinté   NZUIntrD   ÚperiodÚInt64Col)ru  Ú
capitalizerm  r„   )rž  rg  Zk4Zcol_nameZkcaprV   rV   rW   Úget_atom_coltype¶	  s    


zDataCol.get_atom_coltypec                 C  s   | j |d�|d d�S )Nr  r   ©r  ©r+  ©rž  r  rg  rV   rV   rW   r  Å	  s    zDataCol.get_atom_datac                 C  s   t ƒ j|d d�S ©Nr   r,  ©r„   r)  ©rž  r  rV   rV   rW   r  É	  s    zDataCol.get_atom_datetime64c                 C  s   t ƒ j|d d�S r/  r0  r1  rV   rV   rW   r  Í	  s    zDataCol.get_atom_timedelta64c                 C  s   t | jdd ƒS )Nr  )rm  r|  rÐ   rV   rV   rW   r  Ñ	  s    zDataCol.shapec                 C  s   | j S rè  r  rÐ   rV   rV   rW   ré  Õ	  s    zDataCol.cvaluesc                 C  s`   |r\t | j| jdƒ}|dur2|t| jƒkr2tdƒ‚t | j| jdƒ}|dur\|| jkr\tdƒ‚dS )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!)rm  rä  rÂ  rn   r]  r«   r  rÚ  )rÌ   r“   Zexisting_fieldsZexisting_dtyperV   rV   rW   rñ  Ú	  s    ÿzDataCol.validate_attrrÔ  )r]  r[   r™   c                 C  s  t |tjƒsJ t|ƒƒ‚|jjdur.|| j }| jdus<J ‚| jdu r\t|ƒ\}}t	|ƒ}n|}| j}| j
}t |tjƒs|J ‚t| jƒ}| j}	| j}
| j}|dus¤J ‚t|ƒ}| d¡rÈt||dd�}�n&|dkrâtj|dd�}�n|dk�r8ztjd	d
„ |D ƒtd�}W n, t�y4   tjdd
„ |D ƒtd�}Y n0 n¶|dk�r¸|	}| ¡ }|du �rhtg tjd�}n<t|ƒ}| ¡ �r¤||  }||dk  | t¡ ¡ j8  < tj|||
dd�}n6z|j|dd�}W n" t �yì   |jddd�}Y n0 t|ƒdk�rt!||||d�}| j"|fS )aR  
        Convert the data from this selection to the appropriate pandas type.

        Parameters
        ----------
        values : np.ndarray
        nan_rep :
        encoding : str
        errors : str

        Returns
        -------
        index : listlike to become an Index
        data : ndarraylike to become a column
        NÚ
datetime64T©ÚcoerceÚtimedelta64úm8[ns]©rÚ  r   c                 S  s   g | ]}t  |¡‘qS rV   ©r   Úfromordinal©ri   rQ  rV   rV   rW   rm   
  rõ   z#DataCol.convert.<locals>.<listcomp>c                 S  s   g | ]}t  |¡‘qS rV   ©r   Úfromtimestampr:  rV   rV   rW   rm   "
  rõ   r  éÿÿÿÿF)Ú
categoriesra  Úvalidate©r}  ÚOrê  ©rš   r[   r™   )#rQ   rR   rÙ  rß   rÚ  rÛ  r»  r¼  r  r  rg  rX   r¾   r¾  ra  r¹  ru  rÞ  ÚasarrayrÉ  r«   Úravelr,   Zfloat64r3   ÚanyÚastyperd   ZcumsumÚ_valuesr4   Z
from_codesr²   Ú_unconvert_string_arrayr]  )rÌ   r]  rš   r[   r™   Ú	convertedr  rg  r¾   r¾  ra  r¹  rÚ  r>  r  ÚmaskrV   rV   rW   rá  ç	  sf    





ÿ
ÿ



 ÿÿzDataCol.convertc                 C  sH   t | j| j| jƒ t | j| j| jƒ | jdus2J ‚t | j| j| jƒ dS )zset the data for this columnN)rþ  rä  rÂ  r]  r  r¾   rÚ  r  rÐ   rV   rV   rW   rô  K
  s    zDataCol.set_attr)NNNNNNNNNNNN)rà   r­  r®  r¯  r¶  r·  rú  rÍ   r±  r  r  ré   rÑ  r  rã  Úclassmethodr"  r   r+  r  r  r  r  ré  rñ  rá  rô  Ú__classcell__rV   rV   r  rW   r
  7	  sX               ò 





dr
  c                   @  sZ   e Zd ZdZdZddœdd„Zedd„ ƒZed	d
dœdd„ƒZedd„ ƒZ	edd„ ƒZ
dS )ÚDataIndexableColz+represent a data column that can be indexedTrŒ   rÎ   c                 C  s   t t| jƒjƒstdƒ‚d S )Nú-cannot have non-object label DataIndexableCol)r#   r,   r]  rÚ  r«   rÐ   rV   rV   rW   rí  X
  s    zDataIndexableCol.validate_namesc                 C  s   t ƒ j|d�S )N)rÀ  r#  r$  rV   rV   rW   r   ]
  s    z DataIndexableCol.get_atom_stringrZ   rD   r%  c                 C  s   | j |d�ƒ S )Nr  r-  r.  rV   rV   rW   r  a
  s    zDataIndexableCol.get_atom_datac                 C  s
   t ƒ  ¡ S r]   r0  r1  rV   rV   rW   r  e
  s    z$DataIndexableCol.get_atom_datetime64c                 C  s
   t ƒ  ¡ S r]   r0  r1  rV   rV   rW   r  i
  s    z%DataIndexableCol.get_atom_timedelta64N)rà   r­  r®  r¯  r·  rí  rK  r   r  r  r  rV   rV   rV   rW   rM  S
  s   

rM  c                   @  s   e Zd ZdZdS )ÚGenericDataIndexableColz(represent a generic pytables data columnN)rà   r­  r®  r¯  rV   rV   rV   rW   rO  n
  s   rO  c                   @  sÂ  e Zd ZU dZded< dZded< ded< ded	< d
ed< dZded< dNd
dddddœdd„Zeddœdd„ƒZ	eddœdd„ƒZ
edd„ ƒZddœdd „Zddœd!d"„Zd dœd#d$„Zed%d&„ ƒZed'd(„ ƒZed)d*„ ƒZed+d,„ ƒZeddœd-d.„ƒZeddœd/d0„ƒZed1d2„ ƒZddœd3d4„Zddœd5d6„Zed7d8„ ƒZeddœd9d:„ƒZed;d<„ ƒZd=dœd>d?„ZdOddœdAdB„ZddœdCdD„ZdPdEdEdFœdGdH„ZddœdIdJ„ZdQdEdEddKœdLdM„Z d@S )RÚFixedzø
    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.
    rZ   Úpandas_kindrv   Úformat_typeútype[DataFrame | Series]Úobj_typerd   rV  r¡   rÁ   Frˆ   r6  rP   r~   rF   rY   rŒ   )rÁ   r¼   r[   r™   r\   c                 C  sZ   t |tƒsJ t|ƒƒ‚td us"J ‚t |tjƒs:J t|ƒƒ‚|| _|| _t|ƒ| _|| _	d S r]   )
rQ   r¡   rß   r   rF   rÁ   r¼   r`   r[   r™   )rÌ   rÁ   r¼   r[   r™   rV   rV   rW   rÍ   †
  s    
zFixed.__init__rÎ   c                 C  s*   | j d dko(| j d dko(| j d dk S )Nr   rg   é
   é   )ÚversionrÐ   rV   rV   rW   Úis_old_version•
  s    zFixed.is_old_versionztuple[int, int, int]c                 C  s`   t t| jjddƒƒ}z0tdd„ | d¡D ƒƒ}t|ƒdkrB|d }W n tyZ   d}Y n0 |S )	zcompute and set our versionÚpandas_versionNc                 s  s   | ]}t |ƒV  qd S r]   ©rd   r&  rV   rV   rW   rN  ž
  rõ   z Fixed.version.<locals>.<genexpr>Ú.rV  r(  )r   r   r   )rX   rm  r¼   rn  ro   r¨  rp   r�   )rÌ   rW  rV   rV   rW   rW  ™
  s    
zFixed.versionc                 C  s   t t| jjdd ƒƒS )Nrj  )rX   rm  r¼   rn  rÐ   rV   rV   rW   rj  ¥
  s    zFixed.pandas_typec                 C  s^   |   ¡  | j}|durXt|ttfƒrDd dd„ |D ƒ¡}d|› d�}| jd›d|› d	�S | jS )
ú(return a pretty representation of myselfNrÃ  c                 S  s   g | ]}t |ƒ‘qS rV   ©r?   r&  rV   rV   rW   rm   ¯
  rõ   z"Fixed.__repr__.<locals>.<listcomp>ú[r%  ú12.12z	 (shape->ú))r  r  rQ   rn   ro   rÆ  rj  )rÌ   rU   ZjshaperV   rV   rW   ré   ©
  s    zFixed.__repr__c                 C  s   t | jƒ| j_t tƒ| j_dS )zset my pandas type & versionN)rZ   rQ  rä  rj  Ú_versionrY  rÐ   rV   rV   rW   r£  ´
  s    zFixed.set_object_infoc                 C  s   t   | ¡}|S r]   r@  )rÌ   Znew_selfrV   rV   rW   r}  ¹
  s    
z
Fixed.copyc                 C  s   | j S r]   )r  rÐ   rV   rV   rW   r  ½
  s    zFixed.shapec                 C  s   | j jS r]   ©r¼   r¶   rÐ   rV   rV   rW   r7  Á
  s    zFixed.pathnamec                 C  s   | j jS r]   )rÁ   rÂ   rÐ   rV   rV   rW   rÂ   Å
  s    zFixed._handlec                 C  s   | j jS r]   )rÁ   rÊ   rÐ   rV   rV   rW   rÊ   É
  s    zFixed._filtersc                 C  s   | j jS r]   )rÁ   rÇ   rÐ   rV   rV   rW   rÇ   Í
  s    zFixed._complevelc                 C  s   | j jS r]   )rÁ   rÉ   rÐ   rV   rV   rW   rÉ   Ñ
  s    zFixed._fletcher32c                 C  s   | j jS r]   )r¼   rn  rÐ   rV   rV   rW   rä  Õ
  s    zFixed.attrsc                 C  s   dS ©zset our object attributesNrV   rÐ   rV   rV   rW   Ú	set_attrsÙ
  s    zFixed.set_attrsc                 C  s   dS )zget our object attributesNrV   rÐ   rV   rV   rW   Ú	get_attrsÜ
  s    zFixed.get_attrsc                 C  s   | j S )zreturn my storabler¥  rÐ   rV   rV   rW   Ústorableß
  s    zFixed.storablec                 C  s   dS r	  rV   rÐ   rV   rV   rW   r¢  ä
  s    zFixed.is_existsc                 C  s   t | jdd ƒS )Nr  )rm  rf  rÐ   rV   rV   rW   r  è
  s    zFixed.nrowszLiteral[True] | Nonec                 C  s   |du rdS dS )z%validate against an existing storableNTrV   rÐ  rV   rV   rW   r?  ì
  s    zFixed.validateNc                 C  s   dS )ú+are we trying to operate on an old version?NrV   )rÌ   rq   rV   rV   rW   Úvalidate_versionò
  s    zFixed.validate_versionc                 C  s   | j }|du rdS |  ¡  dS )zr
        infer the axes of my storer
        return a boolean indicating if we have a valid storer or not
        NFT)rf  re  )rÌ   rU   rV   rV   rW   r  õ
  s
    zFixed.infer_axesr‡   ©r¤   r¥   c                 C  s   t dƒ‚d S )Nz>cannot read on an abstract storer: subclasses should implement©r®   ©rÌ   rq   r¦   r¤   r¥   rV   rV   rW   r     s    ÿz
Fixed.readc                 K  s   t dƒ‚d S )Nz?cannot write on an abstract storer: subclasses should implementrj  ©rÌ   r   rº   rV   rV   rW   r¤    s    ÿzFixed.write©r¤   r¥   r\   c                 C  s0   t  |||¡r$| jj| jdd� dS tdƒ‚dS )zs
        support fully deleting the node in its entirety (only) - where
        specification must be None
        Tr?  Nz#cannot delete on an abstract storer)rC  rD  rÂ   r¦  r¼   r²   )rÌ   rq   r¤   r¥   rV   rV   rW   rE    s    zFixed.delete)rP   r~   )N)NNNN)NNN)!rà   r­  r®  r¯  r°  rR  r6  rÍ   r±  rX  rW  rj  ré   r£  r}  r  r7  rÂ   rÊ   rÇ   rÉ   rä  rd  re  rf  r¢  r  r?  rh  r  r  r¤  rE  rV   rV   rV   rW   rP  r
  sh   
  û







    û ÿrP  c                   @  sF  e Zd ZU dZedediZdd„ e ¡ D ƒZg Z	de
d< dd	œd
d„Zdd„ Zdd„ Zdd	œdd„Zedd	œdd„ƒZdd	œdd„Zdd	œdd„Zdd	œdd„Zd:ddddœdd „Zd;dddd!d"œd#d$„Zdd!dd%œd&d'„Zdd(dd%œd)d*„Zd<dddd(d"œd+d,„Zd=d-ddd!d.œd/d0„Zdd1dd2œd3d4„Zd>dd5d6dd7œd8d9„ZdS )?ÚGenericFixedza generified fixed versionÚdatetimer(  c                 C  s   i | ]\}}||“qS rV   rV   )ri   r$  rQ  rV   rV   rW   rR  "  rõ   zGenericFixed.<dictcomp>rð   Ú
attributesrZ   rÎ   c                 C  s   | j  |d¡S )NÚ )Ú_index_type_maprÖ   )rÌ   rž  rV   rV   rW   Ú_class_to_alias&  s    zGenericFixed._class_to_aliasc                 C  s   t |tƒr|S | j |t¡S r]   )rQ   rß   Ú_reverse_index_maprÖ   r,   )rÌ   ÚaliasrV   rV   rW   Ú_alias_to_class)  s    
zGenericFixed._alias_to_classc                 C  s¸   |   tt|ddƒƒ¡}|tkr.d	dd„}|}n|tkrFd
dd„}|}n|}i }d|v rn|d |d< |tu rnt}d|v r°t|d tƒr˜|d  	d¡|d< n|d |d< |tu s°J ‚||fS )NÚindex_classrq  c                 S  s>   t j| j| j|d�}tj|d d�}|d ur:| d¡ |¡}|S )N)rÚ  r¸  ra   ÚUTC)r5   Ú_simple_newr]  rÚ  r+   Útz_localizeÚ
tz_convert)r]  r¸  r¹  ZdtaÚresultrV   rV   rW   rx   8  s    
ÿz*GenericFixed._get_index_factory.<locals>.fc                 S  s$   t |ƒ}tj| |d�}tj|d d�S )Nr7  ra   )r(   r6   ry  r.   )r]  r¸  r¹  rÚ  ZparrrV   rV   rW   rx   E  s    r¸  r¹  zutf-8)NN)NN)
rv  rX   rm  r+   r.   r,   r1   rQ   ÚbytesrT   )rÌ   rä  rw  rx   rà  rº   rV   rV   rW   Ú_get_index_factory/  s*    ÿ


zGenericFixed._get_index_factoryrŒ   c                 C  s$   |durt dƒ‚|dur t dƒ‚dS )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²   )rÌ   r¦   rq   rV   rV   rW   Úvalidate_read`  s    ÿÿzGenericFixed.validate_readrˆ   c                 C  s   dS )NTrV   rÐ   rV   rV   rW   r¢  o  s    zGenericFixed.is_existsc                 C  s   | j | j_ | j| j_dS rc  )r[   rä  r™   rÐ   rV   rV   rW   rd  s  s    
zGenericFixed.set_attrsc              	   C  sR   t t| jddƒƒ| _tt| jddƒƒ| _| jD ]}t| |tt| j|dƒƒƒ q.dS )úretrieve our attributesr[   Nr™   r~   )r`   rm  rä  r[   rX   r™   rp  rþ  )rÌ   rô   rV   rV   rW   re  x  s    
zGenericFixed.get_attrsc                 K  s   |   ¡  d S r]   )rd  rl  rV   rV   rW   r¤    s    zGenericFixed.writeNr‡   r  c                 C  sÖ   ddl }t| j|ƒ}|j}t|ddƒ}t||jƒrD|d ||… }n€tt|ddƒƒ}	t|ddƒ}
|
durxtj|
|	d�}n|||… }|	r®|	 	d¡r®t|d	dƒ}t
||d
d�}n|	dkrÄtj|dd�}|rÎ|jS |S dS )z2read an array for the specified node (off of groupr   NÚ
transposedFÚ
value_typer  r7  r2  r¹  Tr3  r5  r6  )r€   rm  r¼   rn  rQ   ZVLArrayrX   rR   rŸ  ru  rÞ  rC  ÚT)rÌ   rŽ   r¤   r¥   r€   rã   rä  r�  ÚretrÚ  r  r¹  rV   rV   rW   Ú
read_array‚  s&    zGenericFixed.read_arrayr,   )rŽ   r¤   r¥   r\   c                 C  sh   t t| j|› d�ƒƒ}|dkr.| j|||d�S |dkrVt| j|ƒ}| j|||d�}|S td|› �ƒ‚d S )NÚ_varietyÚmultiri  Úregularzunrecognized index variety: )rX   rm  rä  Úread_multi_indexr¼   Úread_index_noder²   )rÌ   rŽ   r¤   r¥   Zvarietyrã   r•   rV   rV   rW   Ú
read_index¤  s    zGenericFixed.read_index)rŽ   r•   r\   c                 C  sà   t |tƒr,t| j|› d�dƒ |  ||¡ n°t| j|› d�dƒ td|| j| jƒ}|  ||j	¡ t
| j|ƒ}|j|j_|j|j_t |ttfƒr |  t|ƒ¡|j_t |tttfƒrº|j|j_t |tƒrÜ|jd urÜt|jƒ|j_d S )Nr†  r‡  rˆ  r•   )rQ   r-   rþ  rä  Úwrite_multi_indexÚ_convert_indexr[   r™   Úwrite_arrayr]  rm  r¼   rg  rn  rb   r+   r.   rs  rß   rw  r1   r¸  r¹  Ú_get_tz)rÌ   rŽ   r•   rI  rã   rV   rV   rW   Úwrite_index²  s    



zGenericFixed.write_indexr-   c                 C  sÒ   t | j|› d�|jƒ tt|j|j|jƒƒD ] \}\}}}t|j	t
ƒrNtdƒ‚|› d|› �}t||| j| jƒ}|  ||j¡ t| j|ƒ}	|j|	j_||	j_t |	j|› d|› �|ƒ |› d|› �}
|  |
|¡ q,d S )NÚ_nlevelsz=Saving a MultiIndex with an extension dtype is not supported.Ú_levelÚ_nameÚ_label)rþ  rä  r•  Ú	enumerater5  Úlevelsr  ÚnamesrQ   rÚ  r'   r®   r�  r[   r™   rŽ  r]  rm  r¼   rg  rn  rb   )rÌ   rŽ   r•   ÚiÚlevÚlevel_codesrb   Ú	level_keyZ
conv_levelrã   Ú	label_keyrV   rV   rW   rŒ  É  s"    ÿÿ
zGenericFixed.write_multi_indexc                 C  s¤   t | j|› d�ƒ}g }g }g }t|ƒD ]l}|› d|› �}	t | j|	ƒ}
| j|
||d�}| |¡ | |j¡ |› d|› �}| j|||d�}| |¡ q&t|||dd�S )Nr‘  r’  ri  r”  T)r–  r  r—  r.  )	rm  rä  rU  r¼   rŠ  r“   rb   r…  r-   )rÌ   rŽ   r¤   r¥   r•  r–  r  r—  r˜  r›  rã   r™  rœ  rš  rV   rV   rW   r‰  â  s     
ÿzGenericFixed.read_multi_indexrF   )rã   r¤   r¥   r\   c                 C  sØ   |||… }d|j v r>t |j j¡dkr>tj|j j|j jd�}t|j jƒ}d }d|j v rlt|j j	ƒ}t|ƒ}|j }|  
|¡\}}	|dv r®|t||| j| jd�fdti|	¤Ž}
n |t||| j| jd�fi |	¤Ž}
||
_	|
S )Nr  r   r7  rb   )r   rÉ  rŒ  rÚ  )rn  rR   Úprodr  rŸ  r‚  rX   rg  rc   rb   r~  Ú_unconvert_indexr[   r™   rÉ  )rÌ   rã   r¤   r¥   r|  rg  rb   rä  rà  rº   r•   rV   rV   rW   rŠ  ù  s:    
ÿÿüûÿÿüzGenericFixed.read_index_noderH   )rŽ   r�   r\   c                 C  sJ   t  d|j ¡}| j | j||¡ t| j|ƒ}t|jƒ|j	_
|j|j	_dS )zwrite a 0-len array©rg   N)rR   rŸ  rV  rÂ   Úcreate_arrayr¼   rm  rZ   rÚ  rn  r‚  r  )rÌ   rŽ   r�   Zarrrã   rV   rV   rW   Úwrite_array_empty  s
    zGenericFixed.write_array_emptyrG   zIndex | None)rŽ   r   rþ   r\   c                 C  sh  t |dd�}|| jv r&| j | j|¡ |jdk}d}t|jtƒrHtdƒ‚|s`t	|dƒr`|j
}d}d }| jd ur¦ttƒ�  tƒ j |j¡}W d   ƒ n1 sœ0    Y  |d urì|sÜ| jj| j|||j| jd�}||d d …< n|  ||¡ �nh|jjtjk�rbtj|dd�}	|�rn,|	d	k�rn t|	||f }
tj|
ttƒ d
� | j | j|tƒ  ¡ ¡}|  |¡ nòt !|jd¡�r¢| j "| j|| #d¡¡ t$|jƒt%| j|ƒj&_'n²t|jt(ƒ�rô| j "| j||j)¡ t%| j|ƒ}t*|j+ƒ|j&_+d|jj,› d�|j&_'n`t !|jd¡�r.| j "| j|| #d¡¡ dt%| j|ƒj&_'n&|�rB|  ||¡ n| j "| j||¡ |t%| j|ƒj&_-d S )NT)Zextract_numpyr   Fz]Cannot store a category dtype in a HDF5 dataset that uses format="fixed". Use format="table".rƒ  )rÅ   ©Zskipnarê  rø  rÖ  r×  údatetime64[r%  r  r5  ).r9   r¼   rÂ   r¦  r  rQ   rÚ  r%   r®   rÓ  rƒ  rÊ   r   r«   r„   ZAtomZ
from_dtypeZcreate_carrayr  r¡  rß   rR   Zobject_r   Úinfer_dtyperu   rü  rý  r   r   Zcreate_vlarrayÚ
ObjectAtomr“   rÝ  r   ÚviewrZ   rm  rn  r‚  r&   Úasi8r�  r¹  Úunitr�  )rÌ   rŽ   r   rþ   r�   Zempty_arrayr�  r!  ÚcaÚinferred_typer   Zvlarrrã   rV   rV   rW   rŽ  (  sf    

ÿ


.ÿ

ÿzGenericFixed.write_array)NN)NN)NN)NN)N)rà   r­  r®  r¯  r+   r.   rr  rþ   rt  rp  r°  rs  rv  r~  r  r±  r¢  rd  re  r¤  r…  r‹  r�  rŒ  r‰  rŠ  r¡  rŽ  rV   rV   rV   rW   rn    s2   
1# ÿ ÿ ÿ&
 ÿrn  c                      sV   e Zd ZU dZdgZded< edd„ ƒZddddd	œd
d„Zddœ‡ fdd„Z	‡  Z
S )r“  rˆ  rb   r@   c              	   C  s.   zt | jjƒfW S  ttfy(   Y d S 0 d S r]   )rp   r¼   r]  r²   r�   rÐ   rV   rV   rW   r  ‰  s    zSeriesFixed.shapeNr‡   r0   rm  c                 C  s^   |   ||¡ | jd||d�}| jd||d�}t||| jdd�}tƒ rZt|dd�rZ| d¡}|S )	Nr•   ri  r]  F)r•   rb   r}  Tr¢  ústring[pyarrow_numpy])r  r‹  r…  r0   rb   r   r   rF  )rÌ   rq   r¦   r¤   r¥   r•   r]  r|  rV   rV   rW   r  �  s    
zSeriesFixed.readrŒ   rÎ   c                   s<   t ƒ j|fi |¤Ž |  d|j¡ |  d|¡ |j| j_d S )Nr•   r]  )r  r¤  r�  r•   rŽ  rb   rä  rl  r  rV   rW   r¤  Ÿ  s    zSeriesFixed.write)NNNN)rà   r­  r®  rQ  rp  r°  r±  r  r  r¤  rL  rV   rV   r  rW   r“  ƒ  s   

    ûr“  c                      sZ   e Zd ZU ddgZded< eddœdd„ƒZdd	d	d
dœdd„Zddœ‡ fdd„Z‡  Z	S )ÚBlockManagerFixedrV  Únblocksrd   zShape | NonerÎ   c                 C  s®   z”| j }d}t| jƒD ]8}t| jd|› d�ƒ}t|dd ƒ}|d ur||d 7 }q| jj}t|dd ƒ}|d ur‚t|d|d … ƒ}ng }| |¡ |W S  ty¨   Y d S 0 d S )Nr   ÚblockÚ_itemsr  rg   )	rV  rU  r­  rm  r¼   Zblock0_valuesrn   r“   r�   )rÌ   rV  rþ   r˜  rã   r  rV   rV   rW   r  «  s"    
zBlockManagerFixed.shapeNr‡   r*   rm  c                 C  sH  |   ||¡ |  ¡  d¡}g }t| jƒD ]<}||kr<||fnd\}}	| jd|› �||	d�}
| |
¡ q(|d }g }t| jƒD ]x}|  d|› d�¡}| jd|› d�||	d�}|| 	|¡ }t
|j||d d	d
�}tƒ rêt|dd�rê| d¡}| |¡ q|t|ƒdk�r4t|ddd�}tƒ �r"| ¡ }|j|d	d�}|S t
|d |d d�S )Nr   )NNr-  ri  r®  r¯  rG  rg   F©r¦   r•   r}  Tr¢  r«  )r-  r}  )r¦   r}  ©r¦   r•   )r  rT  Z_get_block_manager_axisrU  rV  r‹  r“   r­  r…  r[  r*   rƒ  r   r   rF  rp   r2   r   r}  r`  )rÌ   rq   r¦   r¤   r¥   Zselect_axisrG  r˜  r  r  Úaxrþ   ÚdfsÚ	blk_itemsr]  ÚdfÚoutrV   rV   rW   r  Æ  s0    
zBlockManagerFixed.readrŒ   c                   sè   t ƒ j|fi |¤Ž t|jtƒr*| d¡}|j}| ¡ s@| ¡ }|j| j	_t
|jƒD ]0\}}|dkrr|jsrtdƒ‚|  d|› �|¡ qTt|jƒ| j	_t
|jƒD ]D\}}|j |j¡}| jd|› d�|j|d� |  d|› d�|¡ qžd S )Nr®  r   z/Columns index has to be unique for fixed formatr-  rG  )rþ   r¯  )r  r¤  rQ   Ú_mgrr;   Ú_as_managerZis_consolidatedZconsolidaterV  rä  r•  rG  Z	is_uniquer«   r�  rp   Úblocksr­  rþ   r\  Úmgr_locsrŽ  r]  )rÌ   r   rº   r|  r˜  r²  Úblkr´  r  rV   rW   r¤  ï  s     

zBlockManagerFixed.write)NNNN)
rà   r­  r®  rp  r°  r±  r  r  r¤  rL  rV   rV   r  rW   r¬  ¦  s   
    û)r¬  c                   @  s   e Zd ZdZeZdS )r”  r‰  N)rà   r­  r®  rQ  r*   rT  rV   rV   rV   rW   r”  	  s   r”  c                      s²  e Zd ZU dZdZdZded< ded< dZded	< d
Zded< d�dddddddddddœ
‡ fdd„Z	e
ddœdd„ƒZddœdd„Zdd œd!d"„Zddœd#d$„Ze
d%dœd&d'„ƒZd(d)d*œd+d,„Ze
d-dœd.d/„ƒZe
d%dœd0d1„ƒZe
d2d3„ ƒZe
d4d5„ ƒZe
d6d7„ ƒZe
d8d9„ ƒZe
d:dœd;d<„ƒZe
d-dœd=d>„ƒZe
d%dœd?d@„ƒZe
dAdœdBdC„ƒZdDdœdEdF„ZdGdH„ ZdIdœdJdK„ZdddLœdMdN„ZddOddPœdQdR„ZddSœdTdU„Z ddœdVdW„Z!ddœdXdY„Z"d‚ddœdZd[„Z#ddœd\d]„Z$e%d^d_„ ƒZ&dƒddd`œdadb„Z'd„dcdcdddeœdfdg„Z(e)d%dhœdidj„ƒZ*dkdl„ Z+d…dmd%dnœdodp„Z,e-dmd%dqœdrds„ƒZ.d†dtdmduœdvdw„Z/dcd%dcdDdxœdydz„Z0d‡dcdcd{œd|d}„Z1dˆddcdcd~œdd€„Z2‡  Z3S )‰rø   aa  
    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_tablerw   rZ   rR  r…  rg   zint | list[Hashable]r–  Trn   r¾  Nr~   r¡   rF   rY   zlist[IndexCol] | Nonez list[tuple[AxisInt, Any]] | Nonezlist[DataCol] | Nonezlist | Nonezdict | NonerŒ   )
rÁ   r¼   r[   r™   Ú
index_axesr)  Úvalues_axesr˜   r‚  r\   c                   sP   t ƒ j||||d� |pg | _|p$g | _|p.g | _|p8g | _|	pBi | _|
| _d S )NrŒ  )r  rÍ   r¼  r)  r½  r˜   r‚  rš   )rÌ   rÁ   r¼   r[   r™   r¼  r)  r½  r˜   r‚  rš   r  rV   rW   rÍ   .  s    




zTable.__init__rÎ   c                 C  s   | j  d¡d S )NÚ_r   )r…  r¨  rÐ   rV   rV   rW   Útable_type_shortC  s    zTable.table_type_shortc                 C  s¦   |   ¡  t| jƒrd | j¡nd}d|› d�}d}| jrZd dd„ | jD ƒ¡}d|› d�}d d	d„ | jD ƒ¡}| jd
›|› d| j› d| j	› d| j
› d|› d|› d�S )r\  rÃ  rq  z,dc->[r%  r[  c                 S  s   g | ]}t |ƒ‘qS rV   ©rZ   r&  rV   rV   rW   rm   O  rõ   z"Table.__repr__.<locals>.<listcomp>r^  c                 S  s   g | ]
}|j ‘qS rV   ra   r{  rV   rV   rW   rm   R  rõ   r_  z (typ->z,nrows->z,ncols->z,indexers->[r`  )r  rp   r˜   rÆ  rX  rW  r¼  rj  r¿  r  Úncols)rÌ   Zjdcrb  ÚverZjverZjindex_axesrV   rV   rW   ré   G  s(    ÿÿþþþÿzTable.__repr__)rö  c                 C  s"   | j D ]}||jkr|  S qdS )zreturn the axis for cN)rG  rb   )rÌ   rö  r…   rV   rV   rW   rØ   Y  s    


zTable.__getitem__c              
   C  sº   |du rdS |j | j kr2td|j › d| j › d�ƒ‚dD ]~}t| |dƒ}t||dƒ}||kr6t|ƒD ]4\}}|| }||krbtd|› d|› d|› d�ƒ‚qbtd|› d|› d|› d�ƒ‚q6dS )	z"validate against an existing tableNz'incompatible table_type with existing [r÷  r%  )r¼  r)  r½  zinvalid combination of [z] on appending data [z] vs current table [)r…  r²   rm  r•  r«   rB  )rÌ   rË  rö  ÚsvÚovr˜  ÚsaxZoaxrV   rV   rW   r?  `  s:    ÿÿÿÿÿÿÿÿzTable.validaterˆ   c                 C  s   t | jtƒS )z@the levels attribute is 1 or a list in the case of a multi-index)rQ   r–  rn   rÐ   rV   rV   rW   Úis_multi_index�  s    zTable.is_multi_indexr†   z tuple[DataFrame, list[Hashable]])r   r\   c              
   C  s`   t  |jj¡}z| ¡ }W n. tyH } ztdƒ|‚W Y d}~n
d}~0 0 t|tƒsXJ ‚||fS )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)rC  Zfill_missing_namesr•   r—  Zreset_indexr«   rQ   r*   )rÌ   r   r–  Z	reset_objrF  rV   rV   rW   Úvalidate_multiindex†  s    ÿþzTable.validate_multiindexrd   c                 C  s   t  dd„ | jD ƒ¡S )z-based on our axes, compute the expected nrowsc                 S  s   g | ]}|j jd  ‘qS r(  )ré  r  ©ri   r˜  rV   rV   rW   rm   š  rõ   z(Table.nrows_expected.<locals>.<listcomp>)rR   r�  r¼  rÐ   rV   rV   rW   Únrows_expected—  s    zTable.nrows_expectedc                 C  s
   d| j v S )zhas this table been createdrw   r¥  rÐ   rV   rV   rW   r¢  œ  s    zTable.is_existsc                 C  s   t | jdd ƒS ©Nrw   ©rm  r¼   rÐ   rV   rV   rW   rf  ¡  s    zTable.storablec                 C  s   | j S )z,return the table group (this is my storable))rf  rÐ   rV   rV   rW   rw   ¥  s    zTable.tablec                 C  s   | j jS r]   )rw   rÚ  rÐ   rV   rV   rW   rÚ  ª  s    zTable.dtypec                 C  s   | j jS r]   rå  rÐ   rV   rV   rW   ræ  ®  s    zTable.descriptionzitertools.chain[IndexCol]c                 C  s   t  | j| j¡S r]   )r3  r4  r¼  r½  rÐ   rV   rV   rW   rG  ²  s    z
Table.axesc                 C  s   t dd„ | jD ƒƒS )z.the number of total columns in the values axesc                 s  s   | ]}t |jƒV  qd S r]   )rp   r]  r{  rV   rV   rW   rN  ¹  rõ   zTable.ncols.<locals>.<genexpr>)Úsumr½  rÐ   rV   rV   rW   rÁ  ¶  s    zTable.ncolsc                 C  s   dS r	  rV   rÐ   rV   rV   rW   Úis_transposed»  s    zTable.is_transposedztuple[int, ...]c                 C  s(   t t dd„ | jD ƒdd„ | jD ƒ¡ƒS )z@return a tuple of my permutated axes, non_indexable at the frontc                 S  s   g | ]}t |d  ƒ‘qS r(  rZ  r{  rV   rV   rW   rm   Ä  rõ   z*Table.data_orientation.<locals>.<listcomp>c                 S  s   g | ]}t |jƒ‘qS rV   )rd   r-  r{  rV   rV   rW   rm   Å  rõ   )ro   r3  r4  r)  r¼  rÐ   rV   rV   rW   Údata_orientation¿  s    þÿzTable.data_orientationzdict[str, Any]c                   sR   dddœ‰ dd„ ˆj D ƒ}‡ fdd„ˆjD ƒ}‡fdd„ˆjD ƒ}t|| | ƒS )z<return a dict of the kinds allowable columns for this objectr•   r¦   ©r   rg   c                 S  s   g | ]}|j |f‘qS rV   ©r»  r{  rV   rV   rW   rm   Ï  rõ   z$Table.queryables.<locals>.<listcomp>c                   s   g | ]\}}ˆ | d f‘qS r]   rV   )ri   r-  r]  )Ú
axis_namesrV   rW   rm   Ð  rõ   c                   s&   g | ]}|j tˆ jƒv r|j|f‘qS rV   )rb   rT  r˜   r»  r:  rÐ   rV   rW   rm   Ñ  s   )r¼  r)  r½  rI  )rÌ   Zd1Zd2Zd3rV   )rÑ  rÌ   rW   Ú
queryablesÉ  s    

ÿzTable.queryablesc                 C  s   dd„ | j D ƒS )zreturn a list of my index colsc                 S  s   g | ]}|j |jf‘qS rV   )r-  r»  rÈ  rV   rV   rW   rm   Ú  rõ   z$Table.index_cols.<locals>.<listcomp>©r¼  rÐ   rV   rV   rW   Ú
index_cols×  s    zTable.index_colsrð   c                 C  s   dd„ | j D ƒS )zreturn a list of my values colsc                 S  s   g | ]
}|j ‘qS rV   rÐ  rÈ  rV   rV   rW   rm   Þ  rõ   z%Table.values_cols.<locals>.<listcomp>)r½  rÐ   rV   rV   rW   Úvalues_colsÜ  s    zTable.values_colsrÙ   c                 C  s   | j j}|› d|› d�S )z)return the metadata pathname for this keyz/meta/z/metarb  r	  rV   rV   rW   Ú_get_metadata_pathà  s    zTable._get_metadata_pathrÔ  )rŽ   r]  r\   c                 C  s0   | j j|  |¡t|dd�d| j| j| jd� dS )z£
        Write out a metadata array to the key as a fixed-format Series.

        Parameters
        ----------
        key : str
        values : ndarray
        Fr@  rw   )r”   r[   r™   rš   N)rÁ   r    rÖ  r0   r[   r™   rš   )rÌ   rŽ   r]  rV   rV   rW   ró  å  s    	
úzTable.write_metadatarÕ   c                 C  s0   t t | jddƒ|dƒdur,| j |  |¡¡S dS )z'return the meta data array for this keyr¾   N)rm  r¼   rÁ   r·   rÖ  r×   rV   rV   rW   r  ÷  s    zTable.read_metadatac                 C  sp   t | jƒ| j_|  ¡ | j_|  ¡ | j_| j| j_| j| j_| j| j_| j| j_| j	| j_	| j
| j_
| j| j_dS )zset our table type & indexablesN)rZ   r…  rä  rÔ  rÕ  r)  r˜   rš   r[   r™   r–  r‚  rÐ   rV   rV   rW   rd  ý  s    





zTable.set_attrsc                 C  s°   t | jddƒpg | _t | jddƒp$g | _t | jddƒp8i | _t | jddƒ| _tt | jddƒƒ| _tt | jddƒƒ| _	t | jd	dƒp„g | _
d
d„ | jD ƒ| _dd„ | jD ƒ| _dS )r€  r)  Nr˜   r‚  rš   r[   r™   r~   r–  c                 S  s   g | ]}|j r|‘qS rV   ©r¶  r{  rV   rV   rW   rm     rõ   z#Table.get_attrs.<locals>.<listcomp>c                 S  s   g | ]}|j s|‘qS rV   r×  r{  rV   rV   rW   rm     rõ   )rm  rä  r)  r˜   r‚  rš   r`   r[   rX   r™   r–  Ú
indexablesr¼  r½  rÐ   rV   rV   rW   re  
  s    zTable.get_attrsc                 C  s>   |dur:| j r:td dd„ | jD ƒ¡ }tj|ttƒ d� dS )rg  Nr[  c                 S  s   g | ]}t |ƒ‘qS rV   rÀ  r&  rV   rV   rW   rm     rõ   z*Table.validate_version.<locals>.<listcomp>rø  )rX  rs   rÆ  rW  rü  rý  r   r   )rÌ   rq   r   rV   rV   rW   rh    s    ýzTable.validate_versionc                 C  sR   |du rdS t |tƒsdS |  ¡ }|D ]&}|dkr4q&||vr&td|› d�ƒ‚q&dS )zˆ
        validate the min_itemsize doesn't contain items that are not in the
        axes this needs data_columns to be defined
        Nr]  zmin_itemsize has the key [z%] which is not an axis or data_column)rQ   rI  rÒ  r«   )rÌ   r–   Úqr$  rV   rV   rW   Úvalidate_min_itemsize!  s    

ÿzTable.validate_min_itemsizec                   sÔ   g }ˆj ‰ˆjj‰tˆjjƒD ]j\}\}}tˆ|ƒ}ˆ |¡}|durJdnd}|› d�}tˆ|dƒ}	t||||	|ˆj||d�}
| |
¡ qt	ˆj
ƒ‰t|ƒ‰ ‡ ‡‡‡‡fdd„‰| ‡fdd„tˆjjƒD ƒ¡ |S )	z/create/cache the indexables if they don't existNr  rÁ  )rb   r-  r½  rg  r¼  rw   r¾   r¾  c                   s¢   t |tƒsJ ‚t}|ˆv rt}tˆ|ƒ}t|ˆjƒ}tˆ|› d�d ƒ}tˆ|› d�d ƒ}t|ƒ}ˆ |¡}tˆ|› d�d ƒ}	|||||ˆ |  |ˆj	|	||d�
}
|
S )NrÁ  r  r  )
rb   r»  r]  rg  r½  r¼  rw   r¾   r¾  rÚ  )
rQ   rZ   r
  rM  rm  Ú_maybe_adjust_namerW  r  r  rw   )r˜  rö  Úklassr!  Úadj_namer]  rÚ  rg  Úmdr¾   r   )Úbase_posrb  ÚdescrÌ   Útable_attrsrV   rW   rx   Y  s0    

özTable.indexables.<locals>.fc                   s   g | ]\}}ˆ ||ƒ‘qS rV   rV   )ri   r˜  rö  )rx   rV   rW   rm   ~  rõ   z$Table.indexables.<locals>.<listcomp>)ræ  rw   rä  r•  rÔ  rm  r  rµ  r“   rT  r˜   rp   rX  rÕ  )rÌ   Ú_indexablesr˜  r-  rb   r!  rÞ  r¾   rÂ  rg  Ú	index_colrV   )rß  rb  rà  rx   rÌ   rá  rW   rØ  6  s2    


ø

% zTable.indexablesr%  c              	   C  sV  |   ¡ sdS |du rdS |du s(|du r8dd„ | jD ƒ}t|ttfƒsL|g}i }|dur`||d< |durp||d< | j}|D ]Ö}t|j|dƒ}|du�r"|jrò|j	}|j
}	|j}
|durÈ|
|krÈ| ¡  n|
|d< |durê|	|krê| ¡  n|	|d< |j�sP|j d¡�rtd	ƒ‚|jf i |¤Ž qz|| jd
 d v rztd|› d|› d|› d�ƒ‚qzdS )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.
        NFTc                 S  s   g | ]}|j r|j‘qS rV   )r·  r»  r{  rV   rV   rW   rm   §  rõ   z&Table.create_index.<locals>.<listcomp>rf  rg  ÚcomplexzíColumns 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.r   rg   zcolumn 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.)r  rG  rQ   ro   rn   rw   rm  rM  rz  r•   rf  rg  Zremove_indexrß   ru  r²   rh  r)  r�   )rÌ   r¦   rf  rg  Úkwrw   rö  rQ  r•   Zcur_optlevelZcur_kindrV   rV   rW   rh  ‚  sR    


ÿÿþÿzTable.create_indexr‡   z9list[tuple[np.ndarray, np.ndarray] | tuple[Index, Index]]rm  c           	      C  sZ   t | |||d�}| ¡ }g }| jD ]2}| | j¡ |j|| j| j| jd�}| 	|¡ 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]]
        r  rB  )
Ú	Selectionr·   rG  r  r‚  rá  rš   r[   r™   r“   )	rÌ   rq   r¤   r¥   Ú	selectionr]  r´  r…   ÚresrV   rV   rW   Ú
_read_axesØ  s    
üzTable._read_axes©r�  c                 C  s   |S )zreturn the data for this objrV   ©rž  r   r�  rV   rV   rW   Ú
get_objectú  s    zTable.get_objectc                   s²   t |ƒsg S |d \}‰ | j |i ¡}| d¡dkrL|rLtd|› d|› �ƒ‚|du r^tˆ ƒ}n|du rjg }t|tƒr t|ƒ‰t|ƒ}| ‡fdd	„| 	¡ D ƒ¡ ‡ fd
d	„|D ƒS )zd
        take the input data_columns and min_itemize and create a data
        columns spec
        r   rß   r-   z"cannot use a multi-index on axis [z] with data_columns TNc                   s    g | ]}|d kr|ˆ vr|‘qS râ  rV   r#  )Úexisting_data_columnsrV   rW   rm     s   þz/Table.validate_data_columns.<locals>.<listcomp>c                   s   g | ]}|ˆ v r|‘qS rV   rV   )ri   rö  )Úaxis_labelsrV   rW   rm   #  rõ   )
rp   r‚  rÖ   r«   rn   rQ   rI  rT  rX  rú   )rÌ   r˜   r–   r)  r-  r‚  rV   )rî  rí  rW   Úvalidate_data_columnsÿ  s.    ÿÿ


þÿ	zTable.validate_data_columnsr*   )r   r?  c           /        sš  t ˆtƒs,| jj}td|› dtˆƒ› d�ƒ‚ˆ du r:dg‰ ‡fdd„ˆ D ƒ‰ |  ¡ rzd}d	d„ | jD ƒ‰ t| j	ƒ}| j
}nd
}| j}	| jdks’J ‚tˆ ƒ| jd kr¬tdƒ‚g }
|du r¼d}t‡ fdd„dD ƒƒ}ˆj| }t|ƒ}|�rHt|
ƒ}| j| d }tt |¡t |¡ddd��sHtt t|ƒ¡t t|ƒ¡ddd��rH|}|	 |i ¡}t|jƒ|d< t|ƒj|d< |
 ||f¡ ˆ d }ˆj| }ˆ |¡}t||| j| jƒ}||_| d¡ |  |	¡ | !|¡ |g}t|ƒ}|dk�sìJ ‚t|
ƒdk�sþJ ‚|
D ]}t"ˆ|d |d ƒ‰�q|jdk}|  #|||
¡}|  $ˆ|¡ %¡ }|  &|||
| j'|¡\}}g }t(t)||ƒƒD �]¸\}\}}t*}d}|�rÒt|ƒdk�rÒ|d |v �rÒt+}|d }|du �sÒt |t,ƒ�sÒtdƒ‚|�r4|�r4z| j'| }W nD t-t.f�y0 }  z&td|› d| j'› d�ƒ| ‚W Y d} ~ n
d} ~ 0 0 nd}|�pFd|› �}!t/|!|j0|||| j| j|d�}"t1|!| j2ƒ}#| 3|"¡}$t4|"j5j6ƒ}%d}&t7|"ddƒdu�r¨t8|"j9ƒ}&d }' }(})t |"j5t:ƒ�rÜ|"j;})d}'t <|"j=¡ >¡ }(t?|"ƒ\}*}+||#|!t|ƒ|$||%|&|)|'|(|+|*d�},|,  |	¡ | |,¡ |d7 }�qpdd„ |D ƒ}-t| ƒ| j@| j| j| j||
||-|	|d�
}.tA| dƒ�rv| jB|._B|. C|¡ |�r–|�r–|. D| ¡ |.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->r‹  r%  Nr   c                   s   g | ]}ˆ   |¡‘qS rV   )Ú_get_axis_numberr{  )r   rV   rW   rm   Q  rõ   z&Table._create_axes.<locals>.<listcomp>Tc                 S  s   g | ]
}|j ‘qS rV   rO  r{  rV   rV   rW   rm   V  rõ   FrV  rg   z<currently only support ndim-1 indexers in an AppendableTableÚnanc                 3  s   | ]}|ˆ vr|V  qd S r]   rV   r&  )rG  rV   rW   rN  n  rõ   z%Table._create_axes.<locals>.<genexpr>rÏ  r  r—  rß   rN  zIncompatible appended table [z]with existing table [Zvalues_block_)Úexisting_colr–   rš   r[   r™   r¦   r¹  r  )rb   r»  r]  r¼  r½  rg  r¹  ra  r¾   r¾  rÚ  r|  c                 S  s   g | ]}|j r|j‘qS rV   )r·  rb   )ri   rç  rV   rV   rW   rm   ü  rõ   )
rÁ   r¼   r[   r™   r¼  r)  r½  r˜   r‚  rš   r–  )ErQ   r*   r¼   r¿   r²   rß   r  r¼  rn   r˜   rš   r‚  rV  rp   r«   rS  rG  r)  r)   rR   ÚarrayrZ  rû  r—  rà   r“   Z_get_axis_namer�  r[   r™   r-  r¿  r  rì  Ú_reindex_axisrï  rì  r/  Ú_get_blocks_and_itemsr½  r•  r5  r
  rM  rZ   Ú
IndexErrorrÞ   Ú_maybe_convert_for_string_atomr]  rÛ  rW  r"  r  rÚ  rb   rm  r�  r¹  r%   ra  rC  r>  rD  r  rÁ   rÓ  r–  rÚ  r?  )/rÌ   rG  r   r?  rš   r˜   r–   r¼   Útable_existsZnew_infoÚnew_non_index_axesrÿ  r…   Zappend_axisZindexerZ
exist_axisr‚  Ú	axis_nameZ	new_indexZnew_index_axesÚjr�  r‰  r¹  r´  Zvaxesr˜  r»  Úb_itemsrÜ  rb   rò  rF  Únew_nameÚdata_convertedrÝ  r¼  rg  r¹  r¾   r¾  ra  r|  r  rç  ZdcsZ	new_tablerV   )rG  r   rW   Ú_create_axes%  s,    
ÿÿ
ÿ
üü





ÿÿ"ÿÿýø


ô

ö

zTable._create_axes)r‰  rø  c                 C  s�  t | jtƒr|  d¡} dd„ }| j}tt|ƒ}t|jƒ}||ƒ}t|ƒrÒ|d \}	}
t	|
ƒ 
t	|ƒ¡}| j||	d�j}tt|ƒ}t|jƒ}||ƒ}|D ]:}| j|g|	d�j}tt|ƒ}| |j¡ | ||ƒ¡ q–|�rˆdd„ t||ƒD ƒ}g }g }|D ]†}t|jƒ}z&| |¡\}}| |¡ | |¡ W qø ttf�y| } z2d d	d
„ |D ƒ¡}td|› d�ƒ|‚W Y d }~qød }~0 0 qø|}|}||fS )Nr®  c                   s   ‡ fdd„ˆ j D ƒS )Nc                   s   g | ]}ˆ j  |j¡‘qS rV   )rþ   r\  rº  )ri   r»  ©ÚmgrrV   rW   rm   $  rõ   zFTable._get_blocks_and_items.<locals>.get_blk_items.<locals>.<listcomp>)r¹  r   rV   r   rW   Úget_blk_items#  s    z2Table._get_blocks_and_items.<locals>.get_blk_itemsr   rO  c                 S  s"   i | ]\}}t | ¡ ƒ||f“qS rV   )ro   Útolist)ri   Úbrü  rV   rV   rW   rR  B  s   ÿz/Table._get_blocks_and_items.<locals>.<dictcomp>rÃ  c                 S  s   g | ]}t |ƒ‘qS rV   r]  )ri   ÚitemrV   rV   rW   rm   O  rõ   z/Table._get_blocks_and_items.<locals>.<listcomp>z+cannot match existing table structure for [z] on appending data)rQ   r·  r;   r¸  r   r<   rn   r¹  rp   r,   rY  r`  rX  r5  ro   r]  r8  r“   rö  rÞ   rÆ  r«   )r‰  rø  rù  r½  r˜   r  r  r¹  r´  r-  rî  Z
new_labelsrö  Zby_itemsZ
new_blocksZnew_blk_itemsZearþ   r  rü  rF  ZjitemsrV   rV   rW   rõ    sR    





þ


ÿýzTable._get_blocks_and_itemsræ  )rç  r\   c                   sª   |durt |ƒ}|durNˆjrNtˆjt ƒs.J ‚ˆjD ]}||vr4| d|¡ q4ˆjD ]$\}}tˆ |||ƒ‰ ‡ ‡fdd„}qT|jdur¦|j ¡ D ]\}}	}
|||
|	ƒ‰ qŽˆ S )zprocess axes filtersNr   c                   sÌ   ˆ j D ]°}ˆ  |¡}ˆ  |¡}|d us*J ‚| |krfˆjrH| tˆjƒ¡}|||ƒ}ˆ j|d�|   S | |v rtt	ˆ | ƒj
ƒ}t|ƒ}tˆ tƒr˜d| }|||ƒ}ˆ j|d�|   S qtd| › d�ƒ‚d S )NrO  rg   zcannot find the field [z] for filtering!)Z_AXIS_ORDERSrð  Ú	_get_axisrÆ  Úunionr,   r–  r_  r:   rm  r]  rQ   r*   r«   )ÚfieldÚfiltÚoprú  Zaxis_numberZaxis_valuesZtakersr]  ©r   rÌ   rV   rW   Úprocess_filterj  s"    





z*Table.process_axes.<locals>.process_filter)	rn   rÆ  rQ   r–  Úinsertr)  rô  Úfilterr”   )rÌ   r   rç  r¦   rô   r-  Úlabelsr  r  r
  r	  rV   r  rW   Úprocess_axesY  s    
 
zTable.process_axes)r‘   rÄ   rH  r\   c                 C  s‚   |du rt | jdƒ}d|dœ}dd„ | jD ƒ|d< |rj|du rH| jpFd}tƒ j|||pZ| jd	�}||d
< n| jdur~| j|d
< |S )z:create the description of the table from the axes & valuesNi'  rw   )rb   rH  c                 S  s   i | ]}|j |j“qS rV   )r»  r¼  r{  rV   rV   rW   rR  Ÿ  rõ   z,Table.create_description.<locals>.<dictcomp>ræ  é	   )r‘   r’   rÄ   rÅ   )ÚmaxrÉ  rG  rÇ   r„   r   rÉ   rÊ   )rÌ   r’   r‘   rÄ   rH  rJ  rÅ   rV   rV   rW   Úcreate_description�  s     	

ý


zTable.create_descriptionri  c           
      C  s�   |   |¡ |  ¡ sdS t| |||d�}| ¡ }|jdurˆ|j ¡ D ]D\}}}| j|| ¡ | ¡ d d�}	|||	j	|| ¡   |ƒj
 }qBt|ƒS )zf
        select coordinates (row numbers) from a table; return the
        coordinates object
        Fr  Nrg   ri  )rh  r  ræ  Úselect_coordsr  r”   r!  r³  r  Úilocr]  r,   )
rÌ   rq   r¤   r¥   rç  Zcoordsr  r
  r	  r|  rV   rV   rW   r  ¯  s    

ÿ zTable.read_coordinatesr   c                 C  s¼   |   ¡  |  ¡ sdS |dur$tdƒ‚| jD ]|}||jkr*|jsNtd|› d�ƒ‚t| jj	|ƒ}| 
| j¡ |j|||… | j| j| jd�}tt|d |jƒ|dd�  S q*td|› d	�ƒ‚dS )
zj
        return a single column from the table, generally only indexables
        are interesting
        FNz4read_column does not currently accept a where clausezcolumn [z=] can not be extracted individually; it is not data indexablerB  rg   )rb   r}  z] not found in the table)rh  r  r²   rG  rb   r·  r«   rm  rw   rM  r  r‚  rá  rš   r[   r™   r0   rÞ  r¹  rÞ   )rÌ   r  rq   r¤   r¥   r…   rö  Z
col_valuesrV   rV   rW   r!  É  s*    


ÿ
ü zTable.read_column)Nr~   NNNNNN)N)NNN)NN)TNNN)N)NNN)NNN)4rà   r­  r®  r¯  rQ  rR  r°  r–  r6  rÍ   r±  r¿  ré   rØ   r?  rÆ  rÇ  rÉ  r¢  rf  rw   rÚ  ræ  rG  rÁ  rÍ  rÎ  rÒ  rÔ  rÕ  rÖ  ró  r  rd  re  rh  rÚ  r   rØ  rh  ré  rK  rì  rï  rÿ  Ústaticmethodrõ  r  r  r  r!  rL  rV   rV   r  rW   rø     sž   
        õ&!



	
L ÿW ÿ"*    ù qC7  ÿ   ûrø   c                   @  s4   e Zd ZdZdZddddœdd„Zdd	œd
d„ZdS )r›  zË
    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
    r’  Nr‡   ri  c                 C  s   t dƒ‚dS )z[
        read the indices and the indexing array, calculate offset rows and return
        z!WORMTable needs to implement readNrj  rk  rV   rV   rW   r  þ  s    
zWORMTable.readrŒ   rÎ   c                 K  s   t dƒ‚dS )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 writeNrj  rl  rV   rV   rW   r¤  
  s    zWORMTable.write)NNNN)rà   r­  r®  r¯  r…  r  r¤  rV   rV   rV   rW   r›  õ  s       ûr›  c                   @  sh   e Zd ZdZdZddddddd	œd
d„Zdddddœdd„Zddddddœdd„Zddddœdd„ZdS )rî  ú(support the new appendable table formatsZ
appendableNFTrˆ   r‡   rŒ   )r“   r¨   r—   r;  r\   c                 C  s¶   |s| j r| j | jd¡ | j||||||d�}|jD ]}| ¡  q6|j s‚|j||||	d�}| ¡  ||d< |jj	|jfi |¤Ž |j
|j_
|jD ]}| ||¡ q’|j||
d� d S )Nrw   )rG  r   r?  r–   rš   r˜   )r’   r‘   rÄ   rH  r;  )r—   )r¢  rÂ   r¦  r¼   rÿ  rG  rí  r  rd  Zcreate_tabler‚  rä  rõ  Ú
write_data)rÌ   r   rG  r“   r’   r‘   rÄ   r–   r¨   rH  r—   rš   r˜   r;  rw   r…   ÚoptionsrV   rV   rW   r¤    s4    
ú	

ü

zAppendableTable.write)r¨   r—   r\   c                   sÈ  | j j}| j}g }|rT| jD ]6}t|jƒjdd�}t|tj	ƒr| 
|jddd�¡ qt|ƒrˆ|d }|dd… D ]}||@ }qp| ¡ }nd}dd	„ | jD ƒ}	t|	ƒ}
|
dks´J |
ƒ‚d
d	„ | jD ƒ}dd	„ |D ƒ}g }t|ƒD ]2\}}|f| j ||
|   j }| 
| |¡¡ qÞ|du �r d}tjt||ƒ| j d�}|| d }t|ƒD ]x}|| ‰t|d | |ƒ‰ ˆˆ k�rx �qÄ| j|‡ ‡fdd	„|	D ƒ|du�r¦|ˆˆ … nd‡ ‡fdd	„|D ƒd� �qJdS )z`
        we form the data into a 2-d including indexes,values,mask write chunk-by-chunk
        r   rO  Úu1Fr@  rg   Nc                 S  s   g | ]
}|j ‘qS rV   )ré  r{  rV   rV   rW   rm   o  rõ   z.AppendableTable.write_data.<locals>.<listcomp>c                 S  s   g | ]}|  ¡ ‘qS rV   )rã  r{  rV   rV   rW   rm   u  rõ   c              	   S  s,   g | ]$}|  t t |j¡|jd  ¡¡‘qS rŸ  )Z	transposerR   ZrollÚarangerV  r:  rV   rV   rW   rm   v  rõ   r²  r7  c                   s   g | ]}|ˆˆ … ‘qS rV   rV   r{  ©Zend_iZstart_irV   rW   rm   Š  rõ   c                   s   g | ]}|ˆˆ … ‘qS rV   rV   r:  r  rV   rW   rm   Œ  rõ   )ÚindexesrJ  r]  )rÚ  r—  rÉ  r½  r3   r|  rK  rQ   rR   rÙ  r“   rF  rp   rD  r¼  r•  r  ÚreshaperŸ  r³  rU  Úwrite_data_chunk)rÌ   r¨   r—   r—  r  Úmasksr…   rJ  r  r  Únindexesr]  Úbvaluesr˜  rQ  Z	new_shapeÚrowsÚchunksrV   r  rW   r  T  sL    




üzAppendableTable.write_datarÔ  zlist[np.ndarray]znpt.NDArray[np.bool_] | None)r#  r  rJ  r]  r\   c                 C  sä   |D ]}t  |j¡s dS q|d jd }|t|ƒkrFt j|| jd�}| jj}t|ƒ}t|ƒD ]\}	}
|
|||	 < q^t|ƒD ]\}	}||||	|  < q||durÂ| ¡ j	t
dd� }| ¡ sÂ|| }t|ƒrà| j |¡ | j ¡  dS )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
        Nr   r7  Fr@  )rR   r�  r  rp   rŸ  rÚ  r—  r•  rD  rF  rˆ   rK  rw   r“   r  )rÌ   r#  r  rJ  r]  rQ  r  r—  r!  r˜  rÿ  r  rV   rV   rW   r  �  s&    z AppendableTable.write_data_chunkri  c                 C  sf  |d u st |ƒsf|d u r:|d u r:| j}| jj| jdd� n(|d u rH| j}| jj||d�}| j ¡  |S |  ¡ srd S | j}t	| |||d�}| 
¡ }t|dd� ¡ }t |ƒ}	|	�rb| ¡ }
t|
|
dk jƒ}t |ƒsÖdg}|d |	krì| |	¡ |d dk�r| dd¡ | ¡ }t|ƒD ]@}| t||ƒ¡}|j||jd  ||jd  d d� |}�q| j ¡  |	S )	NTr?  ri  Fr@  rg   r   r=  )rp   r  rÂ   r¦  r¼   rw   Zremove_rowsr  r  ræ  r  r0   Zsort_valuesÚdiffrn   r•   r“   r  r8  Úreversedr\  rU  )rÌ   rq   r¤   r¥   r  rw   rç  r]  Zsorted_seriesÚlnr%  r´   Zpgrý   r#  rV   rV   rW   rE  »  sD    

ÿ
zAppendableTable.delete)NFNNNNNNFNNT)F)NNN)	rà   r­  r®  r¯  r…  r¤  r  r  rE  rV   rV   rV   rW   rî    s$               ò;;,rî  c                   @  s`   e Zd ZU dZdZdZdZeZde	d< e
ddœd	d
„ƒZeddœdd„ƒZddddœdd„ZdS )r™  r  r†  r�  rV  rS  rT  rˆ   rÎ   c                 C  s   | j d jdkS )Nr   rg   )r¼  r-  rÐ   rV   rV   rW   rÍ  þ  s    z"AppendableFrameTable.is_transposedrê  c                 C  s   |r
|j }|S )zthese are written transposed)rƒ  rë  rV   rV   rW   rì    s    zAppendableFrameTable.get_objectNr‡   ri  c                   sh  ˆ   |¡ ˆ  ¡ sd S ˆ j|||d�}tˆ jƒrHˆ j ˆ jd d i ¡ni }‡ fdd„tˆ jƒD ƒ}t|ƒdkstJ ‚|d }|| d }	g }
tˆ jƒD �]†\}}|ˆ j	vr¬q–|| \}}| d¡dkrÐt
|ƒ}n
t |¡}| d¡}|d urú|j|d	d
� ˆ j�r |}|}t
|	t|	dd ƒd�}n|j}t
|	t|	dd ƒd�}|}|jdk�rlt|tjƒ�rl| d|jd f¡}t|tjƒ�rŽt|j||dd�}n.t|t
ƒ�rªt|||d�}ntj|g||d�}tƒ �rÒ|jjdk�sô|j|jk ¡ �sôJ |j|jfƒ‚tƒ �rt|d	d��r| d¡}|
  |¡ q–t|
ƒdk�r8|
d }nt!|
dd�}t"ˆ |||d�}ˆ j#|||d�}|S )Nr  r   c                   s"   g | ]\}}|ˆ j d  u r|‘qS r(  rÓ  )ri   r˜  r²  rÐ   rV   rW   rm     rõ   z-AppendableFrameTable.read.<locals>.<listcomp>rg   rß   r-   r—  T©Zinplacerb   ra   Fr°  r±  rA  r¢  r«  rO  )rç  r¦   )$rh  r  ré  rp   r)  r‚  rÖ   r•  rG  r½  r,   r-   Úfrom_tuplesÚ	set_namesrÍ  rm  rƒ  rV  rQ   rR   rÙ  r  r  r*   Z_from_arraysr   rÚ  rg  ZdtypesrK  r   rF  r“   r2   ræ  r  )rÌ   rq   r¦   r¤   r¥   r|  r‚  ZindsÚindr•   Úframesr˜  r…   Z
index_valsré  rM  r—  r]  Zindex_Zcols_rµ  rç  rV   rÐ   rW   r  	  sf    
ÿý



"
þ

zAppendableFrameTable.read)NNNN)rà   r­  r®  r¯  rQ  r…  rV  r*   rT  r°  r±  rÍ  rK  rì  r  rV   rV   rV   rW   r™  ö  s   
    ûr™  c                      st   e Zd ZdZdZdZdZeZe	ddœdd„ƒZ
edd	œd
d„ƒZdddœ‡ fdd„Zdddddœ‡ fdd„Z‡  ZS )r—  r  r�  rŽ  rV  rˆ   rÎ   c                 C  s   dS r	  rV   rÐ   rV   rV   rW   rÍ  f  s    z#AppendableSeriesTable.is_transposedrê  c                 C  s   |S r]   rV   rë  rV   rV   rW   rì  j  s    z AppendableSeriesTable.get_objectNrŒ   c                   s@   t |tƒs|jpd}| |¡}tƒ jf ||j ¡ dœ|¤Ž dS )ú+we are going to write this as a frame tabler]  ©r   r˜   N)rQ   r*   rb   Zto_framer  r¤  r¦   r  )rÌ   r   r˜   rº   rb   r  rV   rW   r¤  o  s    


zAppendableSeriesTable.writer‡   r0   rm  c                   s�   | j }|d urB|rBt| jtƒs"J ‚| jD ]}||vr(| d|¡ q(tƒ j||||d�}|rj|j| jdd� |jd d …df }|j	dkrŒd |_	|S )Nr   r,  Tr(  r]  )
rÆ  rQ   r–  rn   r  r  r  Ú	set_indexr  rb   )rÌ   rq   r¦   r¤   r¥   rÆ  rô   rU   r  rV   rW   r  v  s    

zAppendableSeriesTable.read)N)NNNN)rà   r­  r®  r¯  rQ  r…  rV  r0   rT  r±  rÍ  rK  rì  r¤  r  rL  rV   rV   r  rW   r—  ^  s   	    ûr—  c                      s.   e Zd ZdZdZdZddœ‡ fdd„Z‡  ZS )r˜  r  r�  r�  rŒ   rÎ   c                   sb   |j pd}|  |¡\}| _t| jtƒs*J ‚t| jƒ}| |¡ t|ƒ|_tƒ j	f d|i|¤Ž dS )r-  r]  r   N)
rb   rÇ  r–  rQ   rn   r“   r,   r¦   r  r¤  )rÌ   r   rº   rb   ZnewobjrM  r  rV   rW   r¤  –  s    



z AppendableMultiSeriesTable.write)rà   r­  r®  r¯  rQ  r…  r¤  rL  rV   rV   r  rW   r˜  �  s   r˜  c                   @  sp   e Zd ZU dZdZdZdZeZde	d< e
ddœd	d
„ƒZe
dd„ ƒZddœdd„Zedd„ ƒZddœdd„ZdS )r–  z:a table that read/writes the generic pytables table formatr†  r‡  rV  zlist[Hashable]r–  rZ   rÎ   c                 C  s   | j S r]   )rQ  rÐ   rV   rV   rW   rj  ª  s    zGenericTable.pandas_typec                 C  s   t | jdd ƒp| jS rÊ  rË  rÐ   rV   rV   rW   rf  ®  s    zGenericTable.storablerŒ   c                 C  sL   g | _ d| _g | _dd„ | jD ƒ| _dd„ | jD ƒ| _dd„ | jD ƒ| _dS )r€  Nc                 S  s   g | ]}|j r|‘qS rV   r×  r{  rV   rV   rW   rm   ¸  rõ   z*GenericTable.get_attrs.<locals>.<listcomp>c                 S  s   g | ]}|j s|‘qS rV   r×  r{  rV   rV   rW   rm   ¹  rõ   c                 S  s   g | ]
}|j ‘qS rV   ra   r{  rV   rV   rW   rm   º  rõ   )r)  rš   r–  rØ  r¼  r½  r˜   rÐ   rV   rV   rW   re  ²  s    zGenericTable.get_attrsc           
   
   C  s¨   | j }|  d¡}|durdnd}tdd| j||d�}|g}t|jƒD ]^\}}t|tƒsZJ ‚t||ƒ}|  |¡}|durzdnd}t	|||g|| j||d�}	| 
|	¡ qD|S )z0create the indexables from the table descriptionr•   Nr  r   )rb   r-  rw   r¾   r¾  )rb   r½  r]  r¼  rw   r¾   r¾  )ræ  r  r  rw   r•  Z_v_namesrQ   rZ   rm  rO  r“   )
rÌ   rJ  rÞ  r¾   rã  râ  r˜  rô   r!  rb  rV   rV   rW   rØ  ¼  s.    
ÿ

ù	zGenericTable.indexablesc                 K  s   t dƒ‚d S )Nz cannot write on an generic tablerj  )rÌ   rº   rV   rV   rW   r¤  à  s    zGenericTable.writeN)rà   r­  r®  r¯  rQ  r…  rV  r*   rT  r°  r±  rj  rf  re  r   rØ  r¤  rV   rV   rV   rW   r–  ¡  s   



#r–  c                      sf   e Zd ZdZdZeZdZe 	d¡Z
eddœdd„ƒZdd
dœ‡ fdd„Zddddœ‡ fdd„Z‡  ZS )rš  za frame with a multi-indexr‘  rV  z^level_\d+$rZ   rÎ   c                 C  s   dS )NZappendable_multirV   rÐ   rV   rV   rW   r¿  ì  s    z*AppendableMultiFrameTable.table_type_shortNrŒ   c                   s|   |d u rg }n|du r |j  ¡ }|  |¡\}| _t| jtƒs@J ‚| jD ]}||vrF| d|¡ qFtƒ jf ||dœ|¤Ž d S )NTr   r.  )	r¦   r  rÇ  r–  rQ   rn   r  r  r¤  )rÌ   r   r˜   rº   rô   r  rV   rW   r¤  ñ  s    

zAppendableMultiFrameTable.writer‡   ri  c                   sD   t ƒ j||||d�}| ˆ j¡}|j ‡ fdd„|jjD ƒ¡|_|S )Nr,  c                   s    g | ]}ˆ j  |¡rd n|‘qS r]   )Ú
_re_levelsÚsearch)ri   rb   rÐ   rV   rW   rm   	  rõ   z2AppendableMultiFrameTable.read.<locals>.<listcomp>)r  r  r/  r–  r•   r*  r—  )rÌ   rq   r¦   r¤   r¥   rµ  r  rÐ   rW   r  ý  s    ÿzAppendableMultiFrameTable.read)N)NNNN)rà   r­  r®  r¯  r…  r*   rT  rV  ÚreÚcompiler0  r±  r¿  r¤  r  rL  rV   rV   r  rW   rš  ä  s   
    ûrš  r*   rI   r,   )r   r-  r  r\   c                 C  s¢   |   |¡}t|ƒ}|d ur"t|ƒ}|d u s4| |¡rB| |¡rB| S t| ¡ ƒ}|d urlt| ¡ ƒj|dd�}| |¡sžtd d ƒg| j }|||< | jt|ƒ } | S )NF)Úsort)	r  r:   ÚequalsÚuniquer^  ÚslicerV  r_  ro   )r   r-  r  rË  r²  ZslicerrV   rV   rW   rô    s    

rô  r   zstr | tzinfo)r¹  r\   c                 C  s   t  | ¡}|S )z+for a tz-aware type, return an encoded zone)r   Zget_timezone)r¹  ÚzonerV   rV   rW   r�  )  s    
r�  znp.ndarray | Indexr+   )r]  r¹  r4  r\   c                 C  s   d S r]   rV   ©r]  r¹  r4  rV   rV   rW   rÞ  /  s    rÞ  rÔ  c                 C  s   d S r]   rV   r9  rV   rV   rW   rÞ  6  s    zstr | tzinfo | Noneznp.ndarray | DatetimeIndexc                 C  s’   t | tƒr0| jdu s"| j|ks"J ‚| jdur0| S |dur|t | tƒrJ| j}nd}|  ¡ } t|ƒ}t| |d�} |  d¡ |¡} n|rŽtj	| dd�} | 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
    Nra   rx  úM8[ns]r7  )
rQ   r+   r¹  rb   rD  rX   rz  r{  rR   rC  )r]  r¹  r4  rb   rV   rV   rW   rÞ  ;  s    


)rb   r•   r[   r™   r\   c              
   C  s‚  t | tƒsJ ‚|j}t|ƒ\}}t|ƒ}t |¡}t |j	d¡sTt
|j	ƒsTt|j	ƒrzt| |||t|dd ƒt|dd ƒ|d�S t |tƒrŒtdƒ‚tj|dd�}	t |¡}
|	dkrÞtjd	d
„ |
D ƒtjd�}t| |dtƒ  ¡ |d�S |	dk�rt|
||ƒ}|j	j}t| |dtƒ  |¡|d�S |	dv �r2t| ||||d�S t |tjƒ�rL|j	tk�sPJ ‚|dk�sbJ |ƒ‚tƒ  ¡ }t| ||||d�S d S )NÚiur¸  r¹  )r]  rg  r¼  r¸  r¹  rº  zMultiIndex not supported here!Fr¢  r   c                 S  s   g | ]}|  ¡ ‘qS rV   )Ú	toordinalr:  rV   rV   rW   rm   ˆ  rõ   z"_convert_index.<locals>.<listcomp>r7  )rº  rê  )ÚintegerZfloating)r]  rg  r¼  rº  rÉ  )rQ   rZ   rb   r  r  rM  r"  r   rÝ  rÚ  r$   r    rµ  rm  r-   r²   r¤  rR   rC  Zint32r„   Z	Time32ColÚ_convert_string_arrayrÀ  rë  rÙ  rÉ  r¥  )rb   r•   r[   r™   rº  rI  r  rg  r!  rª  r]  rÀ  rV   rV   rW   r�  b  s^    
ÿþý

ù


ÿ

û

ÿ
r�  )rg  r[   r™   r\   c                 C  sè   |  d¡r,|dkrt| ƒ}qät|  |¡ƒ}n¸|dkr>t| ƒ}n¦|dkr�ztjdd„ | D ƒtd�}W qä tyŒ   tjdd„ | D ƒtd�}Y qä0 nT|dv r¤t | ¡}n@|d	v r¾t| d ||d
�}n&|dkrÖt | d ¡}ntd|› �ƒ‚|S )Nr2  r5  r   c                 S  s   g | ]}t  |¡‘qS rV   r8  r:  rV   rV   rW   rm   ¯  rõ   z$_unconvert_index.<locals>.<listcomp>r7  c                 S  s   g | ]}t  |¡‘qS rV   r;  r:  rV   rV   rW   rm   ±  rõ   )r=  Úfloatrˆ   rê  rB  rÉ  r   zunrecognized index type )	ru  r+   r¦  r1   rR   rC  rÉ  r«   rH  )r|  rg  r[   r™   r•   rV   rV   rW   rž  ¢  s*    


 ÿrž  rH   rð   )rb   r"  r¦   c                 C  s’  |j tkr|S ttj|ƒ}|j j}tj|dd�}	|	dkr@tdƒ‚|	dkrPtdƒ‚|	dksd|dksd|S t	|ƒ}
| 
¡ }|||
< tj|dd�}	|	dkrøt|jd	 ƒD ]V}|| }tj|dd�}	|	dkr t|ƒ|krÖ|| nd
|› �}td|› d|	› d�ƒ‚q t|||ƒ |j¡}|j}t|tƒ�r>t| | ¡�p:| d¡�p:d	ƒ}t|�pHd	|ƒ}|d u�rz| |¡}|d u�rz||k�rz|}|jd|› �dd�}|S )NFr¢  r   z+[date] is not implemented as a table columnro  z>too many timezones in this block, create separate data columnsrê  rÉ  r   zNo.zCannot serialize the column [z2]
because its data contents are not [string] but [z] object dtyper]  z|Sr@  )rÚ  rÉ  r   rR   rÙ  rb   r   r¤  r²   r3   r}  rU  r  rp   r>  r  rÀ  rQ   rI  rd   rÖ   r  rð  rF  )rb   r"  rò  r–   rš   r[   r™   r¦   r  rª  rJ  r|  r˜  rç  Zerror_column_labelrþ  rÀ  ZecirV   rV   rW   r÷  ¿  sN    

ÿþÿ 

r÷  )r|  r[   r™   r\   c                 C  s`   t | ƒr,t|  ¡ dd�j ||¡j | j¡} t|  ¡ ƒ}t	dt
 |¡ƒ}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@  rg   ÚSr7  )rp   r0   rD  rZ   ÚencoderG  r  r  r   r  Ú
libwritersÚmax_len_string_arrayrR   rC  )r|  r[   r™   ÚensuredrÀ  rV   rV   rW   r>    s    ÿþÿr>  c                 C  sœ   | j }tj|  ¡ td�} t| ƒrzt t| ƒ¡}d|› �}t	| d t
ƒrbt| dd�jj||d�j} n| j|dd�jtdd�} |du r†d}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.
    r7  ÚUr   Fr@  )r™   Nrñ  )r  rR   rC  rD  rÉ  rp   rB  rC  r   rQ   r}  r0   rZ   rT   rG  rF  Z!string_array_replace_from_nan_repr  )r|  rš   r[   r™   r  rÀ  rÚ  rV   rV   rW   rH  '  s    
rH  )r]  rß  r[   r™   c                 C  s6   t |tƒsJ t|ƒƒ‚t|ƒr2t|||ƒ}|| ƒ} | S r]   )rQ   rZ   rß   Ú_need_convertÚ_get_converter)r]  rß  r[   r™   ÚconvrV   rV   rW   rÜ  M  s
    rÜ  ©rg  r[   r™   c                   sL   ˆdkrdd„ S dˆv r$‡fdd„S ˆdkr:‡ ‡fdd„S t dˆ› �ƒ‚d S )Nr2  c                 S  s   t j| dd�S )Nr:  r7  ©rR   rC  ©r'  rV   rV   rW   rž   W  rõ   z _get_converter.<locals>.<lambda>c                   s   t j| ˆ d�S )Nr7  rJ  rK  r  rV   rW   rž   Y  rõ   rê  c                   s   t | d ˆ ˆd�S )NrB  )rH  rK  rŒ  rV   rW   rž   [  s   ÿzinvalid kind )r«   rI  rV   )r[   r™   rg  rW   rG  U  s    rG  r%  c                 C  s   | dv sd| v rdS dS )N)r2  rê  r2  TFrV   r  rV   rV   rW   rF  b  s    rF  zSequence[int])rb   rW  r\   c                 C  sl   t |tƒst|ƒdk rtdƒ‚|d dkrh|d dkrh|d dkrht d| ¡}|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.r   rg   rU  rV  zvalues_block_(\d+)Zvalues_)rQ   rZ   rp   r«   r2  r1  r´   )rb   rW  r  ÚgrprV   rV   rW   rÛ  h  s    $
rÛ  )Ú	dtype_strr\   c                 C  sº   t | ƒ} |  d¡rd}nž|  d¡r(d}nŽ|  d¡r8d}n~|  d¡rHd}nn|  d¡rX| }n^|  d¡rhd	}nN|  d
¡rxd
}n>|  d¡rˆd}n.|  d¡r˜d}n| dkr¦d}ntd| › d�ƒ‚|S )zA
    Find the "kind" string describing the given dtype name.
    )rê  r}  rê  r?  rä  )rd   r&  r=  r2  Ú	timedeltar5  rˆ   r  r(  rÉ  zcannot interpret dtype of [r%  )rX   ru  r«   )rN  rg  rV   rV   rW   r  �  s.    








r  r  c                 C  sv   t | tƒr| j} t | jtƒr.d| jj› d�}n| jj}| jjdv rTt 	|  
d¡¡} nt | tƒrd| j} t 	| ¡} | |fS )zJ
    Convert the passed data into a storable form and a dtype string.
    r£  r%  ZmMr×  )rQ   r4   r  rÚ  r&   r¨  rb   rg  rR   rC  r¦  r.   r§  )r|  r  rV   rV   rW   r  ¢  s    


r  c                   @  s>   e Zd ZdZddddddœdd„Zd	d
„ Zdd„ Zdd„ ZdS )ræ  zæ
    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

    Nrø   r‡   rŒ   )rw   r¤   r¥   r\   c                 C  sV  || _ || _|| _|| _d | _d | _d | _d | _t|ƒ�rt	t
ƒ�È tj|dd�}|dv rüt |¡}|jtjkr®| j| j }}|d u rŠd}|d u rš| j j}t ||¡| | _nNt|jjtjƒrü| jd urÖ|| jk  ¡ sî| jd urö|| jk ¡ röt
dƒ‚|| _W d   ƒ n1 �s0    Y  | jd u �rR|  |¡| _| jd u�rR| j ¡ \| _| _d S )NFr¢  )r=  Úbooleanr   z3where must have index locations >= start and < stop)rw   rq   r¤   r¥   Ú	conditionr  Ztermsr2  r"   r   r«   r   r¤  rR   rC  rÚ  Zbool_r  r  Ú
issubclassrß   r=  rE  ÚgenerateÚevaluate)rÌ   rw   rq   r¤   r¥   ÚinferredrV   rV   rW   rÍ   Ç  sD    


ÿÿÿ&zSelection.__init__c              
   C  s‚   |du rdS | j  ¡ }zt||| j jd�W S  ty| } z:d | ¡ ¡}td|› d|› d�ƒ}t|ƒ|‚W Y d}~n
d}~0 0 dS )z'where can be a : dict,list,tuple,stringN)rÒ  r[   rÃ  z-                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
                )	rw   rÒ  r7   r[   Ú	NameErrorrÆ  rú   r   r«   )rÌ   rq   rÙ  rF  Zqkeysr  rV   rV   rW   rS  ô  s    
ÿûÿ	zSelection.generatec                 C  sX   | j dur(| jjj| j  ¡ | j| jd�S | jdurB| jj | j¡S | jjj| j| jd�S )ú(
        generate the selection
        Nri  )	rQ  rw   Z
read_wherer”   r¤   r¥   r2  r  r  rÐ   rV   rV   rW   r·     s    
ÿ
zSelection.selectc                 C  s”   | j | j }}| jj}|du r$d}n|dk r4||7 }|du rB|}n|dk rR||7 }| jdurx| jjj| j ¡ ||dd�S | jdurˆ| jS t 	||¡S )rW  Nr   T)r¤   r¥   r4  )
r¤   r¥   rw   r  rQ  Zget_where_listr”   r2  rR   r  )rÌ   r¤   r¥   r  rV   rV   rW   r    s"    
ÿ
zSelection.select_coords)NNN)rà   r­  r®  r¯  rÍ   rS  r·   r  rV   rV   rV   rW   ræ  »  s      û-ræ  )r…   NNFNTNNNNr~   rP   )	Nr£   r~   NNNNFN)N)F)F)F)´r¯  Ú
__future__r   Ú
contextlibr   r}  ro  r   r   r3  r¯   r2  Útextwrapr   Útypingr   r   r	   r
   r   r   r   rü  ÚnumpyrR   Zpandas._configr   r   r   r   Zpandas._libsr   r   rB  Zpandas._libs.libr   Zpandas._libs.tslibsr   Zpandas.compat._optionalr   Zpandas.compat.pickle_compatr   Zpandas.errorsr   r   r   r   r   Zpandas.util._decoratorsr   Zpandas.util._exceptionsr   Zpandas.core.dtypes.commonr   r    r!   r"   r#   r$   Zpandas.core.dtypes.dtypesr%   r&   r'   r(   Zpandas.core.dtypes.missingr)   rï   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   Zpandas.core.arraysr4   r5   r6   Zpandas.core.commonÚcoreÚcommonrC  Z pandas.core.computation.pytablesr7   r8   Zpandas.core.constructionr9   Zpandas.core.indexes.apir:   Zpandas.core.internalsr;   r<   Zpandas.io.commonr=   Zpandas.io.formats.printingr>   r?   Úcollections.abcr@   rA   rB   ÚtypesrC   r€   rD   rE   rF   Zpandas._typingrG   rH   rI   rJ   rK   rL   rM   rN   rO   ra  r^   rX   r`   rc   rh   rr   rs   r°  rt   ru   rƒ  rW  rz   r{   Zconfig_prefixZregister_optionZis_boolZis_one_of_factoryr   rƒ   r„   r¢   r»   rµ   r¡   r  rµ  r  r
  rM  rO  rP  rn  r“  r¬  r”  rø   r›  rî  r™  r—  r˜  r–  rš  rô  r�  rÞ  r�  rž  r÷  r>  rH  rÜ  rG  rF  rÛ  r  r  ræ  rV   rV   rV   rW   Ú<module>   s8  $	 0(
ü&            ñ,:         ö             (p  *   -  g#c       n dh1C, ÿ ÿ ÿ'@I&!