U
    ùQ”iÀž ã                   @  s"  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 ddlmZmZmZ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  dd
l!m"Z"m#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/m0Z0 ddl1m2Z2 ddl3m4Z4m5Z5m6Z6m7Z7m8Z8 ddl9m:Z: ddl;m<Z< ddl=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJ ddlKmLZL ddlMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZW ddlXmYZYmZZZm[Z[ ddl\m]  m^Z_ ddl`maZambZb ddlcmdZd ddlemfZf ddlgmhZhmiZi ddljmkZk ddllmmZmmnZn e�rZddlompZpmqZqmrZr ddlgmsZs dZtdZud d!„ Zvd"d#d$œd%d&„Zwd'd(„ ZxeaZyd)d*œd+d,„Zzd-Z{d.e|d/< d0Z}d.e|d1< d2Z~d.e|d3< d4d4d5d5d6œZeNdgiZ€d7Z�d.e|d8< d9Z‚d.e|d:< e ƒd;¡�8 ej„d<d=e�ej…d>� ej„d?de‚e †d4d5dg¡d>� W 5 Q R X da‡d=aˆd@dA„ Z‰d¼dEd#dFd#dGd"dHd"dHdIdJdKd#d#dLdMœdNdO„ZŠd½dEd#d#dQdGdGdRdHdGdSœ	dTdU„Z‹dVdVdHdWœdXdY„ZŒG dZd[„ d[ƒZ�G d\d]„ d]ƒZŽG d^d_„ d_ƒZ�G d`da„ dae�ƒZ�G dbdc„ dce�ƒZ‘G ddde„ dee‘ƒZ’G dfdg„ dge’ƒZ“G dhdi„ diƒZ”G djdk„ dke”ƒZ•G dldm„ dme•ƒ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 d¾d‚dƒd„d‚d…œd†d‡„Z¡dˆd‰dŠœd‹dŒ„Z¢ed¿d�d‰dHdŽd�œd�d‘„ƒZ£edÀd�dLdHd’d�œd“d‘„ƒZ£dÁd�d”dHd•d�œd–d‘„Z£d#d„d#d#d_d—œ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#dHd­œ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)ÚTracebackType)
ÚTYPE_CHECKINGÚAnyÚCallableÚFinalÚHashableÚIteratorÚLiteralÚSequenceÚcastÚoverload)ÚconfigÚ
get_option)ÚlibÚwriters)Ú	timezones)ÚAnyArrayLikeÚ	ArrayLikeÚAxisIntÚDtypeArgÚFilePathÚShapeÚnpt)Úimport_optional_dependency)Úpatch_pickle)ÚAttributeConflictWarningÚClosedFileErrorÚIncompatibilityWarningÚPerformanceWarningÚPossibleDataLossError)Úcache_readonly)Úfind_stack_level)Úensure_objectÚis_bool_dtypeÚis_categorical_dtypeÚis_complex_dtypeÚis_datetime64_dtypeÚis_datetime64tz_dtypeÚis_extension_array_dtypeÚis_integer_dtypeÚis_list_likeÚis_object_dtypeÚis_string_dtypeÚis_timedelta64_dtypeÚneeds_i8_conversion)Ú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)ÚColÚFileÚNode)ÚBlockz0.15.2úUTF-8c                 C  s   t | tjƒr|  d¡} | S )z(if we have bytes, decode them to unicoderO   )Ú
isinstanceÚnpZbytes_Údecode)Ús© rT   ú6/tmp/pip-unpacked-wheel-58ppya8e/pandas/io/pytables.pyÚ_ensure_decoded†   s    
rV   ú
str | NoneÚstr)ÚencodingÚreturnc                 C  s   | d krt } | S ©N)Ú_default_encoding©rY   rT   rT   rU   Ú_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
    )rP   rX   ©ÚnamerT   rT   rU   Ú_ensure_str•   s    
ra   Úint©Úscope_levelc                   sV   |d ‰ t | ttfƒr*‡ fdd„| D ƒ} nt| ƒr>t| ˆ d�} | dk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 k	rt |ƒr(t|ˆ d d�n|‘qS )Nre   rc   )rC   ÚTerm)Ú.0Zterm©ÚlevelrT   rU   Ú
<listcomp>¯   s   þz _ensure_term.<locals>.<listcomp>rc   N)rP   ÚlistÚtuplerC   rf   Úlen)Úwhererd   rT   rh   rU   Ú_ensure_term¤   s    	
þro   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)Úfrs   Útrt   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)Z	validatorÚdefault_formatc               	   C  s8   t d kr4dd l} | a ttƒ� | jjdkaW 5 Q R X t S )Nr   Ústrict)Ú
_table_modÚtablesr   ÚAttributeErrorÚfileZ_FILE_OPEN_POLICYÚ!_table_file_open_policy_is_strict)r|   rT   rT   rU   Ú_tablesè   s    

ÿr€   ÚaTrz   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ÚerrorsrY   rZ   c              
     s†   |r$‡ ‡‡‡‡‡‡‡‡‡	f
dd„}n‡ ‡‡‡‡‡‡‡‡‡	f
dd„}t | ƒ} t| tƒrzt| |||d��}||ƒ W 5 Q R X 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•   rY   )r�   ©Ústore©
r”   r“   rY   r•   r�   r‘   rŠ   r’   r–   r‹   rT   rU   Ú<lambda>  s   özto_hdf.<locals>.<lambda>c                   s   | j ˆˆ	ˆˆˆˆˆ ˆˆˆd�
S )N)r�   r‘   r’   r–   r”   r•   rY   r“   ©Úputr—   r™   rT   rU   rš     s   ö)rŒ   r�   rŽ   N)rH   rP   rX   ÚHDFStore)r‰   rŠ   r‹   rŒ   r�   rŽ   r�   r�   r‘   r’   r–   r“   r”   r•   rY   ru   r˜   rT   r™   rU   Úto_hdfþ   s     
   ÿrž   Úrzstr | list | Nonezlist[str] | None)	r‰   rŒ   r•   rn   ÚstartÚstopÚcolumnsÚiteratorÚ	chunksizec
                 K  sˆ  |dkrt d|› d�ƒ‚|dk	r,t|dd�}t| tƒrN| jsDtdƒ‚| }d}nvt| ƒ} t| tƒshtd	ƒ‚zt	j
 | ¡}W n tt fk
r”   d}Y nX |sªtd
| › d�ƒ‚t| f||dœ|
—Ž}d}zx|dk�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k
�r‚   t| tƒ�s|ttƒ� | ¡  W 5 Q R X ‚ Y nX 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.Nre   rc   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.)rn   r    r¡   r¢   r£   r¤   Ú
auto_close)Ú
ValueErrorro   rP   r�   Úis_openÚOSErrorrH   rX   ÚNotImplementedErrorÚosÚpathÚexistsÚ	TypeErrorÚFileNotFoundErrorÚgroupsrm   Ú_is_metadata_ofÚ_v_pathnameÚselectÚKeyErrorr   r}   Úclose)r‰   rŠ   rŒ   r•   rn   r    r¡   r¢   r£   r¤   Úkwargsr˜   r¦   r­   r°   Zcandidate_only_groupZgroup_to_checkrT   rT   rU   Úread_hdf6  sj    O
ÿ

ÿ

ÿÿø

r·   rM   )ÚgroupÚparent_grouprZ   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.Fre   ÚmetaT)Z_v_depthZ	_v_parentÚ_v_name)r¸   r¹   ÚcurrentÚparentrT   rT   rU   r±   Ñ  s    
r±   c                   @  s(  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.d/„Zd•dd1d2œd3d4„Zd5dœd6d7„Zd8dœd9d:„Zd–ddd;œd<d=„Zddœd>d?„Zed
dœd@dA„ƒZd—d
ddBœdCdD„ZddœdEdF„Zd˜dd
d
dGœdHdI„Zd™dd	d	dJœdKdL„Zdšddd	d	dMœdNdO„Zd›d
d
dPœdQdR„ZdœddUd
d
d	dVdWdd
d
ddXœdYdZ„Zd�dddœd[d\„Z džddUd]d
d	dVd^dWddd_œ
d`da„Z!dŸdbd
ddcœddde„Z"d dd	dfddgœdhdi„Z#djdœdkdl„Z$d¡ddndoœdpdq„Z%ddrdœdsdt„Z&ddudœdvdw„Z'd¢dd
d	d
d
d dyœdzd{„Z(ddœd|d}„Z)d~d„ Z*ddd€œd�d‚„Z+d£d„dddud…œd†d‡„Z,d¤ddUd]d
d	dVd
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�   aa	  
    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.
        As of v0.20.2 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Ú_handlerX   Ú_moder�   NFrƒ   r„   rˆ   )rŒ   r�   Ú
fletcher32rZ   c                 K  s²   d|krt dƒ‚tdƒ}|d k	r@||jjkr@t d|jj› d�ƒ‚|d krX|d k	rX|jj}t|ƒ| _|d k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_complibrH   Ú_pathr¿   r¾   Ú
_complevelÚ_complibÚ_fletcher32Ú_filtersÚopen)Úselfr¬   rŒ   r�   rŽ   rÀ   r¶   r|   rT   rT   rU   Ú__init__$  s&    	ÿ
zHDFStore.__init__©rZ   c                 C  s   | j S r[   ©rÂ   ©rÈ   rT   rT   rU   Ú
__fspath__E  s    zHDFStore.__fspath__c                 C  s   |   ¡  | jdk	st‚| jjS )zreturn the root nodeN)Ú_check_if_openr¾   ÚAssertionErrorÚrootrÌ   rT   rT   rU   rÐ   H  s    zHDFStore.rootc                 C  s   | j S r[   rË   rÌ   rT   rT   rU   ÚfilenameO  s    zHDFStore.filename©rŠ   c                 C  s
   |   |¡S r[   )Úget©rÈ   rŠ   rT   rT   rU   Ú__getitem__S  s    zHDFStore.__getitem__©rŠ   rZ   c                 C  s   |   ||¡ d S r[   r›   )rÈ   rŠ   r‹   rT   rT   rU   Ú__setitem__V  s    zHDFStore.__setitem__c                 C  s
   |   |¡S r[   )ÚremoverÔ   rT   rT   rU   Ú__delitem__Y  s    zHDFStore.__delitem__r_   c              	   C  sF   z|   |¡W S  ttfk
r$   Y nX tdt| ƒj› d|› d�ƒ‚dS )z$allow attribute access to get storesú'z' object has no attribute 'N)rÓ   r´   r!   r}   ÚtypeÚ__name__)rÈ   r`   rT   rT   rU   Ú__getattr__\  s    ÿzHDFStore.__getattr__c                 C  s4   |   |¡}|dk	r0|j}|||dd… fkr0dS dS )zx
        check for existence of this key
        can match the exact pathname or the pathnm w/o the leading '/'
        Nre   TF)Úget_noder²   )rÈ   rŠ   Únoder`   rT   rT   rU   Ú__contains__f  s    
zHDFStore.__contains__rb   c                 C  s   t |  ¡ ƒS r[   )rm   r°   rÌ   rT   rT   rU   Ú__len__r  s    zHDFStore.__len__c                 C  s   t | jƒ}t| ƒ› d|› d�S )Nú
File path: Ú
)rJ   rÂ   rÛ   )rÈ   ÚpstrrT   rT   rU   Ú__repr__u  s    
zHDFStore.__repr__c                 C  s   | S r[   rT   rÌ   rT   rT   rU   Ú	__enter__y  s    zHDFStore.__enter__ztype[BaseException] | NonezBaseException | NonezTracebackType | None)Úexc_typeÚ	exc_valueÚ	tracebackrZ   c                 C  s   |   ¡  d S r[   )rµ   )rÈ   rç   rè   ré   rT   rT   rU   Ú__exit__|  s    zHDFStore.__exit__Úpandasú	list[str])ÚincluderZ   c                 C  s^   |dkrdd„ |   ¡ D ƒS |dkrJ| jdk	s0t‚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.

                .. versionadded:: 1.1.0

        Returns
        -------
        list
            List of ABSOLUTE path-names (e.g. have the leading '/').

        Raises
        ------
        raises ValueError if kind has an illegal value
        rë   c                 S  s   g | ]
}|j ‘qS rT   ©r²   ©rg   ÚnrT   rT   rU   rj   ›  s     z!HDFStore.keys.<locals>.<listcomp>ZnativeNc                 S  s   g | ]
}|j ‘qS rT   rî   rï   rT   rT   rU   rj   Ÿ  s    ú/ÚTable)Ú	classnamez8`include` should be either 'pandas' or 'native' but is 'rÚ   )r°   r¾   rÏ   Z
walk_nodesr§   )rÈ   rí   rT   rT   rU   Úkeys„  s    ÿ
ÿzHDFStore.keyszIterator[str]c                 C  s   t |  ¡ ƒS r[   )Úiterrô   rÌ   rT   rT   rU   Ú__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È   ÚgrT   rT   rU   Úitems©  s    zHDFStore.items)rŒ   rZ   c                 K  sº   t ƒ }| j|krR| jdkr$|dkr$n(|dk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|Ž| _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|   ÚmsgrT   rT   rU   rÇ   °  s.    
ÿ  ÿ
ÿzHDFStore.openc                 C  s   | j dk	r| j  ¡  d| _ dS )z0
        Close the PyTables file handle
        N)r¾   rµ   rÌ   rT   rT   rU   rµ   Ý  s    

zHDFStore.closec                 C  s   | j dkrdS t| j jƒS )zF
        return a boolean indicating whether the file is open
        NF)r¾   r„   ZisopenrÌ   rT   rT   rU   r¨   å  s    
zHDFStore.is_open)ÚfsyncrZ   c              	   C  s@   | j dk	r<| j  ¡  |r<ttƒ� t | j  ¡ ¡ W 5 Q R X 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ý   rT   rT   rU   rþ   î  s
    


zHDFStore.flushc              
   C  sJ   t ƒ �: |  |¡}|dkr*td|› d�ƒ‚|  |¡W  5 Q R £ S Q R X dS )zÑ
        Retrieve pandas object stored in file.

        Parameters
        ----------
        key : str

        Returns
        -------
        object
            Same type as object stored in file.
        NúNo object named ú in the file)r   rÞ   r´   Ú_read_group©rÈ   rŠ   r¸   rT   rT   rU   rÓ     s
    
zHDFStore.get)rŠ   r£   r¦   c	                   st   |   |¡}	|	dkr"td|› d�ƒ‚t|dd�}|  |	¡‰ˆ ¡  ‡ ‡fdd„}
t| ˆ|
|ˆj|||||d�
}| ¡ S )	aÖ  
        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.
        Nr   r  re   rc   c                   s   ˆj | ||ˆ d�S )N)r    r¡   rn   r¢   ©Úread©Ú_startÚ_stopÚ_where©r¢   rS   rT   rU   ÚfuncQ  s    zHDFStore.select.<locals>.func©rn   Únrowsr    r¡   r£   r¤   r¦   )rÞ   r´   ro   Ú_create_storerÚ
infer_axesÚTableIteratorr  Ú
get_result)rÈ   rŠ   rn   r    r¡   r¢   r£   r¤   r¦   r¸   r  ÚitrT   r
  rU   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
        re   rc   z&can only read_coordinates with a table©rn   r    r¡   )ro   Ú
get_storerrP   rò   r®   Úread_coordinates)rÈ   rŠ   rn   r    r¡   ÚtblrT   rT   rU   Úselect_as_coordinatesd  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  rP   rò   r®   Úread_column)rÈ   rŠ   r  r    r¡   r  rT   rT   rU   Úselect_column„  s    #

zHDFStore.select_column)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krˆ|d }‡fdd	„|D ƒ‰ˆ 	|¡}
d}t
 |
|fgtˆ|ƒ¡D ]\\}}|dkràtd
|› d�ƒ‚|jsøtd|j› d�ƒ‚|dk�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
        re   rc   r   )rŠ   rn   r¢   r    r¡   r£   r¤   r¦   zkeys must be a list/tuplez keys must have a non-zero lengthNc                   s   g | ]}ˆ   |¡‘qS rT   )r  ©rg   ÚkrÌ   rT   rU   rj   ð  s     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 rT   )rP   rò   ©rg   ÚxrT   rT   rU   rj     s     
 c                 S  s   h | ]}|j d  d  ’qS ©r   )Únon_index_axes©rg   rv   rT   rT   rU   Ú	<setcomp>  s     z.HDFStore.select_as_multiple.<locals>.<setcomp>c                   s*   ‡ ‡‡‡fdd„ˆD ƒ}t |ˆdd� ¡ S )Nc                   s   g | ]}|j ˆˆˆ ˆd �‘qS )©rn   r¢   r    r¡   r  r$  )r  r  r	  r¢   rT   rU   rj     s   ÿz=HDFStore.select_as_multiple.<locals>.func.<locals>.<listcomp>F)ÚaxisÚverify_integrity)r=   Ú_consolidate)r  r  r	  Úobjs)r'  r¢   Útblsr  rU   r  
  s    þz)HDFStore.select_as_multiple.<locals>.funcr  T©Úcoordinates)ro   rP   rk   rl   rm   rX   r³   r®   r§   r  Ú	itertoolsÚchainÚzipr´   Úis_tableÚpathnamer  Úpopr  r  )rÈ   rô   rn   Úselectorr¢   r    r¡   r£   r¤   r¦   rS   r  rv   r  Z_tblsr  r  rT   )r'  r¢   rÈ   r+  rU   Úselect_as_multiple¬  sd    +
ø
 ÿ


özHDFStore.select_as_multipleTrz   r‚   r…   r‡   )rŠ   r‹   r‘   r�   r�   r’   r”   r•   Útrack_timesr“   rZ   c                 C  sH   |dk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.

            .. versionadded:: 1.1.0
        Núio.hdf.default_formatrs   )r�   r‘   r�   rŽ   r�   r’   r–   r”   rY   r•   r6  r“   )r   Ú_validate_formatÚ_write_to_group)rÈ   rŠ   r‹   r�   r‘   r�   rŽ   r�   r’   r–   r”   rY   r•   r6  r“   rT   rT   rU   rœ   %  s&    4
òzHDFStore.putc              
   C  sà   t |dd�}z|  |¡}W n„ tk
r0   ‚ Y np tk
rD   ‚ Y n\ tk
rž } z>|dk	rftdƒ|‚|  |¡}|dk	rŽ|jdd� W Y ¢dS W 5 d}~X Y nX 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

        re   rc   Nz5trying to remove a node with a non-None where clause!T©Ú	recursivez7can only remove with where on objects written as tablesr  )ro   r  r´   rÏ   Ú	Exceptionr§   rÞ   Z	_f_removeÚcomÚall_noner¸   r1  Údelete)rÈ   rŠ   rn   r    r¡   rS   Úerrrß   rT   rT   rU   rØ   m  s2    ÿþ
ÿzHDFStore.removezbool | list[str]r†   )
rŠ   r‹   r‘   r�   r�   r’   r“   r”   r•   rZ   c                 C  sl   |	dk	rt dƒ‚|dkr tdƒ}|dk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
        Nz>columns is not a supported keyword in append, try data_columnszio.hdf.dropna_tabler7  rt   )r�   Úaxesr‘   r�   rŽ   r�   r’   r–   r¤   Úexpectedrowsr“   r”   rY   r•   )r®   r   r8  r9  )rÈ   rŠ   r‹   r�   rA  r‘   r�   rŽ   r�   r¢   r’   r–   r¤   rB  r“   r”   rY   r•   rT   rT   rU   r�   ¦  s6    ;ÿ
ðzHDFStore.appendÚdict)Údr“   rZ   c                   s¬  |dk	rt dƒ‚t|tƒs"tdƒ‚||kr2tdƒ‚tttˆjƒƒttt	ˆƒ ƒ ƒd }d}	g }
| 
¡ D ]0\}‰ ˆ dkrŽ|	dk	rˆtdƒ‚|}	qh|
 ˆ ¡ qh|	dk	rÖˆj| }| t|
ƒ¡}t| |¡ƒ}| |¡||	< |dkræ|| }|�r*‡fdd„| ¡ D ƒ}t|ƒ}|D ]}| |¡}�qˆj| ‰| d	d¡}| 
¡ D ]h\}‰ ||k�rT|nd}ˆjˆ |d
�}|dk	�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 dictr   z<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‘   )rg   Úcols)r‹   rT   rU   Ú	<genexpr>I  s     z.HDFStore.append_to_multiple.<locals>.<genexpr>r’   ©r'  c                   s   i | ]\}}|ˆ kr||“qS rT   rT   ©rg   rŠ   r‹   )ÚvrT   rU   Ú
<dictcomp>Y  s       z/HDFStore.append_to_multiple.<locals>.<dictcomp>)r”   r’   )r®   rP   rC  r§   rk   ÚsetÚrangeÚndimÚ	_AXES_MAPrÛ   rø   ÚextendrA  Ú
differencer7   ÚsortedÚget_indexerÚtakeÚvaluesÚnextÚintersectionÚlocr3  Úreindexr�   )rÈ   rD  r‹   r4  r”   rA  r“   r¶   r'  Z
remain_keyZremain_valuesr  ÚorderedZorddZidxsZvalid_indexr‘   r’   ÚdcÚvalÚfilteredrT   )rK  r‹   rU   Úappend_to_multipleþ  sZ    ÿ
ÿÿ&ÿ

ÿýzHDFStore.append_to_multiplerW   )rŠ   ÚoptlevelÚkindrZ   c                 C  sB   t ƒ  |  |¡}|dk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¢   r`  ra  )r€   r  rP   rò   r®   Úcreate_index)rÈ   rŠ   r¢   r`  ra  rS   rT   rT   rU   Úcreate_table_index_  s    

zHDFStore.create_table_indexrk   c                 C  s<   t ƒ  |  ¡  | jdk	st‚tdk	s(t‚dd„ | j ¡ D ƒS )zÂ
        Return a list of all the top-level nodes.

        Each node returned is not a pandas storage object.

        Returns
        -------
        list
            List of objects.
        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_typeNrt   )	rP   r{   ÚlinkÚLinkÚgetattrÚ_v_attrsrt   rò   r»   )rg   r÷   rT   rT   rU   rj   –  s    
ùz#HDFStore.groups.<locals>.<listcomp>)r€   rÎ   r¾   rÏ   r{   Úwalk_groupsrÌ   rT   rT   rU   r°   ‡  s    þzHDFStore.groupsrñ   z*Iterator[tuple[str, list[str], list[str]]])rn   rZ   c                 c  s¼   t ƒ  |  ¡  | jdk	st‚tdk	s(t‚| j |¡D ]‚}t|jddƒdk	rLq4g }g }|j 	¡ D ]B}t|jddƒ}|dkr”t
|tjjƒr | |j¡ q^| |j¡ q^|j d¡||fV  q4dS )aS  
        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`.
        Nrd  rñ   )r€   rÎ   r¾   rÏ   r{   ri  rg  rh  Z_v_childrenrV  rP   r¸   ÚGroupr�   r»   r²   Úrstrip)rÈ   rn   r÷   r°   ZleavesÚchildrd  rT   rT   rU   Úwalk£  s     zHDFStore.walkzNode | Nonec                 C  s€   |   ¡  | d¡sd| }| jdk	s(t‚tdk	s4t‚z| j | j|¡}W n tjjk
rb   Y dS X t	|tj
ƒs|tt|ƒƒ‚|S )z9return the node with the key or None if it does not existrñ   N)rÎ   Ú
startswithr¾   rÏ   r{   rÞ   rÐ   Ú
exceptionsZNoSuchNodeErrorrP   rM   rÛ   )rÈ   rŠ   rß   rT   rT   rU   rÞ   Ó  s    
zHDFStore.get_nodeúGenericFixed | Tablec                 C  s8   |   |¡}|dk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¸   rS   rT   rT   rU   r  ã  s    

zHDFStore.get_storerrù   )rŒ   Úpropindexesr�   rÀ   Ú	overwriterZ   c	              	   C  sÎ   t |||||d�}	|dkr&t|  ¡ ƒ}t|ttfƒs:|g}|D ]Š}
|  |
¡}|dk	r>|
|	k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 rT   )Ú
is_indexedr`   ©rg   r�   rT   rT   rU   rj     s      z!HDFStore.copy.<locals>.<listcomp>r”   )r‘   r”   rY   r]   )r�   rk   rô   rP   rl   r  rØ   r³   rò   rA  r�   rg  rY   rœ   )rÈ   r~   rŒ   rq  rô   rŽ   r�   rÀ   rr  Z	new_storer  rS   Údatar‘   rT   rT   rU   Úcopyí  s>        ÿ




ûzHDFStore.copyc           
      C  s
  t | jƒ}t| ƒ› d|› d�}| jrþt|  ¡ ƒ}t|ƒrôg }g }|D ]œ}z<|  |¡}|dk	r‚| t |j	pj|ƒ¡ | t |p|dƒ¡ W qD t
k
rš   ‚ Y qD tk
rÞ } z(| |¡ t |ƒ}	| d|	› d�¡ W 5 d}~X Y qDX qD|td||ƒ7 }n|d7 }n|d	7 }|S )
zg
        Print detailed information on the store.

        Returns
        -------
        str
        râ   rã   Nzinvalid_HDFStore nodez[invalid_HDFStore node: r  é   ÚEmptyzFile is CLOSED)rJ   rÂ   rÛ   r¨   rS  rô   rm   r  r�   r2  rÏ   r<  rI   )
rÈ   r¬   ÚoutputZlkeysrô   rV  r  rS   ZdetailZdstrrT   rT   rU   Úinfo(  s.    


&
zHDFStore.infoc                 C  s   | j st| j› d�ƒ‚d S )Nz file is not open!)r¨   r!   rÂ   rÌ   rT   rT   rU   rÎ   R  s    zHDFStore._check_if_open)r�   rZ   c              
   C  sJ   zt | ¡  }W n4 tk
rD } ztd|› d�ƒ|‚W 5 d}~X Y nX |S )zvalidate / deprecate formatsz#invalid HDFStore format specified [r  N)Ú_FORMAT_MAPÚlowerr´   r®   )rÈ   r�   r@  rT   rT   rU   r8  V  s
    $zHDFStore._validate_formatrO   zDataFrame | Series | None)r‹   rY   r•   rZ   c              
   C  s:  |dk	rt |ttfƒstdƒ‚tt|jddƒƒ}tt|jddƒƒ}|dkr¶|dkr’tƒ  tdk	sdt	‚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|k�r,ttdœ}z|| }	W nD tk
�r }
 z$td|› dt|ƒ› d|› �ƒ|
‚W 5 d}
~
X Y nX |	| |||d�S |dk�rÆ|dk	�rÆ|dk�r„t|ddƒ}|dk	�rÆ|jdk�rrd}n|jdk�rÆd}nB|dk�rÆt|ddƒ}|dk	�rÆ|jdk�r¶d}n|jdk�rÆd}ttttttdœ}z|| }	W nD tk
�r( }
 z$td|› dt|ƒ› d|› �ƒ|
‚W 5 d}
~
X Y nX |	| |||d�S )z"return a suitable class to operateNz(value must be None, Series, or DataFramerd  Ú
table_typert   Úframe_tableÚgeneric_tablezKcannot create a storer if the object is not existing nor a value are passedÚseriesÚframeZ_table)r€  r�  z=cannot properly create the storer for: [_STORER_MAP] [group->ú,value->z	,format->©rY   r•   Úseries_tabler‘   re   Úappendable_seriesÚappendable_multiseriesÚappendable_frameÚappendable_multiframe)r  r…  r†  r‡  rˆ  Úwormz<cannot properly create the storer for: [_TABLE_MAP] [group->)rP   r;   r5   r®   rV   rg  rh  r€   r{   rÏ   rt   rò   ÚSeriesFixedÚ
FrameFixedr´   rÛ   ÚnlevelsÚGenericTableÚAppendableSeriesTableÚAppendableMultiSeriesTableÚAppendableFrameTableÚAppendableMultiFrameTableÚ	WORMTable)rÈ   r¸   r�   r‹   rY   r•   ÚptÚttZ_STORER_MAPÚclsr@  r‘   Z
_TABLE_MAPrT   rT   rU   r  `  s‚     ÿÿ


ÿý





úÿýzHDFStore._create_storer)
rŠ   r‹   r‘   r�   r�   r’   r“   r•   r6  rZ   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Úemptyrt   rƒ  rs   zCan only append to Tablesz0Compression not supported on Fixed format stores)ÚobjrA  r�   rŽ   r�   rÀ   r’   r¤   rB  r“   r–   r”   r6  )r¢   )rg  Ú_identify_groupr  r1  Ú	is_existsr§   Úset_object_infoÚwriterP   rò   rb  )rÈ   rŠ   r‹   r�   rA  r‘   r�   rŽ   r�   rÀ   r’   r¤   rB  r“   r–   r”   rY   r•   r6  r¸   rS   rT   rT   rU   r9  »  s:    

ózHDFStore._write_to_grouprM   ©r¸   c                 C  s   |   |¡}| ¡  | ¡ S r[   )r  r  r  )rÈ   r¸   rS   rT   rT   rU   r  ù  s    
zHDFStore._read_group)rŠ   r�   rZ   c                 C  sN   |   |¡}| jdk	st‚|dk	r8|s8| jj|dd� d}|dkrJ|  |¡}|S )z@Identify HDF5 group based on key, delete/create group if needed.NTr:  )rÞ   r¾   rÏ   Úremove_nodeÚ_create_nodes_and_group)rÈ   rŠ   r�   r¸   rT   rT   rU   r˜  þ  s    

zHDFStore._identify_groupc                 C  sv   | j dk	st‚| d¡}d}|D ]P}t|ƒs.q |}| d¡sD|d7 }||7 }|  |¡}|dkrl| j  ||¡}|}q |S )z,Create nodes from key and return group name.Nrñ   )r¾   rÏ   Úsplitrm   ÚendswithrÞ   Zcreate_group)rÈ   rŠ   Úpathsr¬   ÚpÚnew_pathr¸   rT   rT   rU   rž    s    


z HDFStore._create_nodes_and_group)r�   NNF)rë   )r�   )F)NNNNFNF)NNN)NN)NNNNNFNF)NTFNNNNNNrz   TF)NNN)NNTTNNNNNNNNNNrz   )NNF)NNN)rñ   )rù   TNNNFT)NNrO   rz   )NTFNNNNNNFNNNrz   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  r5  rœ   rØ   r�   r_  rc  r°   rm  rÞ   r  rv  rz  rÎ   r8  r  r9  r  r˜  rž  rT   rT   rT   rU   r�   ß  s  
A    ú!

"-       ÷N   û$  û+        ö}            ñ$H=               î"]   ùd   û(0       ÷;*    ú`               í">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˜   rp  rS   NFr„   rˆ   )r˜   rS   r£   r¤   r¦   rZ   c                 C  sš   || _ || _|| _|| _| jjrN|d kr,d}|d kr8d}|d krD|}t||ƒ}|| _|| _|| _d | _	|sr|	d k	rŠ|	d kr~d}	t
|	ƒ| _nd | _|
| _d S )Nr   é † )r˜   rS   r  rn   r1  Úminr  r    r¡   r-  rb   r¤   r¦   )rÈ   r˜   rS   r  rn   r  r    r¡   r£   r¤   r¦   rT   rT   rU   rÉ   >  s,    
zTableIterator.__init__r   rÊ   c                 c  sv   | j }| jd krtdƒ‚|| jk rjt|| j | jƒ}|  d d | j||… ¡}|}|d kst|ƒsbq|V  q|  ¡  d S )Nz*Cannot iterate until get_result is called.)	r    r-  r§   r¡   rª  r¤   r  rm   rµ   )rÈ   r¼   r¡   r‹   rT   rT   rU   rö   h  s    

zTableIterator.__iter__c                 C  s   | j r| j ¡  d S r[   )r¦   r˜   rµ   rÌ   rT   rT   rU   rµ   x  s    zTableIterator.closer,  c                 C  sŠ   | j d k	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)rn   z$can only read_coordinates on a tabler  )r¤   rP   rS   rò   r®   r  rn   r-  r    r¡   r  rµ   )rÈ   r-  rn   ÚresultsrT   rT   rU   r  |  s"    
  ÿzTableIterator.get_result)NNFNF)F)	rÜ   r¤  r¥  r¦  r§  rÉ   rö   rµ   r  rT   rT   rT   rU   r  &  s   
	     õ*r  c                   @  s¨  e Zd ZU dZdZded< dZded< dddgZdMd
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	d0d1„ ƒZd2dœd3d4„ZdNddœd5d6„Zddœd7d8„Zd9ddd:œd;d<„ZdOd=d>„Zddd?œd@dA„ZddœdBdC„ZddœdDdE„ZddœdFdG„Zd9ddHœdIdJ„Z d9ddHœdKdL„Z!d	S )PÚ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_nameNrX   rW   rˆ   )r`   ÚcnamerZ   c                 C  s    t |tƒstdƒ‚|| _|| _|| _|| _|p0|| _|| _|| _	|| _
|	| _|
| _|| _|| _|| _|| _|d k	r||  |¡ t | jtƒsŒt‚t | jtƒsœt‚d S )Nz`name` must be a str.)rP   rX   r§   rV  ra  Útypr`   r²  r'  Úposr¯  r°  r±  r[  rt   rº   ÚmetadataÚset_posrÏ   )rÈ   r`   rV  ra  r³  r²  r'  r´  r¯  r°  r±  r[  rt   rº   rµ  rT   rT   rU   rÉ   ¨  s(    


zIndexCol.__init__rb   rÊ   c                 C  s   | j jS r[   )r³  ÚitemsizerÌ   rT   rT   rU   r·  Ó  s    zIndexCol.itemsizec                 C  s   | j › d�S )NÚ_kindr_   rÌ   rT   rT   rU   Ú	kind_attrØ  s    zIndexCol.kind_attr)r´  rZ   c                 C  s$   || _ |dk	r | jdk	r || j_dS )z,set the position of this column in the TableN)r´  r³  Z_v_pos)rÈ   r´  rT   rT   rU   r¶  Ü  s    zIndexCol.set_posc              	   C  sF   t tt| j| j| j| j| jfƒƒ}d dd„ t	dddddg|ƒD ƒ¡S )	Nú,c                 S  s   g | ]\}}|› d |› �‘qS ©z->rT   rJ  rT   rT   rU   rj   ç  s   ÿz%IndexCol.__repr__.<locals>.<listcomp>r`   r²  r'  r´  ra  )
rl   ÚmaprJ   r`   r²  r'  r´  ra  Újoinr0  ©rÈ   ÚtemprT   rT   rU   rå   â  s    ÿþÿzIndexCol.__repr__r	   ©ÚotherrZ   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[   ©rg  rt  ©rÁ  rÈ   rT   rU   rH  ï  s   ÿz"IndexCol.__eq__.<locals>.<genexpr>)r`   r²  r'  r´  ©rE  ©rÈ   rÁ  rT   rÄ  rU   Ú__eq__í  s    þzIndexCol.__eq__c                 C  s   |   |¡ S r[   )rÇ  rÆ  rT   rT   rU   Ú__ne__ô  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 columnrG  F)Úhasattrrt   rg  rG  r²  rs  rÌ   rT   rT   rU   rs  ÷  s    zIndexCol.is_indexedú
np.ndarrayz3tuple[np.ndarray, np.ndarray] | tuple[Index, Index]©rV  rY   r•   rZ   c           
      C  s  t |tjƒstt|ƒƒ‚|jjdk	r2|| j  ¡ }t	| j
ƒ}t||||ƒ}i }t	| jƒ|d< | jdk	rtt	| jƒ|d< t}t|jƒsŒt|jƒr’t}n|jdkr¬d|kr¬dd„ }z||f|Ž}W n0 tk
rì   d|krÜd|d< ||f|Ž}Y nX t|| jƒ}	|	|	fS )zV
        Convert the data from this selection to the appropriate pandas type.
        Nr`   r¯  Úi8c                 [  s   t f d| i|—ŽS )NZordinal)r9   )r!  ÚkwdsrT   rT   rU   rš     s   ÿÿz"IndexCol.convert.<locals>.<lambda>)rP   rQ   ÚndarrayrÏ   rÛ   ÚdtypeÚfieldsr²  rv  rV   ra  Ú_maybe_convertr±  r¯  r7   r+   r,   r6   r§   Ú_set_tzr°  )
rÈ   rV  r–   rY   r•   Úval_kindr¶   ÚfactoryZnew_pd_indexZfinal_pd_indexrT   rT   rU   Úconvertÿ  s,    

zIndexCol.convertc                 C  s   | j S )zreturn the values©rV  rÌ   rT   rT   rU   Ú	take_data.  s    zIndexCol.take_datac                 C  s   | j jS r[   )rt   rh  rÌ   rT   rT   rU   Úattrs2  s    zIndexCol.attrsc                 C  s   | j jS r[   ©rt   ÚdescriptionrÌ   rT   rT   rU   rÚ  6  s    zIndexCol.descriptionc                 C  s   t | j| jdƒS )z!return my current col descriptionN)rg  rÚ  r²  rÌ   rT   rT   rU   Úcol:  s    zIndexCol.colc                 C  s   | j S ©zreturn my cython valuesrÖ  rÌ   rT   rT   rU   Úcvalues?  s    zIndexCol.cvaluesr   c                 C  s
   t | jƒS r[   )rõ   rV  rÌ   rT   rT   rU   rö   D  s    zIndexCol.__iter__c                 C  sP   t | jƒdkrLt|tƒr$| | j¡}|dk	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´  )rV   ra  rP   rC  rÓ   r`   r³  r·  r€   Ú	StringColr´  )rÈ   r’   rT   rT   rU   Úmaybe_set_sizeG  s
    
zIndexCol.maybe_set_sizec                 C  s   d S r[   rT   rÌ   rT   rT   rU   Úvalidate_namesT  s    zIndexCol.validate_namesÚAppendableTable)Úhandlerr�   rZ   c                 C  s:   |j | _ |  ¡  |  |¡ |  |¡ |  |¡ |  ¡  d S r[   )rt   Úvalidate_colÚvalidate_attrÚvalidate_metadataÚwrite_metadataÚset_attr)rÈ   rã  r�   rT   rT   rU   Úvalidate_and_setW  s    


zIndexCol.validate_and_setc                 C  s^   t | jƒdkrZ| j}|dk	rZ|dk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)rV   ra  rÛ  r·  r§   r²  )rÈ   r·  ÚcrT   rT   rU   rä  _  s    
ÿzIndexCol.validate_col)r�   rZ   c                 C  sB   |r>t | j| jd ƒ}|d k	r>|| jkr>td|› d| j› d�ƒ‚d S )Nzincompatible kind in col [ú - r  )rg  rØ  r¹  ra  r®   )rÈ   r�   Zexisting_kindrT   rT   rU   rå  r  s    ÿzIndexCol.validate_attrc                 C  sÈ   | j D ]¼}t| |dƒ}| | ji ¡}| |¡}||krª|dk	rª||krª|dkr„t|||f }tj|tt	ƒ d� d||< t
| |dƒ qÂtd| j› d|› d|› d|› d�	ƒ‚q|dk	sº|dk	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_fieldsrg  Ú
setdefaultr`   rÓ   rq   ÚwarningsÚwarnr    r&   Úsetattrr§   )rÈ   rz  rŠ   r‹   ÚidxZexisting_valueÚwsrT   rT   rU   Úupdate_info{  s&    

  ÿÿzIndexCol.update_infoc                 C  s$   |  | j¡}|dk	r | j |¡ dS )z!set my state from the passed infoN)rÓ   r`   Ú__dict__Úupdate)rÈ   rz  ró  rT   rT   rU   Ú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¹  ra  rÌ   rT   rT   rU   rè  ¡  s    zIndexCol.set_attr)rã  rZ   c                 C  sB   | j dkr>| j}| | j¡}|dk	r>|dk	r>t||ƒs>tdƒ‚dS )z:validate that kind=category does not change the categoriesÚcategoryNzEcannot append a categorical with different categories to the existing)rº   rµ  Úread_metadatar²  r4   r§   )rÈ   rã  Znew_metadataZcur_metadatarT   rT   rU   ræ  ¥  s    
ÿþýÿzIndexCol.validate_metadatac                 C  s   | j dk	r| | j| j ¡ dS )zset the meta dataN)rµ  rç  r²  )rÈ   rã  rT   rT   rU   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È  rs  rÕ  r×  rØ  rÚ  rÛ  rÝ  rö   rà  rá  ré  rä  rå  rõ  rø  rè  ræ  rç  rT   rT   rT   rU   r¬  –  sb   

             ñ+/




	 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 ©NFrT   rÌ   rT   rT   rU   rs  ½  s    zGenericIndexCol.is_indexedrÊ  rX   ztuple[Index, Index]rË  c                 C  s,   t |tjƒst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
        )rP   rQ   rÎ  rÏ   rÛ   r:   rm   )rÈ   rV  r–   rY   r•   r‘   rT   rT   rU   rÕ  Á  s    zGenericIndexCol.convertrˆ   c                 C  s   d S r[   rT   rÌ   rT   rT   rU   rè  Ó  s    zGenericIndexCol.set_attrN)rÜ   r¤  r¥  r¦  r¨  rs  rÕ  rè  rT   rT   rT   rU   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°  r[  NrX   rW   zDtypeArg | Nonerˆ   )r`   r²  rÏ  rZ   c                   s2   t ƒ j|||||||||	|
|d� || _|| _d S )N)r`   rV  ra  r³  r´  r²  r°  r[  rt   rº   rµ  )ÚsuperrÉ   rÏ  ru  )rÈ   r`   rV  ra  r³  r²  r´  r°  r[  rt   rº   rµ  rÏ  ru  ©Ú	__class__rT   rU   rÉ   è  s    õzDataCol.__init__rÊ   c                 C  s   | j › d�S )NÚ_dtyper_   rÌ   rT   rT   rU   Ú
dtype_attr	  s    zDataCol.dtype_attrc                 C  s   | j › d�S )NÚ_metar_   rÌ   rT   rT   rU   Ú	meta_attr	  s    zDataCol.meta_attrc              	   C  sF   t tt| j| j| j| j| jfƒƒ}d dd„ t	dddddg|ƒD ƒ¡S )	Nrº  c                 S  s   g | ]\}}|› d |› �‘qS r»  rT   rJ  rT   rT   rU   rj   	  s   ÿz$DataCol.__repr__.<locals>.<listcomp>r`   r²  rÏ  ra  Úshape)
rl   r¼  rJ   r`   r²  rÏ  ra  r  r½  r0  r¾  rT   rT   rU   rå   	  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Ã  rt  rÄ  rT   rU   rH  	  s   ÿz!DataCol.__eq__.<locals>.<genexpr>)r`   r²  rÏ  r´  rÅ  rÆ  rT   rÄ  rU   rÇ  	  s    þzDataCol.__eq__r   )ru  rZ   c                 C  s@   |d k	st ‚| jd kst ‚t|ƒ\}}|| _|| _t|ƒ| _d S r[   )rÏ   rÏ  Ú_get_data_and_dtype_nameru  Ú_dtype_to_kindra  )rÈ   ru  Ú
dtype_namerT   rT   rU   Úset_data$	  s    zDataCol.set_datac                 C  s   | j S )zreturn the data©ru  rÌ   rT   rT   rU   r×  .	  s    zDataCol.take_datarK   )rV  rZ   c                 C  sÂ   |j }|j}|j}|jdkr&d|jf}t|tƒrJ|j}| j||j j	d�}ntt
|ƒsZt|ƒrf|  |¡}nXt|ƒrz|  |¡}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.
        re   ©ra  r   ©r·  r  )rÏ  r·  r  rO  ÚsizerP   r?   ÚcodesÚget_atom_datar`   r+   r,   Úget_atom_datetime64r2   Úget_atom_timedelta64r*   r€   Z
ComplexColr1   Úget_atom_string)r•  rV  rÏ  r·  r  r  ÚatomrT   rT   rU   Ú	_get_atom2	  s$    


zDataCol._get_atomc                 C  s   t ƒ j||d d�S )Nr   r  ©r€   rß  ©r•  r  r·  rT   rT   rU   r  R	  s    zDataCol.get_atom_stringz	type[Col]©ra  rZ   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UIntrK   ÚperiodÚInt64Col)rn  Ú
capitalizerg  r€   )r•  ra  Zk4Zcol_nameZkcaprT   rT   rU   Úget_atom_coltypeV	  s    


zDataCol.get_atom_coltypec                 C  s   | j |d�|d d�S )Nr  r   ©r  ©r  ©r•  r  ra  rT   rT   rU   r  e	  s    zDataCol.get_atom_datac                 C  s   t ƒ j|d d�S ©Nr   r  ©r€   r  ©r•  r  rT   rT   rU   r  i	  s    zDataCol.get_atom_datetime64c                 C  s   t ƒ j|d d�S r!  r"  r#  rT   rT   rU   r  m	  s    zDataCol.get_atom_timedelta64c                 C  s   t | jdd ƒS )Nr  )rg  ru  rÌ   rT   rT   rU   r  q	  s    zDataCol.shapec                 C  s   | j S rÜ  r
  rÌ   rT   rT   rU   rÝ  u	  s    zDataCol.cvaluesc                 C  s`   |r\t | j| jdƒ}|dk	r2|t| jƒkr2tdƒ‚t | j| jdƒ}|dk	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!)rg  rØ  r¹  rk   rV  r§   r  rÏ  )rÈ   r�   Zexisting_fieldsZexisting_dtyperT   rT   rU   rå  z	  s    ÿzDataCol.validate_attrrÊ  )rV  rY   r•   c                 C  s  t |tjƒstt|ƒƒ‚|jjdk	r.|| j }| jdk	s<t‚| jdkr\t	|ƒ\}}t
|ƒ}n|}| j}| j}t |tjƒs|t‚t| jƒ}| j}	| j}
| j}|dk	s¤t‚t|ƒ}|dk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k
�r4   tjdd
„ |D ƒtd�}Y nX n¶|dk�r¶|	}| ¡ }|dk�rhtg tjd�}n<t|ƒ}| ¡ �r¤||  }||dk  | t¡ ¡ j8  < tj|||
d�}n8z|j|dd�}W n$ t k
�rì   |jddd�}Y nX 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 rT   ©r   Úfromordinal©rg   rK  rT   rT   rU   rj   ¾	  s     z#DataCol.convert.<locals>.<listcomp>c                 S  s   g | ]}t  |¡‘qS rT   ©r   Úfromtimestampr,  rT   rT   rU   rj   Â	  s     rù  éÿÿÿÿ)Ú
categoriesr[  F©rv  ÚOrÞ  ©r–   rY   r•   )#rP   rQ   rÎ  rÏ   rÛ   rÏ  rÐ  r²  r³  r  r  ra  rV   rº   rµ  r[  r°  rÒ  ÚasarrayÚobjectr§   Úravelr7   Zfloat64r>   ÚanyÚastyperb   ZcumsumÚ_valuesr?   Z
from_codesr®   Ú_unconvert_string_arrayrV  )rÈ   rV  r–   rY   r•   Ú	convertedr  ra  rº   rµ  r[  r°  rÏ  r0  r  ÚmaskrT   rT   rU   rÕ  ‡	  st    




 ÿ
 ÿ



   ÿ   ÿzDataCol.convertc                 C  sH   t | j| j| jƒ t | j| j| jƒ | jdk	s2t‚t | j| j| jƒ dS )zset the data for this columnN)	rò  rØ  r¹  rV  r  rº   rÏ  rÏ   r  rÌ   rT   rT   rU   rè  ë	  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__rT   rT   rÿ  rU   rý  ×  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ƒƒstdƒ‚d S )Nú-cannot have non-object label DataIndexableCol)r0   r7   rV  r§   rÌ   rT   rT   rU   rá  ø	  s    zDataIndexableCol.validate_namesc                 C  s   t ƒ j|d�S )N)r·  r  r  rT   rT   rU   r  ý	  s    z DataIndexableCol.get_atom_stringrX   rK   r  c                 C  s   | j |d�ƒ S )Nr  r  r   rT   rT   rU   r  
  s    zDataIndexableCol.get_atom_datac                 C  s
   t ƒ  ¡ S r[   r"  r#  rT   rT   rU   r  
  s    z$DataIndexableCol.get_atom_datetime64c                 C  s
   t ƒ  ¡ S r[   r"  r#  rT   rT   rU   r  	
  s    z%DataIndexableCol.get_atom_timedelta64N)rÜ   r¤  r¥  r¦  r®  rá  r=  r  r  r  r  rT   rT   rT   rU   r?  ó	  s   

r?  c                   @  s   e Zd ZdZdS )ÚGenericDataIndexableColz(represent a generic pytables data columnN)rÜ   r¤  r¥  r¦  rT   rT   rT   rU   rA  
  s   rA  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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.
    rX   Úpandas_kindrs   Úformat_typeútype[DataFrame | Series]Úobj_typerb   rO  r�   r½   Fr„   r1  rO   rz   rM   rW   rˆ   )r½   r¸   rY   r•   rZ   c                 C  sZ   t |tƒstt|ƒƒ‚td k	s"t‚t |tjƒs:tt|ƒƒ‚|| _|| _t|ƒ| _	|| _
d S r[   )rP   r�   rÏ   rÛ   r{   rM   r½   r¸   r^   rY   r•   )rÈ   r½   r¸   rY   r•   rT   rT   rU   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   re   é
   é   )ÚversionrÌ   rT   rT   rU   Úis_old_version5
  s    zFixed.is_old_versionztuple[int, int, int]c                 C  sb   t t| jjddƒƒ}z0tdd„ | d¡D ƒƒ}t|ƒdkrB|d }W n tk
r\   d}Y nX |S )	zcompute and set our versionÚpandas_versionNc                 s  s   | ]}t |ƒV  qd S r[   ©rb   r   rT   rT   rU   rH  >
  s     z Fixed.version.<locals>.<genexpr>Ú.rH  r"  )r   r   r   )rV   rg  r¸   rh  rl   rŸ  rm   r}   )rÈ   rI  rT   rT   rU   rI  9
  s    
zFixed.versionc                 C  s   t t| jjdd ƒƒS )Nrd  )rV   rg  r¸   rh  rÌ   rT   rT   rU   rd  E
  s    zFixed.pandas_typec                 C  s^   |   ¡  | j}|dk	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 rT   ©rJ   r   rT   rT   rU   rj   O
  s     z"Fixed.__repr__.<locals>.<listcomp>ú[r  ú12.12z	 (shape->ú))r  r  rP   rk   rl   r½  rd  )rÈ   rS   ZjshaperT   rT   rU   rå   I
  s    zFixed.__repr__c                 C  s   t | jƒ| j_t tƒ| j_dS )zset my pandas type & versionN)rX   rC  rØ  rd  Ú_versionrK  rÌ   rT   rT   rU   rš  T
  s    zFixed.set_object_infoc                 C  s   t   | ¡}|S r[   r1  )rÈ   Znew_selfrT   rT   rU   rv  Y
  s    
z
Fixed.copyc                 C  s   | j S r[   )r  rÌ   rT   rT   rU   r  ]
  s    zFixed.shapec                 C  s   | j jS r[   ©r¸   r²   rÌ   rT   rT   rU   r2  a
  s    zFixed.pathnamec                 C  s   | j jS r[   )r½   r¾   rÌ   rT   rT   rU   r¾   e
  s    zFixed._handlec                 C  s   | j jS r[   )r½   rÆ   rÌ   rT   rT   rU   rÆ   i
  s    zFixed._filtersc                 C  s   | j jS r[   )r½   rÃ   rÌ   rT   rT   rU   rÃ   m
  s    zFixed._complevelc                 C  s   | j jS r[   )r½   rÅ   rÌ   rT   rT   rU   rÅ   q
  s    zFixed._fletcher32c                 C  s   | j jS r[   )r¸   rh  rÌ   rT   rT   rU   rØ  u
  s    zFixed.attrsc                 C  s   dS ©zset our object attributesNrT   rÌ   rT   rT   rU   Ú	set_attrsy
  s    zFixed.set_attrsc                 C  s   dS )zget our object attributesNrT   rÌ   rT   rT   rU   Ú	get_attrs|
  s    zFixed.get_attrsc                 C  s   | j S )zreturn my storablerœ  rÌ   rT   rT   rU   Ústorable
  s    zFixed.storablec                 C  s   dS rü  rT   rÌ   rT   rT   rU   r™  „
  s    zFixed.is_existsc                 C  s   t | jdd ƒS )Nr  )rg  rX  rÌ   rT   rT   rU   r  ˆ
  s    zFixed.nrowszLiteral[True] | Nonec                 C  s   |dkrdS dS )z%validate against an existing storableNTrT   rÆ  rT   rT   rU   ÚvalidateŒ
  s    zFixed.validateNc                 C  s   dS )ú+are we trying to operate on an old version?NrT   )rÈ   rn   rT   rT   rU   Úvalidate_version’
  s    zFixed.validate_versionc                 C  s   | j }|dk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)rX  rW  )rÈ   rS   rT   rT   rU   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È   rn   r¢   r    r¡   rT   rT   rU   r   
  s    ÿz
Fixed.readc                 K  s   t dƒ‚d S )Nz?cannot write on an abstract storer: subclasses should implementr]  ©rÈ   r¶   rT   rT   rU   r›  «
  s    ÿzFixed.write©r    r¡   rZ   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)r=  r>  r¾   r�  r¸   r®   )rÈ   rn   r    r¡   rT   rT   rU   r?  °
  s    zFixed.delete)rO   rz   )N)NNNN)NNN)!rÜ   r¤  r¥  r¦  r§  rD  r1  rÉ   r¨  rJ  rI  rd  rå   rš  rv  r  r2  r¾   rÆ   rÃ   rÅ   rØ  rV  rW  rX  r™  r  rY  r[  r  r  r›  r?  rT   rT   rT   rU   rB  
  sl   
  û







    û     ÿrB  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 rT   rT   )rg   r  rK  rT   rT   rU   rL  Â
  s      zGenericFixed.<dictcomp>rì   Ú
attributesrX   rÊ   c                 C  s   | j  |d¡S )NÚ )Ú_index_type_maprÓ   )rÈ   r•  rT   rT   rU   Ú_class_to_aliasÆ
  s    zGenericFixed._class_to_aliasc                 C  s   t |tƒr|S | j |t¡S r[   )rP   rÛ   Ú_reverse_index_maprÓ   r7   )rÈ   ÚaliasrT   rT   rU   Ú_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|krn|d |d< |tkrnt}d|kr°t|d tƒr˜|d  	d¡|d< n|d |d< |tks°t
‚||fS )NÚindex_classrd  c                 S  s:   t j| j|d�}tj|d d�}|d k	r6| d¡ |¡}|S )N©r¯  r_   ÚUTC)r@   Ú_simple_newrV  r6   Útz_localizeÚ
tz_convert)rV  r¯  r°  ZdtaÚresultrT   rT   rU   ru   Ø
  s
    z*GenericFixed._get_index_factory.<locals>.fc                 S  s   t j| |d�}tj|d d�S )Nrk  r_   )rA   rm  r9   )rV  r¯  r°  ZparrrT   rT   rU   ru   ã
  s    r¯  r°  zutf-8)NN)NN)ri  rV   rg  r6   r9   r7   r<   rP   ÚbytesrR   rÏ   )rÈ   rØ  rj  ru   rÔ  r¶   rT   rT   rU   Ú_get_index_factoryÏ
  s*    ÿ

zGenericFixed._get_index_factoryrˆ   c                 C  s$   |dk	rt dƒ‚|dk	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¢   rn   rT   rT   rU   Úvalidate_readý
  s    ÿÿzGenericFixed.validate_readr„   c                 C  s   dS )NTrT   rÌ   rT   rT   rU   r™    s    zGenericFixed.is_existsc                 C  s   | j | j_ | j| j_dS rU  )rY   rØ  r•   rÌ   rT   rT   rU   rV    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 attributesrY   Nr•   rz   )r^   rg  rØ  rY   rV   r•   rc  rò  )rÈ   rð   rT   rT   rU   rW    s    
zGenericFixed.get_attrsc                 K  s   |   ¡  d S r[   )rV  ©rÈ   r—  r¶   rT   rT   rU   r›    s    zGenericFixed.writeNrƒ   r  c                 C  sÐ   ddl }t| j|ƒ}|j}t|ddƒ}t||jƒrD|d ||… }nztt|ddƒƒ}	t|ddƒ}
|
dk	rxtj|
|	d�}n|||… }|	dk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  r)  r$  r°  Tr%  r'  r(  )r|   rg  r¸   rh  rP   ZVLArrayrV   rQ   r–  rÒ  r4  ÚT)rÈ   rŠ   r    r¡   r|   rß   rØ  rv  ÚretrÏ  r  r°  rT   rT   rU   Ú
read_array   s&    zGenericFixed.read_arrayr7   )rŠ   r    r¡   rZ   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Úmultir\  Úregularzunrecognized index variety: )rV   rg  rØ  Úread_multi_indexr¸   Úread_index_noder®   )rÈ   rŠ   r    r¡   Zvarietyrß   r‘   rT   rT   rU   Ú
read_indexB  s    zGenericFixed.read_index)rŠ   r‘   rZ   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 k	rÜt|jƒ|j_d S )Nr{  r|  r}  r‘   )rP   r8   rò  rØ  Úwrite_multi_indexÚ_convert_indexrY   r•   Úwrite_arrayrV  rg  r¸   ra  rh  r`   r6   r9   rf  rÛ   rj  r<   r¯  r°  Ú_get_tz)rÈ   rŠ   r‘   r;  rß   rT   rT   rU   Úwrite_indexP  s    



zGenericFixed.write_indexr8   c                 C  sÎ   t | j|› d�|jƒ tt|j|j|jƒƒD ]œ\}\}}}t|ƒrJt	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Œ  Ú	enumerater0  Úlevelsr  Únamesr-   rª   r‚  rY   r•   rƒ  rV  rg  r¸   ra  rh  r`   )rÈ   rŠ   r‘   ÚiÚlevÚlevel_codesr`   Ú	level_keyZ
conv_levelrß   Ú	label_keyrT   rT   rU   r�  g  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‡  r\  r‰  T)r‹  r  rŒ  r(  )	rg  rØ  rN  r¸   r  r�   r`   rz  r8   )rÈ   rŠ   r    r¡   rŒ  r‹  r  rŒ  r�  r�  rß   rŽ  r‘  r�  rT   rT   rU   r~  €  s&    
   ÿzGenericFixed.read_multi_indexrM   )rß   r    r¡   rZ   c                 C  sÔ   |||… }d|j kr>t |j j¡dkr>tj|j j|j jd�}t|j jƒ}d }d|j krlt|j j	ƒ}t|ƒ}|j }|  
|¡\}}	|dkr®|t||| j| jd�fdti|	—Ž}
n|t||| j| jd�f|	Ž}
||
_	|
S )Nr  r   r)  r`   )r   r5  rƒ  rÏ  )rh  rQ   Úprodr  r–  rw  rV   ra  ra   r`   rr  Ú_unconvert_indexrY   r•   r5  )rÈ   rß   r    r¡   ru  ra  r`   rØ  rÔ  r¶   r‘   rT   rT   rU   r  —  sF    
   ÿÿüû   ÿÿüzGenericFixed.read_index_noder   )rŠ   r‹   rZ   c                 C  sJ   t  d|j ¡}| j | j||¡ t| j|ƒ}t|jƒ|j	_
|j|j	_dS )zwrite a 0-len array©re   N)rQ   r–  rO  r¾   Úcreate_arrayr¸   rg  rX   rÏ  rh  rw  r  )rÈ   rŠ   r‹   Zarrrß   rT   rT   rU   Úwrite_array_empty½  s
    zGenericFixed.write_array_emptyr   zIndex | None)rŠ   r—  rø   rZ   c              	   C  s4  t |dd�}|| jkr&| j | j|¡ |jdk}d}t|jƒrFtdƒ‚|s^t|dƒr^|j	}d}d }| j
d k	r�ttƒ� tƒ j |j¡}W 5 Q R X |d k	rÖ|sÆ| jj| j|||j| j
d�}||d d …< n|  ||¡ �nJ|jjtjk�rJtj|dd�}	|rún,|	d	k�rn t|	||f }
tj|
ttƒ d
� | j | j|tƒ  ¡ ¡}| |¡ nÖt |jƒ�r€| j !| j|| "d¡¡ dt#| j|ƒj$_%n t&|jƒ�rÄ| j !| j||j'¡ t#| j|ƒ}t(|j)ƒ|j$_)d|j$_%n\t*|jƒ�rú| j !| j|| "d¡¡ dt#| j|ƒj$_%n&|�r|  ||¡ 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".rx  )rÁ   ©ZskipnarÞ  rì  rÌ  r$  r'  ),rD   r¸   r¾   r�  r  r)   rÏ  rª   rÉ  rx  rÆ   r   r§   r€   ZAtomZ
from_dtypeZcreate_carrayr  r–  rÛ   rQ   Zobject_r   Úinfer_dtyperr   rð  rñ  r#   r&   Zcreate_vlarrayÚ
ObjectAtomr�   r+   r•  Úviewrg  rh  rw  r,   Úasi8r„  r°  r2   rv  )rÈ   rŠ   r—  rø   r‹   Zempty_arrayrv  r  ÚcaÚinferred_typerô  Zvlarrrß   rT   rT   rU   rƒ  Æ  sr    


ÿ


    ÿ
  ÿ
zGenericFixed.write_array)NN)NN)NN)NN)N)rÜ   r¤  r¥  r¦  r6   r9   re  rø   rg  rc  r§  rf  ri  rr  rs  r¨  r™  rV  rW  r›  rz  r€  r…  r�  r~  r  r–  rƒ  rT   rT   rT   rU   ra  ¾
  s8   
.#   ÿ   ÿ   ÿ&
 ÿra  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€  r`   r   c              	   C  s0   zt | jjƒfW S  ttfk
r*   Y d S X d S r[   )rm   r¸   rV  r®   r}   rÌ   rT   rT   rU   r  '  s    zSeriesFixed.shapeNrƒ   r;   r`  c                 C  s>   |   ||¡ | jd||d�}| jd||d�}t||| jdd�S )Nr‘   r\  rV  F)r‘   r`   rv  )rs  r€  rz  r;   r`   )rÈ   rn   r¢   r    r¡   r‘   rV  rT   rT   rU   r  .  s    zSeriesFixed.readrˆ   rÊ   c                   s8   t ƒ j|f|Ž |  d|j¡ |  d|¡ |j| j_d S )Nr‘   rV  )rþ  r›  r…  r‘   rƒ  r`   rØ  ru  rÿ  rT   rU   r›  ;  s    zSeriesFixed.write)NNNN)rÜ   r¤  r¥  rC  rc  r§  r¨  r  r  r›  r>  rT   rT   rÿ  rU   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 )ÚBlockManagerFixedrO  Únblocksrb   zShape | NonerÊ   c                 C  s°   z”| j }d}t| jƒD ]8}t| jd|› d�ƒ}t|dd ƒ}|d k	r||d 7 }q| jj}t|dd ƒ}|d k	r‚t|d|d … ƒ}ng }| |¡ |W S  tk
rª   Y d S X d S )Nr   ÚblockÚ_itemsr  re   )	rO  rN  rŸ  rg  r¸   Zblock0_valuesrk   r�   r}   )rÈ   rO  rø   r�  rß   r  rT   rT   rU   r  G  s"    
zBlockManagerFixed.shapeNrƒ   r5   r`  c                 C  s  |   ||¡ |  ¡  d¡}g }t| jƒD ]<}||kr<||fnd\}}	| jd|› �||	d�}
| |
¡ q(|d }g }t| jƒD ]\}|  d|› d�¡}| jd|› d�||	d�}|| 	|¡ }t
|j||d d	d
�}| |¡ q|t|ƒdk�rt|ddd�}|j|d	d�}|S t
|d |d d�S )Nr   )NNr'  r\  r   r¡  r9  re   F©r¢   r‘   rv  T)r'  rv  )r¢   rv  ©r¢   r‘   )rs  rF  Z_get_block_manager_axisrN  rO  r€  r�   rŸ  rz  rT  r5   rx  rm   r=   rZ  )rÈ   rn   r¢   r    r¡   Zselect_axisrA  r�  r  r  Úaxrø   ÚdfsÚ	blk_itemsrV  ÚdfÚoutrT   rT   rU   r  b  s(    zBlockManagerFixed.readrˆ   c                   sä   t ƒ j|f|Ž t|jtƒr&| d¡}|j}| ¡ s<| ¡ }|j| j	_t
|jƒD ]0\}}|dkrn|jsntdƒ‚|  d|› �|¡ qPt|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'  r9  )rø   r¡  )rþ  r›  rP   Ú_mgrrF   Ú_as_managerZis_consolidatedZconsolidaterO  rØ  rŠ  rA  Z	is_uniquer§   r…  rm   ÚblocksrŸ  rø   rU  Úmgr_locsrƒ  rV  )rÈ   r—  r¶   ru  r�  r¤  Úblkr¦  rÿ  rT   rU   r›  †  s     

zBlockManagerFixed.write)NNNN)
rÜ   r¤  r¥  rc  r§  r¨  r  r  r›  r>  rT   rT   rÿ  rU   rž  B  s   
    û$rž  c                   @  s   e Zd ZdZeZdS )r‹  r�  N)rÜ   r¤  r¥  rC  r5   rF  rT   rT   rT   rU   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;„ ƒZe
d-dœd<d=„ƒZe
d%dœd>d?„ƒZe
d@dœdAdB„ƒZdCdœdDdE„ZdFdG„ ZdHdœdIdJ„ZdddKœdLdM„ZddNddOœdPdQ„ZddRœdSdT„Z ddœdUdV„Z!ddœdWdX„Z"d�ddœdYdZ„Z#ddœd[d\„Z$e%d]d^„ ƒZ&d‚ddd_œd`da„Z'dƒdbdbdcddœdedf„Z(e)d%dgœdhdi„ƒZ*djdk„ Z+d„dld%dmœdndo„Z,e-dld%dpœdqdr„ƒZ.d…dsdldtœdudv„Z/dbd%dbdCdwœdxdy„Z0d†dbdbdzœd{d|„Z1d‡ddbdbd}œ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_tablert   rX   rD  r}  re   zint | list[Hashable]r‹  Trk   rµ  Nrz   r�   rM   rW   zlist[IndexCol] | Nonez list[tuple[AxisInt, Any]] | Nonezlist[DataCol] | Nonezlist | Nonezdict | Nonerˆ   )
r½   r¸   rY   r•   Ú
index_axesr#  Úvalues_axesr”   rz  rZ   c                   sP   t ƒ j||||d� |pg | _|p$g | _|p.g | _|p8g | _|	pBi | _|
| _d S )Nrƒ  )rþ  rÉ   r®  r#  r¯  r”   rz  r–   )rÈ   r½   r¸   rY   r•   r®  r#  r¯  r”   rz  r–   rÿ  rT   rU   rÉ   Å  s    




zTable.__init__rÊ   c                 C  s   | j  d¡d S )NÚ_r   )r}  rŸ  rÌ   rT   rT   rU   Útable_type_shortÚ  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 )rN  rº  rd  z,dc->[r  rM  c                 S  s   g | ]}t |ƒ‘qS rT   ©rX   r   rT   rT   rU   rj   æ  s     z"Table.__repr__.<locals>.<listcomp>rP  c                 S  s   g | ]
}|j ‘qS rT   r_   rt  rT   rT   rU   rj   é  s     rQ  z (typ->z,nrows->z,ncols->z,indexers->[rR  )r  rm   r”   r½  rJ  rI  r®  rd  r±  r  Úncols)rÈ   Zjdcr\  ÚverZjverZjindex_axesrT   rT   rU   rå   Þ  s    4ÿzTable.__repr__)rê  c                 C  s"   | j D ]}||jkr|  S qdS )zreturn the axis for cN)rA  r`   )rÈ   rê  r�   rT   rT   rU   rÕ   ð  s    


zTable.__getitem__c              
   C  sº   |dk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®   rg  rŠ  r§   r<  )rÈ   rÁ  rê  ÚsvÚovr�  ÚsaxZoaxrT   rT   rU   rY  ÷  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)rP   r‹  rk   rÌ   rT   rT   rU   Úis_multi_index  s    zTable.is_multi_indexr‚   z tuple[DataFrame, list[Hashable]])r—  rZ   c              
   C  s^   t  |jj¡}z| ¡ }W n, tk
rF } ztdƒ|‚W 5 d}~X Y nX t|tƒsVt‚||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)	r=  Zfill_missing_namesr‘   rŒ  Zreset_indexr§   rP   r5   rÏ   )rÈ   r—  r‹  Z	reset_objr@  rT   rT   rU   Úvalidate_multiindex  s    ÿþzTable.validate_multiindexrb   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  ©rg   r�  rT   rT   rU   rj   1  s     z(Table.nrows_expected.<locals>.<listcomp>)rQ   r’  r®  rÌ   rT   rT   rU   Únrows_expected.  s    zTable.nrows_expectedc                 C  s
   d| j kS )zhas this table been createdrt   rœ  rÌ   rT   rT   rU   r™  3  s    zTable.is_existsc                 C  s   t | jdd ƒS ©Nrt   ©rg  r¸   rÌ   rT   rT   rU   rX  8  s    zTable.storablec                 C  s   | j S )z,return the table group (this is my storable))rX  rÌ   rT   rT   rU   rt   <  s    zTable.tablec                 C  s   | j jS r[   )rt   rÏ  rÌ   rT   rT   rU   rÏ  A  s    zTable.dtypec                 C  s   | j jS r[   rÙ  rÌ   rT   rT   rU   rÚ  E  s    zTable.descriptionc                 C  s   t  | j| j¡S r[   )r.  r/  r®  r¯  rÌ   rT   rT   rU   rA  I  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[   )rm   rV  rt  rT   rT   rU   rH  P  s     zTable.ncols.<locals>.<genexpr>)Úsumr¯  rÌ   rT   rT   rU   r³  M  s    zTable.ncolsc                 C  s   dS rü  rT   rÌ   rT   rT   rU   Úis_transposedR  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"  rL  rt  rT   rT   rU   rj   [  s     z*Table.data_orientation.<locals>.<listcomp>c                 S  s   g | ]}t |jƒ‘qS rT   )rb   r'  rt  rT   rT   rU   rj   \  s     )rl   r.  r/  r#  r®  rÌ   rT   rT   rU   Údata_orientationV  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   re   c                 S  s   g | ]}|j |f‘qS rT   ©r²  rt  rT   rT   rU   rj   f  s     z$Table.queryables.<locals>.<listcomp>c                   s   g | ]\}}ˆ | d f‘qS r[   rT   )rg   r'  rV  )Ú
axis_namesrT   rU   rj   g  s     c                   s&   g | ]}|j tˆ jƒkr|j|f‘qS rT   )r`   rM  r”   r²  r,  rÌ   rT   rU   rj   h  s     )r®  r#  r¯  rC  )rÈ   Úd1Zd2Zd3rT   )rÃ  rÈ   rU   Ú
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 rT   )r'  r²  rº  rT   rT   rU   rj   q  s     z$Table.index_cols.<locals>.<listcomp>©r®  rÌ   rT   rT   rU   Ú
index_colsn  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 rT   rÂ  rº  rT   rT   rU   rj   u  s     z%Table.values_cols.<locals>.<listcomp>)r¯  rÌ   rT   rT   rU   Úvalues_colss  s    zTable.values_colsrÖ   c                 C  s   | j j}|› d|› d�S )z)return the metadata pathname for this keyz/meta/z/metarT  r  rT   rT   rU   Ú_get_metadata_pathw  s    zTable._get_metadata_pathrÊ  )rŠ   rV  rZ   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
        Fr1  rt   )r�   rY   r•   r–   N)r½   rœ   rÉ  r;   rY   r•   r–   )rÈ   rŠ   rV  rT   rT   rU   rç  |  s    	
úzTable.write_metadatarÒ   c                 C  s0   t t | jddƒ|dƒdk	r,| j |  |¡¡S dS )z'return the meta data array for this keyrº   N)rg  r¸   r½   r³   rÉ  rÔ   rT   rT   rU   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)rX   r}  rØ  rÇ  rÈ  r#  r”   r–   rY   r•   r‹  rz  rÌ   rT   rT   rU   rV  ”  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 )rt  r#  Nr”   rz  r–   rY   r•   rz   r‹  c                 S  s   g | ]}|j r|‘qS rT   ©r­  rt  rT   rT   rU   rj   ª  s      z#Table.get_attrs.<locals>.<listcomp>c                 S  s   g | ]}|j s|‘qS rT   rÊ  rt  rT   rT   rU   rj   «  s      )rg  rØ  r#  r”   rz  r–   r^   rY   rV   r•   r‹  Ú
indexablesr®  r¯  rÌ   rT   rT   rU   rW  ¡  s    zTable.get_attrsc                 C  s>   |dk	r:| j r:td dd„ | jD ƒ¡ }tj|ttƒ d� dS )rZ  NrM  c                 S  s   g | ]}t |ƒ‘qS rT   r²  r   rT   rT   rU   rj   ±  s     z*Table.validate_version.<locals>.<listcomp>rì  )rJ  rp   r½  rI  rð  rñ  r"   r&   )rÈ   rn   rô  rT   rT   rU   r[  ­  s    ýzTable.validate_versionc                 C  sR   |dkrdS t |tƒsdS |  ¡ }|D ]&}|dkr4q&||k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
        NrV  zmin_itemsize has the key [z%] which is not an axis or data_column)rP   rC  rÅ  r§   )rÈ   r’   Úqr  rT   rT   rU   Úvalidate_min_itemsize¸  s    

ÿzTable.validate_min_itemsizec                   sÔ   g }ˆj ‰ˆjj‰tˆjjƒD ]j\}\}}tˆ|ƒ}ˆ |¡}|dk	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¸  )r`   r'  r´  ra  r³  rt   rº   rµ  c                   s¢   t |tƒst‚t}|ˆkrt}tˆ|ƒ}t|ˆjƒ}tˆ|› d�d ƒ}tˆ|› d�d ƒ}t|ƒ}ˆ 	|¡}tˆ|› d�d ƒ}	|||||ˆ |  |ˆj
|	||d�
}
|
S )Nr¸  r  r  )
r`   r²  rV  ra  r´  r³  rt   rº   rµ  rÏ  )rP   rX   rÏ   rý  r?  rg  Ú_maybe_adjust_namerI  r  rú  rt   )r�  rê  Úklassr  Úadj_namerV  rÏ  ra  Úmdrº   r—  )Úbase_posr\  ÚdescrÈ   Útable_attrsrT   rU   ru   ð  s0    

özTable.indexables.<locals>.fc                   s   g | ]\}}ˆ ||ƒ‘qS rT   rT   )rg   r�  rê  )ru   rT   rU   rj     s     z$Table.indexables.<locals>.<listcomp>)rÚ  rt   rØ  rŠ  rÇ  rg  rú  r¬  r�   rM  r”   rm   rQ  rÈ  )rÈ   Ú_indexablesr�  r'  r`   r  rÑ  rº   r¹  ra  Ú	index_colrT   )rÒ  r\  rÓ  ru   rÈ   rÔ  rU   rË  Í  s2    


ø

% zTable.indexablesr  c              	   C  sR  |   ¡ sdS |dkrdS |dks(|dkr8dd„ | jD ƒ}t|ttfƒsL|g}i }|dk	r`||d< |dk	rp||d< | j}|D ]Ò}t|j|dƒ}|dk	�r|jrò|j	}|j
}	|j}
|dk	rÈ|
|krÈ| ¡  n|
|d< |dk	rê|	|krê| ¡  n|	|d< |j�sL|j d¡�rtd	ƒ‚|jf |Ž qz|| jd
 d k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 rT   )r®  r²  rt  rT   rT   rU   rj   >  s      z&Table.create_index.<locals>.<listcomp>r`  ra  Ú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   re   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  rA  rP   rl   rk   rt   rg  rG  rs  r‘   r`  ra  Zremove_indexrÛ   rn  r®   rb  r#  r}   )rÈ   r¢   r`  ra  Úkwrt   rê  rK  r‘   Zcur_optlevelZcur_kindrT   rT   rU   rb    sJ    


ÿÿzTable.create_indexrƒ   z!list[tuple[ArrayLike, ArrayLike]]r`  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  r3  )
Ú	Selectionr³   rA  rø  rz  rÕ  r–   rY   r•   r�   )	rÈ   rn   r    r¡   Ú	selectionrV  r«  r�   ÚresrT   rT   rU   Ú
_read_axeso  s    
üzTable._read_axes©rv  c                 C  s   |S )zreturn the data for this objrT   ©r•  r—  rv  rT   rT   rU   Ú
get_object‘  s    zTable.get_objectc                   s²   t |ƒsg S |d \}‰ | j |i ¡}| d¡dkrL|rLtd|› d|› �ƒ‚|dkr^tˆ ƒ}n|dk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Û   r8   z"cannot use a multi-index on axis [z] with data_columns TNc                   s    g | ]}|d kr|ˆ kr|‘qS rÖ  rT   r  )Úexisting_data_columnsrT   rU   rj   ²  s    þz/Table.validate_data_columns.<locals>.<listcomp>c                   s   g | ]}|ˆ kr|‘qS rT   rT   )rg   rê  )Úaxis_labelsrT   rU   rj   º  s      )
rm   rz  rÓ   r§   rk   rP   rC  rM  rQ  rô   )rÈ   r”   r’   r#  r'  rz  rT   )rá  rà  rU   Úvalidate_data_columns–  s*    ÿ


þÿ	zTable.validate_data_columnsr5   )r—  rY  c           /        sŽ  t ˆtƒs,| jj}td|› dtˆƒ› d�ƒ‚ˆ dkr:dg‰ ‡fdd„ˆ D ƒ‰ |  ¡ rzd}d	d„ | jD ƒ‰ t| j	ƒ}| j
}nd
}| j}	| jdks’t‚tˆ ƒ| jd kr¬tdƒ‚g }
|dkr¼d}‡ fdd„dD ƒd }ˆj| }t|ƒ}|�r<t|
ƒ}| j| d }tt |¡t |¡ƒ�s<tt t|ƒ¡t t|ƒ¡ƒ�r<|}|	 |i ¡}t|jƒ|d< t|ƒj|d< |
 ||f¡ ˆ d }ˆj| }ˆ |¡}t||| j| jƒ}||_| d¡ |  |	¡ | !|¡ |g}t|ƒ}|dk�sàt‚t|
ƒdk�sòt‚|
D ]}t"ˆ|d |d ƒ‰�qö|jdk}|  #|||
¡}|  $ˆ|¡ %¡ }|  &|||
| j'|¡\}}g }t(t)||ƒƒD �]¸\}\}}t*}d}|�rÆt|ƒdk�rÆ|d |k�rÆt+}|d }|dk�sÆt |t,ƒ�sÆtdƒ‚|�r&|�r&z| j'| }W nB t-t.fk
�r" }  ztd|› d| j'› d�ƒ| ‚W 5 d} ~ X Y nX nd}|�p8d|› �}!t/|!|j0|||| j| j|d�}"t1|!| j2ƒ}#| 3|"¡}$t4|"j5j6ƒ}%d}&t7|"ddƒdk	�ršt8|"j9ƒ}&d }' }(})t:|"j5ƒ�rÐ|"j;})d}'tj|"j<d
d� =¡ }(t>|"ƒ\}*}+||#|!t|ƒ|$||%|&|)|'|(|+|*d�},|,  |	¡ | |,¡ |d7 }�qddd„ |D ƒ}-t| ƒ| j?| j| j| j||
||-|	|d�
}.t@| dƒ�rj| jA|._A|. B|¡ |�rŠ|�rŠ|. C| ¡ |.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 rT   )Ú_get_axis_numberrt  )r—  rT   rU   rj   è  s     z&Table._create_axes.<locals>.<listcomp>Tc                 S  s   g | ]
}|j ‘qS rT   rI  rt  rT   rT   rU   rj   í  s     FrH  re   z<currently only support ndim-1 indexers in an AppendableTableÚnanc                   s   g | ]}|ˆ kr|‘qS rT   rT   r   )rA  rT   rU   rj     s      rÁ  rŒ  rÛ   r@  zIncompatible appended table [z]with existing table [Zvalues_block_)Úexisting_colr’   r–   rY   r•   r¢   r°  rù  r1  )r`   r²  rV  r³  r´  ra  r°  r[  rº   rµ  rÏ  ru  c                 S  s   g | ]}|j r|j‘qS rT   )r®  r`   )rg   rÛ  rT   rT   rU   rj   ‹  s      )
r½   r¸   rY   r•   r®  r#  r¯  r”   rz  r–   r‹  )DrP   r5   r¸   r»   r®   rÛ   r  r®  rk   r”   r–   rz  rO  rÏ   rm   r§   rA  r#  r4   rQ   ÚarrayrS  rï  rŒ  rÜ   r�   Z_get_axis_namer‚  rY   r•   r'  r¶  rõ  rà  Ú_reindex_axisrâ  rß  r)  Ú_get_blocks_and_itemsr¯  rŠ  r0  rý  r?  rX   Ú
IndexErrorr´   Ú_maybe_convert_for_string_atomrV  rÎ  rI  r  r  rÏ  r`   rg  r„  r°  r)   r[  r0  r6  r  r½   rÉ  r‹  rÍ  rY  )/rÈ   rA  r—  rY  r–   r”   r’   r¸   Útable_existsZnew_infoÚnew_non_index_axesró  r�   Zappend_axisZindexerZ
exist_axisrz  Ú	axis_nameZ	new_indexZnew_index_axesÚjrv  r�  r«  r¦  Zvaxesr�  r­  Úb_itemsrÏ  r`   rå  r@  Únew_nameÚdata_convertedrÐ  r³  ra  r°  rº   rµ  r[  ru  r  rÛ  ZdcsZ	new_tablerT   )rA  r—  rU   Ú_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k
�rz } z*d d	d
„ |D ƒ¡}td|› d�ƒ|‚W 5 d }~X Y qøX qø|}|}||fS )Nr   c                   s   ‡ fdd„ˆ j D ƒS )Nc                   s   g | ]}ˆ j  |j¡‘qS rT   )rø   rU  r¬  )rg   r­  ©ÚmgrrT   rU   rj   ³  s     zFTable._get_blocks_and_items.<locals>.get_blk_items.<locals>.<listcomp>)r«  ró  rT   ró  rU   Úget_blk_items²  s    z2Table._get_blocks_and_items.<locals>.get_blk_itemsr   rI  c                 S  s"   i | ]\}}t | ¡ ƒ||f“qS rT   )rl   Útolist)rg   Úbrï  rT   rT   rU   rL  Ñ  s   ÿ
 z/Table._get_blocks_and_items.<locals>.<dictcomp>rº  c                 S  s   g | ]}t |ƒ‘qS rT   rO  )rg   ÚitemrT   rT   rU   rj   Þ  s     z/Table._get_blocks_and_items.<locals>.<listcomp>z+cannot match existing table structure for [z] on appending data)rP   r©  rF   rª  r   rG   rk   r«  rm   r7   rR  rZ  rQ  r0  rl   rV  r3  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ï  r@  ZjitemsrT   rT   rU   rè  ¤  sR    





þ


ÿýzTable._get_blocks_and_itemsrÙ  )rÚ  rZ   c                   sª   |dk	rt |ƒ}|dk	rNˆjrNtˆjt ƒs.t‚ˆjD ]}||kr4| d|¡ q4ˆjD ]$\}}tˆ |||ƒ‰ ‡ ‡fdd„}qT|jdk	r¦|j 	¡ D ]\}}	}
|||
|	ƒ‰ qŽˆ S )zprocess axes filtersNr   c                   sÌ   ˆ j D ]°}ˆ  |¡}ˆ  |¡}|d k	s*t‚| |krfˆjrH| tˆjƒ¡}|||ƒ}ˆ j|d�|   S | |krt	t
ˆ | ƒjƒ}t	|ƒ}tˆ tƒr˜d| }|||ƒ}ˆ j|d�|   S qtd| › d�ƒ‚d S )NrI  re   zcannot find the field [z] for filtering!)Z_AXIS_ORDERSrã  Ú	_get_axisrÏ   r¸  Úunionr7   r‹  rY  rE   rg  rV  rP   r5   r§   )ÚfieldÚfiltÚoprí  Zaxis_numberZaxis_valuesZtakersrV  ©r—  rÈ   rT   rU   Úprocess_filterù  s"    





z*Table.process_axes.<locals>.process_filter)
rk   r¸  rP   r‹  rÏ   Úinsertr#  rç  Úfilterr�   )rÈ   r—  rÚ  r¢   rð   r'  Úlabelsrÿ  rû  rý  rü  rT   rþ  rU   Úprocess_axesè  s    
 
zTable.process_axes)r�   rÀ   rB  rZ   c                 C  s‚   |dkrt | jdƒ}d|dœ}dd„ | jD ƒ|d< |rj|dkrH| jpFd}tƒ j|||pZ| jd	�}||d
< n| jdk	r~| j|d
< |S )z:create the description of the table from the axes & valuesNi'  rt   )r`   rB  c                 S  s   i | ]}|j |j“qS rT   )r²  r³  rt  rT   rT   rU   rL  .  s      z,Table.create_description.<locals>.<dictcomp>rÚ  é	   )r�   rŽ   rÀ   rÁ   )Úmaxr»  rA  rÃ   r€   rú   rÅ   rÆ   )rÈ   rŽ   r�   rÀ   rB  rD  rÁ   rT   rT   rU   Úcreate_description  s     	

ý


zTable.create_descriptionr\  c           
      C  s�   |   |¡ |  ¡ sdS t| |||d�}| ¡ }|jdk	rˆ|j ¡ D ]D\}}}| j|| ¡ | ¡ d d�}	|||	j	|| ¡   |ƒj
 }qBt|ƒS )zf
        select coordinates (row numbers) from a table; return the
        coordinates object
        Fr  Nre   r\  )r[  r  rÙ  Úselect_coordsr  r�   r  rª  r  ÚilocrV  r7   )
rÈ   rn   r    r¡   rÚ  Zcoordsrû  rý  rü  ru  rT   rT   rU   r  >  s    

  
ÿ zTable.read_coordinatesr  c                 C  s¼   |   ¡  |  ¡ sdS |dk	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 indexabler3  re   )r`   rv  z] not found in the table)r[  r  r®   rA  r`   r®  r§   rg  rt   rG  rø  rz  rÕ  r–   rY   r•   r;   rÒ  r°  r´   )rÈ   r  rn   r    r¡   r�   rê  Z
col_valuesrT   rT   rU   r  X  s*    


ÿ
ü zTable.read_column)Nrz   NNNNNN)N)NNN)NN)TNNN)N)NNN)NNN)4rÜ   r¤  r¥  r¦  rC  rD  r§  r‹  r1  rÉ   r¨  r±  rå   rÕ   rY  r¸  r¹  r»  r™  rX  rt   rÏ  rÚ  rA  r³  r¿  rÀ  rÅ  rÇ  rÈ  rÉ  rç  rú  rV  rW  r[  rÍ  r%   rË  rb  rÜ  r=  rß  râ  rò  Ústaticmethodrè  r  r  r  r  r>  rT   rT   rÿ  rU   rò   ¥  s¨   
        õ&!




	
L     ÿW   ÿ"*    ù i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ƒ   r\  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 readNr]  r^  rT   rT   rU   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 writeNr]  r_  rT   rT   rU   r›  ™  s    zWORMTable.write)NNNN)rÜ   r¤  r¥  r¦  r}  r  r›  rT   rT   rT   rU   r’  „  s       ûr’  c                   @  sf   e Zd ZdZdZ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“   r6  rZ   c                 C  s²   |s| j r| j | jd¡ | j||||||d�}|jD ]}| ¡  q6|j s~|j||||	d�}| ¡  ||d< |jj	|jf|Ž |j
|j_
|jD ]}| ||¡ qŽ|j||
d� d S )Nrt   )rA  r—  rY  r’   r–   r”   )rŽ   r�   rÀ   rB  r6  )r“   )r™  r¾   r�  r¸   rò  rA  rá  r  rV  Zcreate_tablerz  rØ  ré  Ú
write_data)rÈ   r—  rA  r�   rŽ   r�   rÀ   r’   r¤   rB  r“   r–   r”   r6  rt   r�   ÚoptionsrT   rT   rU   r›  ¨  s4    
ú	

ü

zAppendableTable.writerƒ   )r¤   r“   rZ   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´t|
ƒ‚d
d	„ | jD ƒ}dd	„ |D ƒ}g }t|ƒD ]2\}}|f| j ||
|   j }| 
| |¡¡ qÞ|dk�r d}tjt||ƒ| j d�}|| d }t|ƒD ]x}|| ‰t|d | |ƒ‰ ˆˆ k�rx �qÄ| j|‡ ‡fdd	„|	D ƒ|dk	�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   rI  Úu1Fr1  re   Nc                 S  s   g | ]
}|j ‘qS rT   )rÝ  rt  rT   rT   rU   rj   þ  s     z.AppendableTable.write_data.<locals>.<listcomp>c                 S  s   g | ]}|  ¡ ‘qS rT   )r×  rt  rT   rT   rU   rj     s     c              	   S  s,   g | ]$}|  t t |j¡|jd  ¡¡‘qS r”  )Z	transposerQ   ZrollÚarangerO  r,  rT   rT   rU   rj     s     r©  r)  c                   s   g | ]}|ˆˆ … ‘qS rT   rT   rt  ©Zend_iZstart_irT   rU   rj     s     c                   s   g | ]}|ˆˆ … ‘qS rT   rT   r,  r  rT   rU   rj     s     )Úindexesr<  rV  )rÏ  rŒ  r»  r¯  r>   ru  rE  rP   rQ   rÎ  r�   r8  rm   r6  r®  rÏ   rŠ  r  Úreshaper–  rª  rN  Úwrite_data_chunk)rÈ   r¤   r“   rŒ  r  Úmasksr�   r<  Úmr  ÚnindexesrV  Úbvaluesr�  rK  Z	new_shapeÚrowsÚchunksrT   r  rU   r  ã  sL    




üzAppendableTable.write_datarÊ  zlist[np.ndarray]znpt.NDArray[np.bool_] | None)r  r  r<  rV  rZ   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k	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   r)  Fr1  )rQ   r’  r  rm   r–  rÏ  rŒ  rŠ  r6  r8  r„   rE  rt   r�   rþ   )rÈ   r  r  r<  rV  rK  r  rŒ  r  r�  ró  r  rT   rT   rU   r    s&    z AppendableTable.write_data_chunkr\  c                 C  sf  |d kst |ƒsf|d kr:|d kr:| j}| jj| jdd� n(|d k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:  r\  Fr1  re   r   r/  )rm   r  r¾   r�  r¸   rt   Zremove_rowsrþ   r  rÙ  r  r;   Zsort_valuesÚdiffrk   r‘   r�   r   r3  ÚreversedrU  rN  )rÈ   rn   r    r¡   r  rt   rÚ  rV  Zsorted_seriesÚlnr  r°   Zpgr÷   r  rT   rT   rU   r?  J  sF    

 ÿ
zAppendableTable.delete)NFNNNNNNFNNT)F)NNN)	rÜ   r¤  r¥  r¦  r}  r›  r  r  r?  rT   rT   rT   rU   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‡  rH  rE  rF  r„   rÊ   c                 C  s   | j d jdkS )Nr   re   )r®  r'  rÌ   rT   rT   rU   r¿  �  s    z"AppendableFrameTable.is_transposedrÝ  c                 C  s   |r
|j }|S )zthese are written transposed)rx  rÞ  rT   rT   rU   rß  ‘  s    zAppendableFrameTable.get_objectNrƒ   r\  c                   s2  ˆ   |¡ ˆ  ¡ sd S ˆ j|||d�}tˆ jƒrHˆ j ˆ jd d i ¡ni }‡ fdd„tˆ jƒD ƒ}t|ƒdkstt	‚|d }|| d }	g }
tˆ jƒD �]P\}}|ˆ j
kr¬q–|| \}}| d¡dkrÐt|ƒ}n
t |¡}| d¡}|d k	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�}|j|jk ¡ �sÞt	|j|jfƒ‚|
 |¡ q–t|
ƒdk�r|
d }nt|
dd�}tˆ |||d�}ˆ j |||d�}|S )Nr  r   c                   s"   g | ]\}}|ˆ j d  kr|‘qS r"  rÆ  )rg   r�  r¤  rÌ   rT   rU   rj   ®  s      z-AppendableFrameTable.read.<locals>.<listcomp>re   rÛ   r8   rŒ  T©Zinplacer`   r_   Fr¢  r£  rI  )rÚ  r¢   )!r[  r  rÜ  rm   r#  rz  rÓ   rŠ  rA  rÏ   r¯  r7   r8   Úfrom_tuplesÚ	set_namesr¿  rg  rx  rO  rP   rQ   rÎ  r  r  r5   Z_from_arraysZdtypesrÏ  rE  r�   r=   rÙ  r  )rÈ   rn   r¢   r    r¡   rp  rz  ZindsÚindr‘   Úframesr�  r�   Z
index_valsrÝ  rG  rŒ  rV  Zindex_Zcols_r§  rÚ  rT   rÌ   rU   r  ˜  sZ    
ÿý



"
zAppendableFrameTable.read)NNNN)rÜ   r¤  r¥  r¦  rC  r}  rO  r5   rF  r§  r¨  r¿  r=  rß  r  rT   rT   rT   rU   r�  …  s   
    ûr�  c                      sn   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‡ fdd„	Zdddddœ‡ fdd„Z‡  ZS )rŽ  r
  r„  r…  rH  r„   rÊ   c                 C  s   dS rü  rT   rÌ   rT   rT   rU   r¿  ð  s    z#AppendableSeriesTable.is_transposedrÝ  c                 C  s   |S r[   rT   rÞ  rT   rT   rU   rß  ô  s    z AppendableSeriesTable.get_objectNc                   s<   t |tƒs|jpd}| |¡}tƒ jf ||j ¡ dœ|—ŽS )ú+we are going to write this as a frame tablerV  ©r—  r”   )rP   r5   r`   Zto_framerþ  r›  r¢   rö  )rÈ   r—  r”   r¶   r`   rÿ  rT   rU   r›  ø  s    


zAppendableSeriesTable.writerƒ   r;   r`  c                   s�   | j }|d k	rB|rBt| jtƒs"t‚| jD ]}||k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  rV  )r¸  rP   r‹  rk   rÏ   r   rþ  r  Ú	set_indexr  r`   )rÈ   rn   r¢   r    r¡   r¸  rð   rS   rÿ  rT   rU   r  ÿ  s    

zAppendableSeriesTable.read)N)NNNN)rÜ   r¤  r¥  r¦  rC  r}  rO  r;   rF  r¨  r¿  r=  rß  r›  r  r>  rT   rT   rÿ  rU   rŽ  è  s   	    ûrŽ  c                      s(   e Zd ZdZdZdZ‡ fdd„Z‡  ZS )r�  r
  r„  r†  c                   s^   |j pd}|  |¡\}| _t| jtƒs*t‚t| jƒ}| |¡ t|ƒ|_t	ƒ j
f d|i|—ŽS )r!  rV  r—  )r`   r¹  r‹  rP   rk   rÏ   r�   r7   r¢   rþ  r›  )rÈ   r—  r¶   r`   ZnewobjrG  rÿ  rT   rU   r›    s    



z AppendableMultiSeriesTable.write)rÜ   r¤  r¥  r¦  rC  r}  r›  r>  rT   rT   rÿ  rU   r�    s   r�  c                   @  sj   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„ ZdS )r�  z:a table that read/writes the generic pytables table formatr~  r  rH  zlist[Hashable]r‹  rX   rÊ   c                 C  s   | j S r[   )rC  rÌ   rT   rT   rU   rd  2  s    zGenericTable.pandas_typec                 C  s   t | jdd ƒp| jS r¼  r½  rÌ   rT   rT   rU   rX  6  s    zGenericTable.storablerˆ   c                 C  sL   g | _ d| _g | _dd„ | jD ƒ| _dd„ | jD ƒ| _dd„ | jD ƒ| _dS )rt  Nc                 S  s   g | ]}|j r|‘qS rT   rÊ  rt  rT   rT   rU   rj   @  s      z*GenericTable.get_attrs.<locals>.<listcomp>c                 S  s   g | ]}|j s|‘qS rT   rÊ  rt  rT   rT   rU   rj   A  s      c                 S  s   g | ]
}|j ‘qS rT   r_   rt  rT   rT   rU   rj   B  s     )r#  r–   r‹  rË  r®  r¯  r”   rÌ   rT   rT   rU   rW  :  s    zGenericTable.get_attrsc           
   
   C  s¨   | j }|  d¡}|dk	rdnd}tdd| j||d�}|g}t|jƒD ]^\}}t|tƒsZt‚t	||ƒ}|  |¡}|dk	rzdnd}t
|||g|| j||d�}	| |	¡ qD|S )z0create the indexables from the table descriptionr‘   Nrù  r   )r`   r'  rt   rº   rµ  )r`   r´  rV  r³  rt   rº   rµ  )rÚ  rú  rû  rt   rŠ  Z_v_namesrP   rX   rÏ   rg  rA  r�   )
rÈ   rD  rÑ  rº   rÖ  rÕ  r�  rð   r  r\  rT   rT   rU   rË  D  s6    
    ÿ

ù	zGenericTable.indexablesc                 K  s   t dƒ‚d S )Nz cannot write on an generic tabler]  r_  rT   rT   rU   r›  g  s    zGenericTable.writeN)rÜ   r¤  r¥  r¦  rC  r}  rO  r5   rF  r§  r¨  rd  rX  rW  r%   rË  r›  rT   rT   rT   rU   r�  )  s   



"r�  c                      s`   e Zd ZdZdZeZdZe 	d¡Z
eddœdd„ƒZd‡ fd
d„	Zddddœ‡ fdd„Z‡  ZS )r‘  za frame with a multi-indexrˆ  rH  z^level_\d+$rX   rÊ   c                 C  s   dS )NZappendable_multirT   rÌ   rT   rT   rU   r±  s  s    z*AppendableMultiFrameTable.table_type_shortNc                   sx   |d krg }n|dkr |j  ¡ }|  |¡\}| _t| jtƒs@t‚| jD ]}||krF| d|¡ qFtƒ j	f ||dœ|—ŽS )NTr   r"  )
r¢   rö  r¹  r‹  rP   rk   rÏ   r   rþ  r›  )rÈ   r—  r”   r¶   rð   rÿ  rT   rU   r›  w  s    

zAppendableMultiFrameTable.writerƒ   r\  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)rg   r`   rÌ   rT   rU   rj   �  s     z2AppendableMultiFrameTable.read.<locals>.<listcomp>)rþ  r  r#  r‹  r‘   r  rŒ  )rÈ   rn   r¢   r    r¡   r§  rÿ  rÌ   rU   r  ƒ  s    ÿzAppendableMultiFrameTable.read)N)NNNN)rÜ   r¤  r¥  r¦  r}  r5   rF  rO  ÚreÚcompiler$  r¨  r±  r›  r  r>  rT   rT   rÿ  rU   r‘  k  s   
    ûr‘  r5   r   r7   )r—  r'  r  rZ   c                 C  s¢   |   |¡}t|ƒ}|d k	r"t|ƒ}|d ks4| |¡rB| |¡rB| S t| ¡ ƒ}|d k	rlt| ¡ ƒj|dd�}| |¡sžtd d ƒg| j }|||< | jt|ƒ } | S )NF)Úsort)	rù  rE   ÚequalsÚuniquerX  ÚslicerO  rY  rl   )r—  r'  r  rÁ  r¤  ZslicerrT   rT   rU   rç  •  s    

rç  r   zstr | tzinfo)r°  rZ   c                 C  s   t  | ¡}|S )z+for a tz-aware type, return an encoded zone)r   Zget_timezone)r°  ÚzonerT   rT   rU   r„  ¯  s    
r„  znp.ndarray | Indexr6   )rV  r°  r&  rZ   c                 C  s   d S r[   rT   ©rV  r°  r&  rT   rT   rU   rÒ  µ  s    rÒ  rÊ  c                 C  s   d S r[   rT   r-  rT   rT   rU   rÒ  ¼  s    zstr | tzinfo | Noneznp.ndarray | DatetimeIndexc                 C  sŠ   t | tƒr"| jdks"| j|ks"t‚|dk	rtt | tƒrB| j}| 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
    Nr_   rl  úM8[ns]r)  )rP   r6   r°  rÏ   r`   r›  r6  rV   rn  ro  rQ   r4  )rV  r°  r&  r`   rT   rT   rU   rÒ  Á  s    

)r`   r‘   rY   r•   rZ   c              
   C  sŠ  t | tƒst‚|j}t|ƒ\}}t|ƒ}t |¡}t |jt	jƒrHt
|ƒs\t|jƒs\t|jƒr‚t| |||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k�r:t| ||||d�S t |t	jƒ�rT|jtk�sXt‚|dk�sjt|ƒ‚tƒ  ¡ }t| ||||d�S d S )Nr¯  r°  )rV  ra  r³  r¯  r°  r±  zMultiIndex not supported here!Fr—  r   c                 S  s   g | ]}|  ¡ ‘qS rT   )Ú	toordinalr,  rT   rT   rU   rj     s     z"_convert_index.<locals>.<listcomp>r)  )r±  rÞ  )ÚintegerZfloating)rV  ra  r³  r±  r5  )rP   rX   rÏ   r`   r  r  r?  r  rÏ  rQ   r.   r3   r(   r¬  rg  r8   r®   r   r˜  r4  Zint32r€   Z	Time32ColÚ_convert_string_arrayr·  rß  rÎ  r5  r™  )r`   r‘   rY   r•   r±  r;  r  ra  r  r�  rV  r·  rT   rT   rU   r‚  ç  sr    
ÿÿþý

ù


    ÿ

û
    ÿ
r‚  )ra  rY   r•   rZ   c                 C  sÐ   |dkrt | ƒ}nº|dkr$t| ƒ}n¨|dkrxztjdd„ | D ƒtd�}W qÌ tk
rt   tjdd„ | D ƒtd�}Y qÌX nT|dkrŒt | ¡}n@|d	kr¦t| d ||d
�}n&|dkr¾t | d ¡}ntd|› �ƒ‚|S )Nr$  r'  r   c                 S  s   g | ]}t  |¡‘qS rT   r*  r,  rT   rT   rU   rj   0  s     z$_unconvert_index.<locals>.<listcomp>r)  c                 S  s   g | ]}t  |¡‘qS rT   r-  r,  rT   rT   rU   rj   2  s     )r0  Úfloatr„   rÞ  r3  r5  r   zunrecognized index type )r6   r<   rQ   r4  r5  r§   r:  )ru  ra  rY   r•   r‘   rT   rT   rU   r“  '  s,    

    ÿr“  r   rì   )r`   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 k	�rz| |¡}|d k	�rz||k�rz|}|jd|› �dd�}|S )NFr—  r   z+[date] is not implemented as a table columnrb  z>too many timezones in this block, create separate data columnsrÞ  r5  r   zNo.zCannot serialize the column [z2]
because its data contents are not [string] but [z] object dtyperV  z|Sr1  )rÏ  r5  r   rQ   rÎ  r`   r   r˜  r®   r>   rv  rN  r  rm   r1  r  r·  rP   rC  rb   rÓ   r  rä  r8  )r`   r  rå  r’   r–   rY   r•   r¢   r  r�  r<  ru  r�  rÛ  Zerror_column_labelrñ  r·  ZecirT   rT   rU   rê  @  sJ    

ÿÿ 

rê  )ru  rY   r•   rZ   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]
    Fr1  re   ÚSr)  )rm   r;   r6  rX   Úencoder9  r  r  r'   r  Ú
libwritersÚmax_len_string_arrayrQ   r4  )ru  rY   r•   Úensuredr·  rT   rT   rU   r1  ‰  s     ÿþÿr1  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k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.
    r)  ÚUr   Fr1  )r•   Nrä  )r  rQ   r4  r6  r5  rm   r5  r6  r'   rP   rq  r;   rX   rR   r9  r8  Z!string_array_replace_from_nan_repr  )ru  r–   rY   r•   r  r·  rÏ  rT   rT   rU   r:  ¨  s    
r:  )rV  rÓ  rY   r•   c                 C  s6   t |tƒstt|ƒƒ‚t|ƒr2t|||ƒ}|| ƒ} | S r[   )rP   rX   rÏ   rÛ   Ú_need_convertÚ_get_converter)rV  rÓ  rY   r•   ÚconvrT   rT   rU   rÑ  Î  s
    rÑ  ©ra  rY   r•   c                   s8   | dkrdd„ S | dkr&‡ ‡fdd„S t d| › �ƒ‚d S )Nr$  c                 S  s   t j| dd�S )Nr.  r)  )rQ   r4  ©r!  rT   rT   rU   rš   Ø  ó    z _get_converter.<locals>.<lambda>rÞ  c                   s   t | d ˆ ˆd�S )Nr3  )r:  r=  rƒ  rT   rU   rš   Ú  s
      ÿzinvalid kind )r§   r<  rT   rƒ  rU   r:  Ö  s
    r:  r  c                 C  s   | dkrdS dS )N)r$  rÞ  TFrT   r  rT   rT   rU   r9  á  s    r9  zSequence[int])r`   rI  rZ   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   re   rG  rH  zvalues_block_(\d+)Zvalues_)rP   rX   rm   r§   r&  r%  r°   )r`   rI  r  ÚgrprT   rT   rU   rÎ  ç  s    $
rÎ  )Ú	dtype_strrZ   c                 C  sÎ   t | ƒ} |  d¡s|  d¡r"d}n¨|  d¡r2d}n˜|  d¡rBd}nˆ|  d¡sV|  d¡r\d}nn|  d¡rld}n^|  d	¡r|d
}nN|  d¡rŒd}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Þ  rq  r2  r×  rb   r  r0  r$  Ú	timedeltar'  r„   rù  r  r5  zcannot interpret dtype of [r  )rV   rn  r§   )rA  ra  rT   rT   rU   r     s.    






r  r
  c                 C  sb   t | tƒr| j} | jj d¡d }| jjdkr@t |  	d¡¡} nt | t
ƒrP| j} t | ¡} | |fS )zJ
    Convert the passed data into a storable form and a dtype string.
    rP  r   )r  ÚMrÌ  )rP   r?   r  rÏ  r`   rŸ  ra  rQ   r4  rš  r9   r›  )ru  r  rT   rT   rU   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ˆ   )rt   r    r¡   rZ   c              	   C  s@  || _ || _|| _|| _d | _d | _d | _d | _t|ƒ�rt	t
ƒ�¾ tj|dd�}|dkrüt |¡}|jtjkr®| j| j }}|d krŠd}|d krš| j j}t ||¡| | _nNt|jjtjƒrü| jd k	rÖ|| jk  ¡ sî| jd k	rö|| jk ¡ röt
dƒ‚|| _W 5 Q R X | jd k�r<|  |¡| _| jd k	�r<| j ¡ \| _| _d S )NFr—  )r0  Úbooleanr   z3where must have index locations >= start and < stop)rt   rn   r    r¡   Ú	conditionr  Ztermsr-  r/   r   r§   r   r˜  rQ   r4  rÏ  Zbool_r  r  Ú
issubclassrÛ   r0  r7  ÚgenerateÚevaluate)rÈ   rt   rn   r    r¡   ÚinferredrT   rT   rU   rÉ   C  sD    


ÿÿÿzSelection.__init__c              
   C  s€   |dkrdS | j  ¡ }zt||| j jd�W S  tk
rz } z2d | ¡ ¡}td|› d|› d�ƒ}t|ƒ|‚W 5 d}~X Y nX dS )z'where can be a : dict,list,tuple,stringN)rÅ  rY   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
                )	rt   rÅ  rB   rY   Ú	NameErrorr½  rô   r   r§   )rÈ   rn   rÌ  r@  Zqkeysrü   rT   rT   rU   rG  p  s    
ÿûÿ	zSelection.generatec                 C  sX   | j dk	r(| jjj| j  ¡ | j| jd�S | jdk	rB| jj | j¡S | jjj| j| jd�S )ú(
        generate the selection
        Nr\  )	rE  rt   Z
read_wherer�   r    r¡   r-  r  r  rÌ   rT   rT   rU   r³   ‡  s    
  ÿ
zSelection.selectc                 C  s”   | j | j }}| jj}|dkr$d}n|dk r4||7 }|dkrB|}n|dk rR||7 }| jdk	rx| jjj| j ¡ ||dd�S | jdk	rˆ| jS t 	||¡S )rK  Nr   T)r    r¡   r(  )
r    r¡   rt   r  rE  Zget_where_listr�   r-  rQ   r  )rÈ   r    r¡   r  rT   rT   rU   r  “  s(    
   ÿ
zSelection.select_coords)NNN)rÜ   r¤  r¥  r¦  rÉ   rG  r³   r  rT   rT   rT   rU   rÙ  7  s      û-rÙ  )r�   NNFNTNNNNrz   rO   )	NrŸ   rz   NNNNFN)N)F)F)F)°r¦  Ú
__future__r   Ú
contextlibr   rv  rb  r   r   r.  r«   r&  Útextwrapr   Útypesr   Útypingr   r	   r
   r   r   r   r   r   r   r   rð  ZnumpyrQ   Zpandas._configr   r   Zpandas._libsr   r   r5  Zpandas._libs.tslibsr   Zpandas._typingr   r   r   r   r   r   r   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,   r-   r.   r/   r0   r1   r2   r3   Zpandas.core.dtypes.missingr4   rë   r5   r6   r7   r8   r9   r:   r;   r<   r=   r>   Zpandas.core.arraysr?   r@   rA   Zpandas.core.commonÚcoreÚcommonr=  Z pandas.core.computation.pytablesrB   rC   Zpandas.core.constructionrD   Zpandas.core.indexes.apirE   Zpandas.core.internalsrF   rG   Zpandas.io.commonrH   Zpandas.io.formats.printingrI   rJ   r|   rK   rL   rM   rN   rS  r\   rV   r^   ra   rf   ro   rp   r§  rq   rr   r{  rP  rw   rx   Zconfig_prefixZregister_optionZis_boolZis_one_of_factoryr{   r   r€   rž   r·   r±   r�   r  r¬  rû  rý  r?  rA  rB  ra  rŠ  rž  r‹  rò   r’  râ  r�  rŽ  r�  r�  r‘  rç  r„  rÒ  r‚  r“  rê  r1  r:  rÑ  r:  r9  rÎ  r  r  rÙ  rT   rT   rT   rU   Ú<module>   s0  0$	<0
ü            ñ,:         ö            Qp  &   -  e!^       f dc0B+ ÿ ÿ ÿ&@I&!