U
    ÎZj´Ÿ ã                   @  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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+ ddl,m-Z- ddl.m/Z/ ddl0m1Z1m2Z2m3Z3m4Z4m5Z5 ddl6m7Z7 ddl8m9Z9 ddl:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZE ddlFmGZG ddlHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQ ddlRmSZS ddlTmUZUmVZVmWZW ddlXmY  mZZ[ ddl\m]Z]m^Z^ ddl_m`Z` ddlambZb ddlcmdZdmeZe ddlfmgZg ddlhmiZimjZj e�rJddlkmlZlmmZmmnZn ddlcmoZo dZpdZqd d!„ Zrd"d#„ Zsd$d%„ Zte]Zud&d'œd(d)„Zvd*Zwd+exd,< d-Zyd+exd.< d/Zzd+exd0< d1d1d2d2d3œZ{eIdgiZ|d4Z}d+exd5< d6Z~d+exd7< e d8¡�8 ej€d9d:e}ej�d;� ej€d<de~e ‚d1d2dg¡d;� W 5 Q R X daƒd:a„d=d>„ Z…dºdBdCdDdCdEdFdGdFdGdHdIdJdCdCdKdLœdMdN„Z†d»dBdCdCdPdEdEdQdGdEdRœ	dSdT„Z‡dUdUdGdVœdWdX„ZˆG dYdZ„ dZƒZ‰G d[d\„ d\ƒZŠG d]d^„ d^ƒZ‹G d_d`„ d`e‹ƒZŒG dadb„ dbe‹ƒZ�G dcdd„ dde�ƒZŽG dedf„ dfeŽƒZ�G dgdh„ dhƒZ�G didj„ dje�ƒZ‘G dkdl„ dle‘ƒZ’G dmdn„ dne‘ƒZ“G dodp„ dpe“ƒZ”G dqdr„ dre�ƒZ•G dsdt„ dte•ƒZ–G dudv„ dve•ƒZ—G dwdx„ dxe—ƒZ˜G dydz„ dze˜ƒ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‡dGdŒd�œdŽd�„ƒZŸed¾d‹dKdGd�d�œd‘d�„ƒZŸd¿d‹d’dGd“d�œd”d�„ZŸdCd‚dCdCd^d•œd–d—„Z dCdCdCd‹d˜œd™dš„Z¡dCd›dœd�œdždŸ„Z¢d�dCdCd�d œd¡d¢„Z£d�dCdCd�d œd£d¤„Z¤d�dCdCdCd¥œd¦d§„Z¥dCdCdCd¨œd©dª„Z¦dCdGd«œd¬d­„Z§dCd®dCd¯œd°d±„Z¨dCdCd²œd³d´„Z©d›dµœd¶d·„ZªG d¸d¹„ d¹ƒZ«dS )ÀzY
High level interface to PyTables for reading and writing pandas data structures
to disk
é    )Úannotations)ÚsuppressN)ÚdateÚtzinfo)Údedent)
ÚTYPE_CHECKINGÚAnyÚCallableÚFinalÚHashableÚIteratorÚLiteralÚSequenceÚcastÚoverload)ÚconfigÚ
get_option)ÚlibÚwriters)Ú	timezones)ÚAnyArrayLikeÚ	ArrayLikeÚ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_list_likeÚis_string_dtypeÚis_timedelta64_dtypeÚneeds_i8_conversion)Úarray_equivalent)	Ú	DataFrameÚDatetimeIndexÚIndexÚ
MultiIndexÚPeriodIndexÚSeriesÚTimedeltaIndexÚconcatÚisna)Ú
Int64Index)Ú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 unicoderK   )Ú
isinstanceÚnpÚbytes_Údecode)Ús© rQ   úU/var/www/html/TRUCKING_PROJECT/venv/lib/python3.8/site-packages/pandas/io/pytables.pyÚ_ensure_decoded‚   s    
rS   c                 C  s   | d krt } | S ©N)Ú_default_encoding©ÚencodingrQ   rQ   rR   Ú_ensure_encoding‰   s    rX   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
    )rL   Ústr©ÚnamerQ   rQ   rR   Ú_ensure_str‘   s    
r\   Ú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 )Nr`   r^   )r?   ÚTerm)Ú.0Úterm©ÚlevelrQ   rR   Ú
<listcomp>«   s   þz _ensure_term.<locals>.<listcomp>r^   N)rL   ÚlistÚtupler?   ra   Úlen)Úwherer_   rQ   rd   rR   Ú_ensure_term    s    	
þrk   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)Úfro   Útrp   z;
: boolean
    drop ALL nan rows when appending to a table
Ú
dropna_docz~
: format
    default format writing format, if None, then
    put will default to 'fixed' and append will default to 'table'
Ú
format_doczio.hdfZdropna_tableF)Ú	validatorÚdefault_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)ry   rQ   rQ   rR   Ú_tablesä   s    

ÿr}   ÚaTrw   zFilePath | HDFStorerY   úDataFrame | Seriesú
int | Noneú
str | 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ÚerrorsrW   Úreturnc              
     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“   rW   )r�   ©Ústore©
r’   r‘   rW   r“   rŽ   r�   rˆ   r�   r•   r‰   rQ   rR   Ú<lambda>  s   özto_hdf.<locals>.<lambda>c                   s   | j ˆˆ	ˆˆˆˆˆ ˆˆˆd�
S )N)rŽ   r�   r�   r•   r’   r“   rW   r‘   ©Úputr–   r˜   rQ   rR   r™     s   ö)rŠ   r‹   rŒ   N)rD   rL   rY   ÚHDFStore)r‡   rˆ   r‰   rŠ   r‹   rŒ   r�   rŽ   r�   r�   r•   r‘   r’   r“   rW   rq   r—   rQ   r˜   rR   Úto_hdfú   s     
   ÿr�   Úrzstr | list | Nonezlist[str] | None)	r‡   rŠ   r“   rj   Ú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
    -------
    item : 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.Nr`   r^   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.)rj   rŸ   r    r¡   r¢   r£   Ú
auto_close)Ú
ValueErrorrk   rL   rœ   Úis_openÚOSErrorrD   rY   ÚNotImplementedErrorÚosÚpathÚexistsÚ	TypeErrorÚFileNotFoundErrorÚgroupsri   Ú_is_metadata_ofÚ_v_pathnameÚselectÚKeyErrorr   rz   Úclose)r‡   rˆ   rŠ   r“   rj   rŸ   r    r¡   r¢   r£   Úkwargsr—   r¥   r¬   r¯   Zcandidate_only_groupZgroup_to_checkrQ   rQ   rR   Úread_hdf2  sj    O
ÿ

ÿ

ÿÿø

r¶   rI   )ÚgroupÚparent_groupr”   c                 C  sF   | j |j krdS | }|j dkrB|j}||kr:|jdkr:dS |j}qdS )zDCheck if a given group is a metadata group for a given parent_group.Fr`   ÚmetaT)Z_v_depthZ	_v_parentÚ_v_name)r·   r¸   ÚcurrentÚparentrQ   rQ   rR   r°   Í  s    
r°   c                   @  s"  e Zd ZU dZded< ded< 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-„Zd”dd/d0œd1d2„Zd3dœd4d5„Zd6dœd7d8„Z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dGœdHdI„Zd˜ddddJœdKdL„Zd™dddddMœdNdO„ZdšddPœdQdR„Zd›ddUddVdWdddddXœ	dYdZ„Z dœdddœd[d\„Z!d�ddUddVd]dWddd^œd_d`„Z"dždaddbœdcdd„Z#dŸdddeddfœdgdh„Z$didœdjdk„Z%d ddmdnœdodp„Z&ddqdœdrds„Z'ddtdœdudv„Z(d¡dddd dxœdydz„Z)ddœd{d|„Z*d}d~„ Z+dddœd€d�„Z,d¢dƒdddtd„œd…d†„Z-d£ddUddVdddd‡œdˆd‰„Z.dŠd‹œdŒd�„Z/dddŠdŽœd�d�„Z0ddŠdœd‘d’„Z1d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Ú_handlerY   Ú_moder]   Ú
_complevelr‚   Ú_fletcher32r~   NFr€   r†   )rŠ   r‹   Ú
fletcher32r”   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 HDFStorery   zcomplib only supports z compression.r~   r   rŠ   )r¦   r   ÚfiltersZall_complibsZdefault_complibrD   Ú_pathr¾   r½   r¿   Ú_complibrÀ   Ú_filtersÚopen)Úselfr«   rŠ   r‹   rŒ   rÁ   rµ   ry   rQ   rQ   rR   Ú__init__"  s&    
ÿ
zHDFStore.__init__©r”   c                 C  s   | j S rT   ©rÃ   ©rÇ   rQ   rQ   rR   Ú
__fspath__D  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Ë   rQ   rQ   rR   rÏ   G  s    zHDFStore.rootc                 C  s   | j S rT   rÊ   rË   rQ   rQ   rR   ÚfilenameN  s    zHDFStore.filename©rˆ   c                 C  s
   |   |¡S rT   )Úget©rÇ   rˆ   rQ   rQ   rR   Ú__getitem__R  s    zHDFStore.__getitem__©rˆ   r”   c                 C  s   |   ||¡ d S rT   rš   )rÇ   rˆ   r‰   rQ   rQ   rR   Ú__setitem__U  s    zHDFStore.__setitem__c                 C  s
   |   |¡S rT   )ÚremoverÓ   rQ   rQ   rR   Ú__delitem__X  s    zHDFStore.__delitem__rZ   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   rz   ÚtypeÚ__name__)rÇ   r[   rQ   rQ   rR   Ú__getattr__[  s    ÿzHDFStore.__getattr__c                 C  s8   |   |¡}|dk	r4|j}||ks0|dd… |kr4dS dS )zx
        check for existence of this key
        can match the exact pathname or the pathnm w/o the leading '/'
        Nr`   TF)Úget_noder±   )rÇ   rˆ   Únoder[   rQ   rQ   rR   Ú__contains__e  s    
zHDFStore.__contains__c                 C  s   t |  ¡ ƒS rT   )ri   r¯   rË   rQ   rQ   rR   Ú__len__q  s    zHDFStore.__len__c                 C  s   t | jƒ}t| ƒ› d|› d�S )Nú
File path: Ú
)rF   rÃ   rÚ   )rÇ   ZpstrrQ   rQ   rR   Ú__repr__t  s    
zHDFStore.__repr__c                 C  s   | S rT   rQ   rË   rQ   rQ   rR   Ú	__enter__x  s    zHDFStore.__enter__c                 C  s   |   ¡  d S rT   )r´   )rÇ   Úexc_typeÚ	exc_valueÚ	tracebackrQ   rQ   rR   Ú__exit__{  s    zHDFStore.__exit__Úpandasú	list[str])Úincluder”   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 rQ   ©r±   ©rb   ÚnrQ   rQ   rR   rf   •  s     z!HDFStore.keys.<locals>.<listcomp>ÚnativeNc                 S  s   g | ]
}|j ‘qS rQ   rì   rí   rQ   rQ   rR   rf   ™  s    ú/ÚTable)Ú	classnamez8`include` should be either 'pandas' or 'native' but is 'rÙ   )r¯   r½   rÎ   Z
walk_nodesr¦   )rÇ   rë   rQ   rQ   rR   Úkeys~  s    ÿ
ÿzHDFStore.keyszIterator[str]c                 C  s   t |  ¡ ƒS rT   )Úiterró   rË   rQ   rQ   rR   Ú__iter__   s    zHDFStore.__iter__zIterator[tuple[str, list]]c                 c  s   |   ¡ D ]}|j|fV  qdS )ú'
        iterate on key->group
        N)r¯   r±   )rÇ   ÚgrQ   rQ   rR   Úitems£  s    zHDFStore.itemsc                 c  s$   t jdttƒ d� |  ¡ E dH  dS )rö   zTiteritems is deprecated and will be removed in a future version. Use .items instead.©Ú
stacklevelN)ÚwarningsÚwarnÚFutureWarningr$   rø   rË   rQ   rQ   rR   Ú	iteritemsª  s    üzHDFStore.iteritems)rŠ   r”   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µ   ry   ÚmsgrQ   rQ   rR   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Ë   rQ   rQ   rR   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Ë   rQ   rQ   rR   r§   ë  s    
zHDFStore.is_open)Úfsyncr”   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  rQ   rQ   rR   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·   rQ   rQ   rR   rÒ   
  s
    
zHDFStore.get)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  r`   r^   c                   s   ˆj | ||ˆ d�S )N)rŸ   r    rj   r¡   ©Úread©Ú_startÚ_stopÚ_where©r¡   rP   rQ   rR   ÚfuncW  s    zHDFStore.select.<locals>.func©rj   ÚnrowsrŸ   r    r¢   r£   r¥   )rÝ   r³   rk   Ú_create_storerÚ
infer_axesÚTableIteratorr  Ú
get_result)rÇ   rˆ   rj   rŸ   r    r¡   r¢   r£   r¥   r·   r  ÚitrQ   r  rR   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
        r`   r^   z&can only read_coordinates with a table©rj   rŸ   r    )rk   Ú
get_storerrL   rñ   r­   Úread_coordinates)rÇ   rˆ   rj   rŸ   r    ÚtblrQ   rQ   rR   Úselect_as_coordinatesj  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  rL   rñ   r­   Úread_column)rÇ   rˆ   r  rŸ   r    r  rQ   rQ   rR   Úselect_columnŠ  s    #

zHDFStore.select_column)r¥   c
                   sz  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 ƒ}t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
        r`   r^   r   )rˆ   rj   r¡   rŸ   r    r¢   r£   r¥   zkeys must be a list/tuplez keys must have a non-zero lengthNc                   s   g | ]}ˆ   |¡‘qS rQ   )r  ©rb   ÚkrË   rQ   rR   rf   ö  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 rQ   )rL   rñ   ©rb   ÚxrQ   rQ   rR   rf     s     
 c                 S  s   h | ]}|j d  d  ’qS ©r   )Únon_index_axes©rb   rr   rQ   rQ   rR   Ú	<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 )©rj   r¡   rŸ   r    r
  r*  )r  r  r  r¡   rQ   rR   rf     s   ÿz=HDFStore.select_as_multiple.<locals>.func.<locals>.<listcomp>F)ÚaxisÚverify_integrity)r8   Ú_consolidate)r  r  r  Zobjs)r-  r¡   Útblsr  rR   r    s    þz)HDFStore.select_as_multiple.<locals>.funcr  T©Úcoordinates)rk   rL   rg   rh   ri   rY   r²   r­   r¦   r  Ú	itertoolsÚchainÚzipr³   Úis_tableÚpathnamer  r  r  )rÇ   ró   rj   Úselectorr¡   rŸ   r    r¢   r£   r¥   rP   r  rr   r$  Z_tblsr  r  rQ   )r-  r¡   rÇ   r0  rR   Úselect_as_multiple²  sd    +
ø
 ÿ


özHDFStore.select_as_multipleTrw   r   rƒ   r…   )	rˆ   r‰   r‹   r�   r’   r“   Útrack_timesr‘   r”   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_formatro   )rŽ   r�   r�   rŒ   r‹   r�   r•   r’   rW   r“   r:  r‘   )r   Ú_validate_formatÚ_write_to_group)rÇ   rˆ   r‰   rŽ   r�   r�   rŒ   r‹   r�   r•   r’   rW   r“   r:  r‘   rQ   rQ   rR   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

        r`   r^   Nz5trying to remove a node with a non-None where clause!T©Ú	recursivez7can only remove with where on objects written as tablesr  )rk   r  r³   rÎ   Ú	Exceptionr¦   rÝ   Z	_f_removeÚcomÚall_noner·   r6  Údelete)rÇ   rˆ   rj   rŸ   r    rP   ÚerrrÞ   rQ   rQ   rR   r×   t  s2    ÿþ
ÿzHDFStore.remover„   )rˆ   r‰   r‹   r�   r‘   r’   r“   r”   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_tabler;  rp   )rŽ   Úaxesr�   r�   rŒ   r‹   r�   r•   r£   Úexpectedrowsr‘   r’   rW   r“   )r­   r   r<  r=  )rÇ   rˆ   r‰   rŽ   rE  r�   r�   rŒ   r‹   r¡   r�   r•   r£   rF  r‘   r’   rW   r“   rQ   rQ   rR   r�   ­  s6    ;ÿ
ðzHDFStore.appendÚdict)Údr”   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�   )rb   Úcols)r‰   rQ   rR   Ú	<genexpr>P  s     z.HDFStore.append_to_multiple.<locals>.<genexpr>r�   ©r-  c                   s   i | ]\}}|ˆ kr||“qS rQ   rQ   ©rb   rˆ   r‰   )ÚvrQ   rR   Ú
<dictcomp>`  s       z/HDFStore.append_to_multiple.<locals>.<dictcomp>)r’   r�   )r­   rL   rG  r¦   rg   ÚsetÚrangeÚndimÚ	_AXES_MAPrÚ   rø   ÚextendrE  Ú
differencer3   ÚsortedÚget_indexerÚtakeÚvaluesÚnextÚintersectionÚlocÚpopÚreindexr�   )rÇ   rH  r‰   r8  r’   rE  r‘   rµ   r-  Z
remain_keyZremain_valuesr$  ÚorderedZorddZidxsZvalid_indexr�   r�   ÚdcÚvalÚfilteredrQ   )rO  r‰   rR   Úappend_to_multiple  sZ    ÿ
ÿÿ&ÿ

ÿýzHDFStore.append_to_multipler�   )rˆ   ÚoptlevelÚkindr”   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¡   re  rf  )r}   r  rL   rñ   r­   Úcreate_index)rÇ   rˆ   r¡   re  rf  rP   rQ   rQ   rR   Úcreate_table_indexf  s    

zHDFStore.create_table_indexrg   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_typeNrp   )	rL   rx   ÚlinkÚLinkÚgetattrÚ_v_attrsrp   rñ   rº   )rb   r÷   rQ   rQ   rR   rf   �  s    
ùz#HDFStore.groups.<locals>.<listcomp>)r}   rÍ   r½   rÎ   rx   Úwalk_groupsrË   rQ   rQ   rR   r¯   Ž  s    þzHDFStore.groupsrð   z*Iterator[tuple[str, list[str], list[str]]])rj   r”   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`.
        Nri  rð   )r}   rÍ   r½   rÎ   rx   rn  rl  rm  Z_v_childrenrZ  rL   r·   ÚGroupr�   rº   r±   Úrstrip)rÇ   rj   r÷   r¯   ÚleavesÚchildri  rQ   rQ   rR   Ú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Î   rx   rÝ   rÏ   Ú
exceptionsZNoSuchNodeErrorrL   rI   rÚ   )rÇ   rˆ   rÞ   rQ   rQ   rR   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·   rP   rQ   rQ   rR   r  ê  s    

zHDFStore.get_storerrÿ   )Úpropindexesr‹   rÁ   r”   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 rQ   )Ú
is_indexedr[   ©rb   r~   rQ   rQ   rR   rf   $  s      z!HDFStore.copy.<locals>.<listcomp>r’   )r�   r’   rW   rV   )rœ   rg   ró   rL   rh   r  r×   r²   rñ   rE  r�   rl  rW   r›   )rÇ   r{   rŠ   rw  ró   rŒ   r‹   rÁ   Ú	overwriteZ	new_storer$  rP   Údatar�   rQ   rQ   rR   Ú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)rF   rÃ   rÚ   r§   rW  ró   ri   r  r�   r7  rÎ   r@  rE   )
rÇ   r«   ÚoutputZlkeysró   rZ  r$  rP   ÚdetailZdstrrQ   rQ   rR   Úinfo1  s.    


&
zHDFStore.infoc                 C  s   | j st| j› d�ƒ‚d S )Nz file is not open!)r§   r   rÃ   rË   rQ   rQ   rR   rÍ   [  s    zHDFStore._check_if_open)rŽ   r”   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Ž   rD  rQ   rQ   rR   r<  _  s
    $zHDFStore._validate_formatrK   zDataFrame | Series | None)r‰   rW   r“   r”   c              
     s  ˆdk	rt ˆttfƒstdƒ‚‡ ‡‡fdd„}ttˆjddƒƒ}ttˆjddƒƒ}|dkrÆˆdkr¢tƒ  tdk	stt	‚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 n. tk
�r } z|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�rld}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 n. tk
�r } z|dƒ|‚W 5 d}~X Y nX |
| ˆ||d�S )z"return a suitable class to operateNz(value must be None, Series, or DataFramec              	     s$   t d| › dˆ› dtˆƒ› dˆ › �ƒS )Nz(cannot properly create the storer for: [z
] [group->ú,value->z	,format->)r­   rÚ   )rr   ©rŽ   r·   r‰   rQ   rR   Úerrorw  s    ÿz&HDFStore._create_storer.<locals>.errorri  Ú
table_typerp   Úframe_tableÚgeneric_tablezKcannot create a storer if the object is not existing nor a value are passedÚseriesÚframeÚ_table)rŠ  r‹  Ú_STORER_MAP©rW   r“   Úseries_tabler�   r`   Úappendable_seriesÚappendable_multiseriesÚappendable_frameÚappendable_multiframe)r‰  r�  r‘  r’  r“  ÚwormÚ
_TABLE_MAP)rL   r6   r1   r­   rS   rl  rm  r}   rx   rÎ   rp   rñ   ÚSeriesFixedÚ
FrameFixedr³   ÚnlevelsÚGenericTableÚAppendableSeriesTableÚAppendableMultiSeriesTableÚAppendableFrameTableÚAppendableMultiFrameTableÚ	WORMTable)rÇ   r·   rŽ   r‰   rW   r“   r†  ÚptÚttr�  ÚclsrD  r�   r•  rQ   r…  rR   r  i  st     ÿÿ








úzHDFStore._create_storer)rˆ   r‰   r‹   r�   r“   r:  r”   c                 C  sÎ   t |dd ƒr|dks|rd S |  ||¡}| j|||||d�}|rr|jrZ|jrb|dkrb|jrbtdƒ‚|jsz| ¡  n| ¡  |jsŒ|rŒtdƒ‚|j||||||	|
||||||d� t|t	ƒrÊ|rÊ|j
|d� d S )	NÚemptyrp   rŽ  ro   zCan only append to Tablesz0Compression not supported on Fixed format stores)ÚobjrE  r�   rŒ   r‹   rÁ   r�   r£   rF  r‘   r•   r’   r:  )r¡   )rl  Ú_identify_groupr  r6  Ú	is_existsr¦   Úset_object_infoÚwriterL   rñ   rg  )rÇ   rˆ   r‰   rŽ   rE  r�   r�   rŒ   r‹   rÁ   r�   r£   rF  r‘   r•   r’   rW   r“   r:  r·   rP   rQ   rQ   rR   r=  Å  s:    

ózHDFStore._write_to_grouprI   ©r·   c                 C  s   |   |¡}| ¡  | ¡ S rT   )r  r  r  )rÇ   r·   rP   rQ   rQ   rR   r    s    
zHDFStore._read_group)rˆ   r�   r”   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·   rQ   rQ   rR   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Î   Úsplitri   ÚendswithrÝ   Zcreate_group)rÇ   rˆ   Úpathsr«   ÚpÚnew_pathr·   rQ   rQ   rR   rª    s    


z HDFStore._create_nodes_and_group)r~   NNF)ré   )r~   )F)NNNNFNF)NNN)NN)NNNNNFNF)NTFNNNNNNrw   TF)NNN)NNTTNNNNNNNNNNrw   )NNF)NNN)rð   )rÿ   TNNNFT)NNrK   rw   )NTFNNNNNNFNNNrw   T)2rÛ   Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__rÈ   rÌ   ÚpropertyrÏ   rÐ   rÔ   rÖ   rØ   rÜ   rß   rà   rã   rä   rè   ró   rõ   rø   rþ   rÆ   r´   r§   r  rÒ   r²   r  r"  r9  r›   r×   r�   rd  rh  r¯   rs  rÝ   r  r|  r�  rÍ   r<  r  r=  r  r¤  rª  rQ   rQ   rQ   rR   rœ   Û  s  
A    ú"

"-       ÷N   û$  û+        ö~            ñ H=               î]   ùd   û(0       ÷=*    úa               í>rœ   c                   @  sj   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„ 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—   rv  rP   NFr‚   r†   )r—   rP   r¢   r£   r¥   r”   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—   rP   r  rj   r6  Úminr  rŸ   r    r2  r]   r£   r¥   )rÇ   r—   rP   r  rj   r  rŸ   r    r¢   r£   r¥   rQ   rQ   rR   rÈ   H  s,    
zTableIterator.__init__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Ÿ   r2  r¦   r    r¶  r£   r  ri   r´   )rÇ   r»   r    r‰   rQ   rQ   rR   rõ   r  s    

zTableIterator.__iter__rÉ   c                 C  s   | j r| j ¡  d S rT   )r¥   r—   r´   rË   rQ   rQ   rR   r´   ‚  s    zTableIterator.closer1  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)rj   z$can only read_coordinates on a tabler  )r£   rL   rP   rñ   r­   r  rj   r2  rŸ   r    r  r´   )rÇ   r2  rj   ÚresultsrQ   rQ   rR   r  †  s"    
  ÿzTableIterator.get_result)NNFNF)F)	rÛ   r°  r±  r²  r³  rÈ   rõ   r´   r  rQ   rQ   rQ   rR   r  0  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d	ed
< d	ed< dNd	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	d0d1„ ƒZe	d2d3„ ƒZd4d5„ ZdOddœd6d7„Zddœd8d9„Zd:ddd;œd<d=„ZdPd>d?„Zddd@œdAdB„ZddœdCdD„ZddœdEdF„ZddœdGdH„Zd:ddIœdJdK„Z d:ddIœdLdM„Z!dS )QÚ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_namerY   r[   ÚcnameNr�   r†   )r[   r¾  r”   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.)rL   rY   r¦   rZ  rf  Útypr[   r¾  r-  Úposr»  r¼  r½  r`  rp   r¹   ÚmetadataÚset_posrÎ   )rÇ   r[   rZ  rf  r¿  r¾  r-  rÀ  r»  r¼  r½  r`  rp   r¹   rÁ  rQ   rQ   rR   rÈ   µ  s(    


zIndexCol.__init__r]   rÉ   c                 C  s   | j jS rT   )r¿  ÚitemsizerË   rQ   rQ   rR   rÃ  á  s    zIndexCol.itemsizec                 C  s   | j › d�S )NÚ_kindrZ   rË   rQ   rQ   rR   Ú	kind_attræ  s    zIndexCol.kind_attr)rÀ  r”   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À  rQ   rQ   rR   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->rQ   rN  rQ   rQ   rR   rf   õ  s   ÿz%IndexCol.__repr__.<locals>.<listcomp>r[   r¾  r-  rÀ  rf  )
rh   ÚmaprF   r[   r¾  r-  rÀ  rf  Újoinr5  ©rÇ   ÚtemprQ   rQ   rR   rã   ð  s    ÿþÿzIndexCol.__repr__r   ©Úotherr”   c                   s   t ‡ ‡fdd„dD ƒƒS )úcompare 2 col itemsc                 3  s&   | ]}t ˆ|d ƒt ˆ |d ƒkV  qd S rT   ©rl  ry  ©rÍ  rÇ   rQ   rR   rL  ý  s   ÿz"IndexCol.__eq__.<locals>.<genexpr>)r[   r¾  r-  rÀ  ©rI  ©rÇ   rÍ  rQ   rÐ  rR   Ú__eq__û  s    þzIndexCol.__eq__c                 C  s   |   |¡ S rT   )rÓ  rÒ  rQ   rQ   rR   Ú__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 columnrK  F)Úhasattrrp   rl  rK  r¾  rx  rË   rQ   rQ   rR   rx    s    zIndexCol.is_indexedú
np.ndarrayzCtuple[np.ndarray, np.ndarray] | tuple[DatetimeIndex, DatetimeIndex]©rZ  rW   r“   r”   c           
      C  sþ   t |tjƒstt|ƒƒ‚|jjdk	r.|| j }t| j	ƒ}t
||||ƒ}i }t| jƒ|d< | jdk	rpt| 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)r5   )r'  ÚkwdsrQ   rQ   rR   r™   *  s   ÿÿz"IndexCol.convert.<locals>.<lambda>)rL   rM   ÚndarrayrÎ   rÚ   ÚdtypeÚfieldsr¾  rS   rf  Ú_maybe_convertr½  r»  r3   r)   r*   r2   r¦   Ú_set_tzr¼  )
rÇ   rZ  r•   rW   r“   Úval_kindrµ   ÚfactoryZnew_pd_indexZfinal_pd_indexrQ   rQ   rR   Úconvert  s,    


zIndexCol.convertc                 C  s   | j S )zreturn the values©rZ  rË   rQ   rQ   rR   Ú	take_data:  s    zIndexCol.take_datac                 C  s   | j jS rT   )rp   rm  rË   rQ   rQ   rR   Úattrs>  s    zIndexCol.attrsc                 C  s   | j jS rT   ©rp   ÚdescriptionrË   rQ   rQ   rR   ræ  B  s    zIndexCol.descriptionc                 C  s   t | j| jdƒS )z!return my current col descriptionN)rl  ræ  r¾  rË   rQ   rQ   rR   ÚcolF  s    zIndexCol.colc                 C  s   | j S ©zreturn my cython valuesrâ  rË   rQ   rQ   rR   ÚcvaluesK  s    zIndexCol.cvaluesc                 C  s
   t | jƒS rT   )rô   rZ  rË   rQ   rQ   rR   rõ   P  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À  )rS   rf  rL   rG  rÒ   r[   r¿  rÃ  r}   Ú	StringColrÀ  )rÇ   r�   rQ   rQ   rR   Úmaybe_set_sizeS  s
    
zIndexCol.maybe_set_sizec                 C  s   d S rT   rQ   rË   rQ   rQ   rR   Úvalidate_names`  s    zIndexCol.validate_namesÚAppendableTable)Úhandlerr�   r”   c                 C  s:   |j | _ |  ¡  |  |¡ |  |¡ |  |¡ |  ¡  d S rT   )rp   Úvalidate_colÚvalidate_attrÚvalidate_metadataÚwrite_metadataÚset_attr)rÇ   rï  r�   rQ   rQ   rR   Úvalidate_and_setc  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)rS   rf  rç  rÃ  r¦   r¾  )rÇ   rÃ  ÚcrQ   rQ   rR   rð  k  s    
ÿzIndexCol.validate_col)r�   r”   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%  )rl  rä  rÅ  rf  r­   )rÇ   r�   Zexisting_kindrQ   rQ   rR   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½  rù   zinvalid info for [z] for [z], existing_value [z] conflicts with new value [r%  )Ú_info_fieldsrl  Ú
setdefaultr[   rÒ   rm   rû   rü   r   r$   Úsetattrr¦   )rÇ   r�  rˆ   r‰   ÚidxZexisting_valueÚwsrQ   rQ   rR   Ú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Ç   r�  rû  rQ   rQ   rR   Ú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Å  rf  rË   rQ   rQ   rR   rô  ®  s    zIndexCol.set_attr)rï  r”   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¾  r0   r¦   )rÇ   rï  Znew_metadataZcur_metadatarQ   rQ   rR   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ï  rQ   rQ   rR   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Ô  rx  rá  rã  rä  ræ  rç  ré  rõ   rì  rí  rõ  rð  rñ  rý  r   rô  rò  ró  rQ   rQ   rQ   rR   r¸     sf   

             ñ,-




	!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 ©NFrQ   rË   rQ   rQ   rR   rx  Ê  s    zGenericIndexCol.is_indexedrÖ  rY   ztuple[Int64Index, Int64Index]r×  c                 C  s2   t |tjƒst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
        )rL   rM   rÚ  rÎ   rÚ   r:   Úarangeri   )rÇ   rZ  r•   rW   r“   r�   rQ   rQ   rR   rá  Ò  s    zGenericIndexCol.convertr†   c                 C  s   d S rT   rQ   rË   rQ   rQ   rR   rô  ä  s    zGenericIndexCol.set_attrN)rÛ   r°  r±  r²  r´  rx  rá  rô  rQ   rQ   rQ   rR   r  Ç  s
   r  c                      s<  e Zd ZdZdZdZddgZ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.d/„ ƒZed0d1„ ƒZddœd2d3„Zd4ddd5œd6d7„Zddœd8d9„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`  NrY   zDtypeArg | Noner†   )r[   rÛ  r”   c                   s2   t ƒ j|||||||||	|
|d� || _|| _d S )N)r[   rZ  rf  r¿  rÀ  r¾  r¼  r`  rp   r¹   rÁ  )ÚsuperrÈ   rÛ  r{  )rÇ   r[   rZ  rf  r¿  r¾  rÀ  r¼  r`  rp   r¹   rÁ  rÛ  r{  ©Ú	__class__rQ   rR   rÈ   ù  s    õzDataCol.__init__rÉ   c                 C  s   | j › d�S )NÚ_dtyperZ   rË   rQ   rQ   rR   Ú
dtype_attr	  s    zDataCol.dtype_attrc                 C  s   | j › d�S )NÚ_metarZ   rË   rQ   rQ   rR   Ú	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Ç  rQ   rN  rQ   rQ   rR   rf   (	  s   ÿz$DataCol.__repr__.<locals>.<listcomp>r[   r¾  rÛ  rf  Úshape)
rh   rÈ  rF   r[   r¾  rÛ  rf  r  rÉ  r5  rÊ  rQ   rQ   rR   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 rT   rÏ  ry  rÐ  rQ   rR   rL  0	  s   ÿz!DataCol.__eq__.<locals>.<genexpr>)r[   r¾  rÛ  rÀ  rÑ  rÒ  rQ   rÐ  rR   rÓ  .	  s    þzDataCol.__eq__r   )r{  r”   c                 C  s@   |d k	st ‚| jd kst ‚t|ƒ\}}|| _|| _t|ƒ| _d S rT   )rÎ   rÛ  Ú_get_data_and_dtype_namer{  Ú_dtype_to_kindrf  )rÇ   r{  Ú
dtype_namerQ   rQ   rR   Úset_data5	  s    zDataCol.set_datac                 C  s   | j S )zreturn the data©r{  rË   rQ   rQ   rR   rã  ?	  s    zDataCol.take_datarG   )rZ  r”   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.
        r`   ©rf  r   ©rÃ  r  )rÛ  rÃ  r  rS  ÚsizerL   r;   ÚcodesÚget_atom_datar[   r)   r*   Úget_atom_datetime64r.   Úget_atom_timedelta64r(   r}   Z
ComplexColr-   Úget_atom_string)r¡  rZ  rÛ  rÃ  r  r  ÚatomrQ   rQ   rR   Ú	_get_atomC	  s$    


zDataCol._get_atomc                 C  s   t ƒ j||d d�S )Nr   r  ©r}   rë  ©r¡  r  rÃ  rQ   rQ   rR   r  c	  s    zDataCol.get_atom_stringz	type[Col]©rf  r”   c                 C  sR   |  d¡r$|dd… }d|› d�}n"|  d¡r4d}n| ¡ }|› d�}ttƒ |ƒS )z0return the PyTables column class for this columnÚuinté   NZUIntrG   ÚperiodÚInt64Col)rt  Ú
capitalizerl  r}   )r¡  rf  Zk4Zcol_nameZkcaprQ   rQ   rR   Úget_atom_coltypeg	  s    


zDataCol.get_atom_coltypec                 C  s   | j |d�|d d�S )Nr  r   ©r  ©r&  ©r¡  r  rf  rQ   rQ   rR   r  v	  s    zDataCol.get_atom_datac                 C  s   t ƒ j|d d�S ©Nr   r'  ©r}   r$  ©r¡  r  rQ   rQ   rR   r  z	  s    zDataCol.get_atom_datetime64c                 C  s   t ƒ j|d d�S r*  r+  r,  rQ   rQ   rR   r  ~	  s    zDataCol.get_atom_timedelta64c                 C  s   t | jdd ƒS )Nr  )rl  r{  rË   rQ   rQ   rR   r  ‚	  s    zDataCol.shapec                 C  s   | j S rè  r  rË   rQ   rQ   rR   ré  †	  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!)rl  rä  rÅ  rg   rZ  r¦   r  rÛ  )rÇ   r�   Zexisting_fieldsZexisting_dtyperQ   rQ   rR   rñ  ‹	  s    ÿzDataCol.validate_attrrÖ  )rZ  rW   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 rQ   ©r   Úfromordinal©rb   rO  rQ   rQ   rR   rf   Ï	  s     z#DataCol.convert.<locals>.<listcomp>c                 S  s   g | ]}t  |¡‘qS rQ   ©r   Úfromtimestampr5  rQ   rQ   rR   rf   Ó	  s     r  éÿÿÿÿ)Ú
categoriesr`  F©r|  ÚOrê  ©r•   rW   r“   )#rL   rM   rÚ  rÎ   rÚ   rÛ  rÜ  r¾  r¿  r  r  rf  rS   r¹   rÁ  r`  r¼  rÞ  ÚasarrayÚobjectr¦   Úravelr3   Zfloat64r9   ÚanyÚastyper]   ZcumsumÚ_valuesr;   Z
from_codesr­   Ú_unconvert_string_arrayrZ  )rÇ   rZ  r•   rW   r“   Ú	convertedr  rf  r¹   rÁ  r`  r¼  rÛ  r9  r  ÚmaskrQ   rQ   rR   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Å  rZ  r  r¹   rÛ  rÎ   r  rË   rQ   rQ   rR   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__rQ   rQ   r  rR   r  è  sX               ò 





er  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 | jƒ ¡ stdƒ‚d S )Nú-cannot have non-object label DataIndexableCol)r3   rZ  Z	is_objectr¦   rË   rQ   rQ   rR   rí  

  s    zDataIndexableCol.validate_namesc                 C  s   t ƒ j|d�S )N)rÃ  r  r  rQ   rQ   rR   r  
  s    z DataIndexableCol.get_atom_stringrY   rG   r   c                 C  s   | j |d�ƒ S )Nr  r(  r)  rQ   rQ   rR   r  
  s    zDataIndexableCol.get_atom_datac                 C  s
   t ƒ  ¡ S rT   r+  r,  rQ   rQ   rR   r  
  s    z$DataIndexableCol.get_atom_datetime64c                 C  s
   t ƒ  ¡ S rT   r+  r,  rQ   rQ   rR   r  
  s    z%DataIndexableCol.get_atom_timedelta64N)rÛ   r°  r±  r²  rº  rí  rF  r  r  r  r  rQ   rQ   rQ   rR   rH  
  s   

rH  c                   @  s   e Zd ZdZdS )ÚGenericDataIndexableColz(represent a generic pytables data columnN)rÛ   r°  r±  r²  rQ   rQ   rQ   rR   rJ   
  s   rJ  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ed< ded< ded< dZded< dPd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/d0„ƒZeddœd1d2„ƒZed3d4„ ƒZddœd5d6„Zddœd7d8„Zed9d:„ ƒZeddœd;d<„ƒZed=d>„ ƒZd?dœd@dA„ZdQddœdCdD„ZddœdEdF„ZdRdGdGdHœdIdJ„ZdKdL„ ZdSdGdGddMœdNdO„Z dBS )TÚ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.
    rY   Úpandas_kindro   Úformat_typeútype[DataFrame | Series]Úobj_typer]   rS  rW   rœ   r¼   rI   r·   r“   Fr‚   r6  rK   rw   r†   )r¼   r·   rW   r“   r”   c                 C  sZ   t |tƒstt|ƒƒ‚td k	s"t‚t |tjƒs:tt|ƒƒ‚|| _|| _t|ƒ| _	|| _
d S rT   )rL   rœ   rÎ   rÚ   rx   rI   r¼   r·   rX   rW   r“   )rÇ   r¼   r·   rW   r“   rQ   rQ   rR   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   r`   é
   é   )ÚversionrË   rQ   rQ   rR   Úis_old_versionL
  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 rT   ©r]   r&  rQ   rQ   rR   rL  U
  s     z Fixed.version.<locals>.<genexpr>Ú.rQ  r(  )r   r   r   )rS   rl  r·   rm  rh   r«  ri   rz   )rÇ   rR  rQ   rQ   rR   rR  P
  s    
zFixed.versionc                 C  s   t t| jjdd ƒƒS )Nri  )rS   rl  r·   rm  rË   rQ   rQ   rR   ri  \
  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 rQ   ©rF   r&  rQ   rQ   rR   rf   f
  s     z"Fixed.__repr__.<locals>.<listcomp>ú[r%  ú12.12z	 (shape->ú))r  r  rL   rg   rh   rÉ  ri  )rÇ   rP   ZjshaperQ   rQ   rR   rã   `
  s    zFixed.__repr__c                 C  s   t | jƒ| j_t tƒ| j_dS )zset my pandas type & versionN)rY   rL  rä  ri  Ú_versionrT  rË   rQ   rQ   rR   r¦  k
  s    zFixed.set_object_infoc                 C  s   t   | ¡}|S rT   r:  )rÇ   Znew_selfrQ   rQ   rR   r|  p
  s    
z
Fixed.copyc                 C  s   | j S rT   )r  rË   rQ   rQ   rR   r  t
  s    zFixed.shapec                 C  s   | j jS rT   ©r·   r±   rË   rQ   rQ   rR   r7  x
  s    zFixed.pathnamec                 C  s   | j jS rT   )r¼   r½   rË   rQ   rQ   rR   r½   |
  s    zFixed._handlec                 C  s   | j jS rT   )r¼   rÅ   rË   rQ   rQ   rR   rÅ   €
  s    zFixed._filtersc                 C  s   | j jS rT   )r¼   r¿   rË   rQ   rQ   rR   r¿   „
  s    zFixed._complevelc                 C  s   | j jS rT   )r¼   rÀ   rË   rQ   rQ   rR   rÀ   ˆ
  s    zFixed._fletcher32c                 C  s   | j jS rT   )r·   rm  rË   rQ   rQ   rR   rä  Œ
  s    zFixed.attrsc                 C  s   dS ©zset our object attributesNrQ   rË   rQ   rQ   rR   Ú	set_attrs�
  s    zFixed.set_attrsc                 C  s   dS )zget our object attributesNrQ   rË   rQ   rQ   rR   Ú	get_attrs”
  s    zFixed.get_attrsc                 C  s   | j S )zreturn my storabler¨  rË   rQ   rQ   rR   Ústorable˜
  s    zFixed.storablec                 C  s   dS r  rQ   rË   rQ   rQ   rR   r¥  �
  s    zFixed.is_existsc                 C  s   t | jdd ƒS )Nr  )rl  ra  rË   rQ   rQ   rR   r  ¡
  s    zFixed.nrowszLiteral[True] | Nonec                 C  s   |dkrdS dS )z%validate against an existing storableNTrQ   rÒ  rQ   rQ   rR   Úvalidate¥
  s    zFixed.validateNc                 C  s   dS )ú+are we trying to operate on an old version?NrQ   )rÇ   rj   rQ   rQ   rR   Ú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)ra  r`  )rÇ   rP   rQ   rQ   rR   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Ç   rj   r¡   rŸ   r    rQ   rQ   rR   r  º
  s    ÿz
Fixed.readc                 K  s   t dƒ‚d S )Nz?cannot write on an abstract storer: subclasses should implementrf  ©rÇ   rµ   rQ   rQ   rR   r§  Å
  s    ÿzFixed.write©rŸ   r    r”   c                 C  s0   t  |||¡r$| jj| jdd� dS tdƒ‚dS )zs
        support fully deleting the node in its entirety (only) - where
        specification must be None
        Tr>  Nz#cannot delete on an abstract storer)rA  rB  r½   r©  r·   r­   )rÇ   rj   rŸ   r    rQ   rQ   rR   rC  Ê
  s    zFixed.delete)rK   rw   )N)NNNN)NNN)!rÛ   r°  r±  r²  r³  rM  r6  rÈ   r´  rS  rR  ri  rã   r¦  r|  r  r7  r½   rÅ   r¿   rÀ   rä  r_  r`  ra  r¥  r  rb  rd  r  r  r§  rC  rQ   rQ   rQ   rR   rK  &
  sr   
  û







    û     ÿrK  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 rQ   rQ   )rb   r$  rO  rQ   rQ   rR   rP  Ü
  s      zGenericFixed.<dictcomp>rê   Ú
attributesrY   rÉ   c                 C  s   | j  |d¡S )NÚ )Ú_index_type_maprÒ   )rÇ   r¡  rQ   rQ   rR   Ú_class_to_aliasà
  s    zGenericFixed._class_to_aliasc                 C  s   t |tƒr|S | j |t¡S rT   )rL   rÚ   Ú_reverse_index_maprÒ   r3   )rÇ   ÚaliasrQ   rQ   rR   Ú_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_classrm  c                 S  s:   t j| j|d�}tj|d d�}|d k	r6| d¡ |¡}|S )N©r»  rZ   ÚUTC)r<   Ú_simple_newrZ  r2   Útz_localizeÚ
tz_convert)rZ  r»  r¼  ZdtaÚresultrQ   rQ   rR   rq   ò
  s
    z*GenericFixed._get_index_factory.<locals>.fc                 S  s   t j| |d�}tj|d d�S )Nrt  rZ   )r=   rv  r5   )rZ  r»  r¼  ZparrrQ   rQ   rR   rq   ý
  s    r»  r¼  zutf-8)NN)NN)rr  rS   rl  r2   r5   r3   r7   rL   ÚbytesrO   rÎ   )rÇ   rä  rs  rq   rà  rµ   rQ   rQ   rR   Ú_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¡   rj   rQ   rQ   rR   Úvalidate_read  s    ÿÿzGenericFixed.validate_readr‚   c                 C  s   dS )NTrQ   rË   rQ   rQ   rR   r¥  &  s    zGenericFixed.is_existsc                 C  s   | j | j_ | j| j_dS r^  )rW   rä  r“   rË   rQ   rQ   rR   r_  *  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 attributesrW   Nr“   rw   )rX   rl  rä  rW   rS   r“   rl  rú  )rÇ   rî   rQ   rQ   rR   r`  /  s    
zGenericFixed.get_attrsc                 K  s   |   ¡  d S rT   )r_  ©rÇ   r£  rµ   rQ   rQ   rR   r§  7  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  r2  r-  r¼  Tr.  r0  r1  )ry   rl  r·   rm  rL   ZVLArrayrS   rM   r¢  rÞ  r=  ÚT)rÇ   rˆ   rŸ   r    ry   rÞ   rä  r  ÚretrÛ  r  r¼  rQ   rQ   rR   Ú
read_array:  s&    zGenericFixed.read_arrayr3   )rˆ   rŸ   r    r”   c                 C  sh   t t| j|› d�ƒƒ}|dkr.| j|||d�S |dkrVt| j|ƒ}| j|||d�}|S td|› �ƒ‚d S )NÚ_varietyÚmultire  Úregularzunrecognized index variety: )rS   rl  rä  Úread_multi_indexr·   Úread_index_noder­   )rÇ   rˆ   rŸ   r    ZvarietyrÞ   r�   rQ   rQ   rR   Ú
read_index\  s    zGenericFixed.read_index)rˆ   r�   r”   c                 C  sà   t |tƒr,t| j|› d�dƒ |  ||¡ n°t| j|› d�dƒ td|| j| jƒ}|  ||j	¡ t
| j|ƒ}|j|j_|j|j_t |ttfƒr |  t|ƒ¡|j_t |tttfƒrº|j|j_t |tƒrÜ|jd k	rÜt|jƒ|j_d S )Nr„  r…  r†  r�   )rL   r4   rú  rä  Úwrite_multi_indexÚ_convert_indexrW   r“   Úwrite_arrayrZ  rl  r·   rf  rm  r[   r2   r5   ro  rÚ   rs  r7   r»  r¼  Ú_get_tz)rÇ   rˆ   r�   rD  rÞ   rQ   rQ   rR   Úwrite_indexj  s    



zGenericFixed.write_indexr4   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˜  Ú	enumerater5  Úlevelsr  Únamesr+   r©   r‹  rW   r“   rŒ  rZ  rl  r·   rf  rm  r[   )rÇ   rˆ   r�   ÚiÚlevÚlevel_codesr[   Ú	level_keyZ
conv_levelrÞ   Ú	label_keyrQ   rQ   rR   rŠ  �  s"    ÿÿ
zGenericFixed.write_multi_indexc                 C  s¤   t | j|› d�ƒ}g }g }g }t|ƒD ]l}|› d|› �}	t | j|	ƒ}
| j|
||d�}| |¡ | |j¡ |› d|› �}| j|||d�}| |¡ q&t|||dd�S )Nr�  r�  re  r’  T)r”  r  r•  r.  )	rl  rä  rR  r·   rˆ  r�   r[   rƒ  r4   )rÇ   rˆ   rŸ   r    r˜  r”  r  r•  r–  r™  rÞ   r—  rš  r˜  rQ   rQ   rR   r‡  š  s&    
   ÿzGenericFixed.read_multi_indexrI   )rÞ   rŸ   r    r”   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   r2  r[   r   rŽ  rÛ  )rm  rM   Úprodr  r¢  r€  rS   rf  r\   r[   r{  Ú_unconvert_indexrW   r“   r>  )rÇ   rÞ   rŸ   r    r{  rf  r[   rä  rà  rµ   r�   rQ   rQ   rR   rˆ  ±  sF    
   ÿÿüû   ÿÿüzGenericFixed.read_index_noder   )rˆ   r‰   r”   c                 C  sJ   t  d|j ¡}| j | j||¡ t| j|ƒ}t|jƒ|j	_
|j|j	_dS )zwrite a 0-len array©r`   N)rM   r¢  rS  r½   Úcreate_arrayr·   rl  rY   rÛ  rm  r€  r  )rÇ   rˆ   r‰   ZarrrÞ   rQ   rQ   rR   Úwrite_array_empty×  s
    zGenericFixed.write_array_emptyr   zIndex | None)rˆ   r£  rø   r”   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".r�  )rÂ   ©Zskipnarê  rù   rØ  r-  r0  ),r@   r·   r½   r©  r  r'   rÛ  r©   rÕ  r�  rÅ   r   r¦   r}   ZAtomZ
from_dtypeZcreate_carrayr  rŸ  rÚ   rM   Zobject_r   Úinfer_dtypern   rû   rü   r!   r$   Zcreate_vlarrayÚ
ObjectAtomr�   r)   rž  Úviewrl  rm  r€  r*   Úasi8r�  r¼  r.   r  )rÇ   rˆ   r£  rø   r‰   Zempty_arrayr  r  ÚcaÚinferred_typerü  ZvlarrrÞ   rQ   rQ   rR   rŒ  à  sr    


ÿ


    ÿ
  ÿ
zGenericFixed.write_array)NN)NN)NN)NN)N)rÛ   r°  r±  r²  r2   r5   rn  rø   rp  rl  r³  ro  rr  r{  r|  r´  r¥  r_  r`  r§  rƒ  r‰  rŽ  rŠ  r‡  rˆ  rŸ  rŒ  rQ   rQ   rQ   rR   rj  Ø
  s8   
.#   ÿ   ÿ   ÿ&
 ÿrj  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 rT   )ri   r·   rZ  r­   rz   rË   rQ   rQ   rR   r  A  s    zSeriesFixed.shapeNr€   r6   ri  c                 C  s<   |   ||¡ | jd||d�}| jd||d�}t||| jd�S )Nr�   re  rZ  )r�   r[   )r|  r‰  rƒ  r6   r[   )rÇ   rj   r¡   rŸ   r    r�   rZ  rQ   rQ   rR   r  H  s    zSeriesFixed.readr†   rÉ   c                   s8   t ƒ j|f|Ž |  d|j¡ |  d|¡ |j| j_d S )Nr�   rZ  )r  r§  rŽ  r�   rŒ  r[   rä  r~  r  rQ   rR   r§  U  s    zSeriesFixed.write)NNNN)rÛ   r°  r±  rL  rl  r³  r´  r  r  r§  rG  rQ   rQ   r  rR   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 )ÚBlockManagerFixedrS  Únblocksr]   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  r`   )	rS  rR  r¨  rl  r·   Zblock0_valuesrg   r�   rz   )rÇ   rS  rø   r–  rÞ   r  rQ   rQ   rR   r  a  s"    
zBlockManagerFixed.shapeNr€   r1   ri  c                 C  s  |   ||¡ |  ¡  d¡}g }t| jƒD ]<}||kr<||fnd\}}	| jd|› �||	d�}
| |
¡ q(|d }g }t| jƒD ]Z}|  d|› d�¡}| jd|› d�||	d�}|| 	|¡ }t
|j||d d	�}| |¡ q|t|ƒdk�rt|dd
�}|j|dd�}|S t
|d |d d	�S )Nr   )NNr-  re  r©  rª  rB  r`   ©r¡   r�   rM  F)r¡   r|  )r|  rO  Z_get_block_manager_axisrR  rS  r‰  r�   r¨  rƒ  rX  r1   r�  ri   r8   r_  )rÇ   rj   r¡   rŸ   r    Zselect_axisrE  r–  r  r  Úaxrø   ÚdfsÚ	blk_itemsrZ  ÚdfÚoutrQ   rQ   rR   r  |  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-  rB  )rø   rª  )r  r§  rL   Ú_mgrrB   Ú_as_managerZis_consolidatedZconsolidaterS  rä  r“  rE  Z	is_uniquer¦   rŽ  ri   Úblocksr¨  rø   rY  Úmgr_locsrŒ  rZ  )rÇ   r£  rµ   r{  r–  r¬  Úblkr®  r  rQ   rR   r§  ¢  s     

zBlockManagerFixed.write)NNNN)
rÛ   r°  r±  rl  r³  r´  r  r  r§  rG  rQ   rQ   r  rR   r§  \  s   
    û&r§  c                   @  s   e Zd ZdZeZdS )r—  r‹  N)rÛ   r°  r±  rL  r1   rO  rQ   rQ   rQ   rR   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ed< ded< ded< ded< de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
d0dœd1d2„ƒZe
d(dœd3d4„ƒZe
d5d6„ ƒZe
d7d8„ ƒZe
d9d:„ ƒZe
d;d<„ ƒZe
d=d>„ ƒZe
d0dœd?d@„ƒZe
d(dœdAdB„ƒZe
dCdœdDdE„ƒZdFdœdGdH„ZdIdJ„ ZdKdœdLdM„ZdddNœdOdP„ZddQddRœdSdT„ZddUœdVdW„Z ddœdXdY„Z!ddœdZd[„Z"d…ddœd\d]„Z#ddœd^d_„Z$e%d`da„ ƒZ&d†dbddcœddde„Z'd‡dfdfdgdhœdidj„Z(e)d(dkœdldm„ƒZ*dndo„ Z+dˆdpd(dqœdrds„Z,e-dpd(dtœdudv„ƒZ.d‰dwdpdxœdydz„Z/dfd(dfdFd{œd|d}„Z0dŠdfdfd~œdd€„Z1d‹ddfdfd�œ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_tablerp   rY   rM  r‡  r`   zint | list[Hashable]r”  Tzlist[IndexCol]Ú
index_axeszlist[tuple[int, Any]]r)  zlist[DataCol]Úvalues_axesrg   r’   rÁ  rG  r�  Nrw   rœ   rI   r†   )r¼   r·   r“   r”   c                   sP   t ƒ j||||d� |pg | _|p$g | _|p.g | _|p8g | _|	pBi | _|
| _d S )NrŽ  )r  rÈ   r¶  r)  r·  r’   r�  r•   )rÇ   r¼   r·   rW   r“   r¶  r)  r·  r’   r�  r•   r  rQ   rR   rÈ   æ  s    




zTable.__init__rÉ   c                 C  s   | j  d¡d S )NÚ_r   )r‡  r«  rË   rQ   rQ   rR   Ú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 )rW  rÆ  rm  z,dc->[r%  rV  c                 S  s   g | ]}t |ƒ‘qS rQ   ©rY   r&  rQ   rQ   rR   rf     s     z"Table.__repr__.<locals>.<listcomp>rY  c                 S  s   g | ]
}|j ‘qS rQ   rZ   ry  rQ   rQ   rR   rf   
  s     rZ  z (typ->z,nrows->z,ncols->z,indexers->[r[  )r  ri   r’   rÉ  rS  rR  r¶  ri  r¹  r  Úncols)rÇ   Zjdcra  ÚverZjverZjindex_axesrQ   rQ   rR   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)rE  r[   )rÇ   rö  r~   rQ   rQ   rR   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­   rl  r“  r¦   r@  )rÇ   rÍ  rö  ÚsvÚovr–  ÚsaxZoaxrQ   rQ   rR   rb    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)rL   r”  rg   rË   rQ   rQ   rR   Úis_multi_index:  s    zTable.is_multi_indexr   z tuple[DataFrame, list[Hashable]])r£  r”   c              
   C  s^   t  |jj¡}z| ¡ }W n, t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)	rA  Zfill_missing_namesr�   r•  Zreset_indexr¦   rL   r1   rÎ   )rÇ   r£  r”  Z	reset_objrD  rQ   rQ   rR   Úvalidate_multiindex?  s    ÿþzTable.validate_multiindexr]   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  ©rb   r–  rQ   rQ   rR   rf   S  s     z(Table.nrows_expected.<locals>.<listcomp>)rM   r›  r¶  rË   rQ   rQ   rR   Únrows_expectedP  s    zTable.nrows_expectedc                 C  s
   d| j kS )zhas this table been createdrp   r¨  rË   rQ   rQ   rR   r¥  U  s    zTable.is_existsc                 C  s   t | jdd ƒS ©Nrp   ©rl  r·   rË   rQ   rQ   rR   ra  Z  s    zTable.storablec                 C  s   | j S )z,return the table group (this is my storable))ra  rË   rQ   rQ   rR   rp   ^  s    zTable.tablec                 C  s   | j jS rT   )rp   rÛ  rË   rQ   rQ   rR   rÛ  c  s    zTable.dtypec                 C  s   | j jS rT   rå  rË   rQ   rQ   rR   ræ  g  s    zTable.descriptionc                 C  s   t  | j| j¡S rT   )r3  r4  r¶  r·  rË   rQ   rQ   rR   rE  k  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 rT   )ri   rZ  ry  rQ   rQ   rR   rL  r  s     zTable.ncols.<locals>.<genexpr>)Úsumr·  rË   rQ   rQ   rR   r»  o  s    zTable.ncolsc                 C  s   dS r  rQ   rË   rQ   rQ   rR   Úis_transposedt  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(  rU  ry  rQ   rQ   rR   rf   }  s     z*Table.data_orientation.<locals>.<listcomp>c                 S  s   g | ]}t |jƒ‘qS rQ   )r]   r-  ry  rQ   rQ   rR   rf   ~  s     )rh   r3  r4  r)  r¶  rË   rQ   rQ   rR   Údata_orientationx  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   r`   c                 S  s   g | ]}|j |f‘qS rQ   ©r¾  ry  rQ   rQ   rR   rf   ˆ  s     z$Table.queryables.<locals>.<listcomp>c                   s   g | ]\}}ˆ | d f‘qS rT   rQ   )rb   r-  rZ  )Ú
axis_namesrQ   rR   rf   ‰  s     c                   s&   g | ]}|j tˆ jƒkr|j|f‘qS rQ   )r[   rQ  r’   r¾  r5  rË   rQ   rR   rf   Š  s     )r¶  r)  r·  rG  )rÇ   Zd1Zd2Zd3rQ   )rË  rÇ   rR   Ú
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 rQ   )r-  r¾  rÂ  rQ   rQ   rR   rf   •  s     z$Table.index_cols.<locals>.<listcomp>©r¶  rË   rQ   rQ   rR   Ú
index_cols’  s    zTable.index_colsrê   c                 C  s   dd„ | j D ƒS )zreturn a list of my values colsc                 S  s   g | ]
}|j ‘qS rQ   rÊ  rÂ  rQ   rQ   rR   rf   ™  s     z%Table.values_cols.<locals>.<listcomp>)r·  rË   rQ   rQ   rR   Úvalues_cols—  s    zTable.values_colsrÕ   c                 C  s   | j j}|› d|› d�S )z)return the metadata pathname for this keyz/meta/z/metar]  r	  rQ   rQ   rR   Ú_get_metadata_path›  s    zTable._get_metadata_pathrÖ  )rˆ   rZ  r”   c                 C  s,   | j j|  |¡t|ƒ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
        rp   )rŽ   rW   r“   r•   N)r¼   r›   rÐ  r6   rW   r“   r•   )rÇ   rˆ   rZ  rQ   rQ   rR   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)rl  r·   r¼   r²   rÐ  rÓ   rQ   rQ   rR   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)rY   r‡  rä  rÎ  rÏ  r)  r’   r•   rW   r“   r”  r�  rË   rQ   rQ   rR   r_  ¸  s    





zTable.set_attrsc                 C  s°   t | jddƒpg | _t | jddƒp$g | _t | jddƒp8i | _t | jddƒ| _tt | jddƒƒ| _tt | jddƒƒ| _	t | jd	dƒp„g | _
d
d„ | jD ƒ| _dd„ | jD ƒ| _dS )r}  r)  Nr’   r�  r•   rW   r“   rw   r”  c                 S  s   g | ]}|j r|‘qS rQ   ©r¹  ry  rQ   rQ   rR   rf   Î  s      z#Table.get_attrs.<locals>.<listcomp>c                 S  s   g | ]}|j s|‘qS rQ   rÑ  ry  rQ   rQ   rR   rf   Ï  s      )rl  rä  r)  r’   r�  r•   rX   rW   rS   r“   r”  Ú
indexablesr¶  r·  rË   rQ   rQ   rR   r`  Å  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 )rc  NrV  c                 S  s   g | ]}t |ƒ‘qS rQ   rº  r&  rQ   rQ   rR   rf   Õ  s     z*Table.validate_version.<locals>.<listcomp>rù   )rS  rl   rÉ  rR  rû   rü   r    r$   )rÇ   rj   rü  rQ   rQ   rR   rd  Ñ  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
        NrZ  zmin_itemsize has the key [z%] which is not an axis or data_column)rL   rG  rÌ  r¦   )rÇ   r�   Úqr$  rQ   rQ   rR   Ú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À  rf  r¿  rp   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¾  rZ  rf  rÀ  r¿  rp   r¹   rÁ  rÛ  )rL   rY   rÎ   r  rH  rl  Ú_maybe_adjust_namerR  r  r  rp   )r–  rö  Úklassr  Úadj_namerZ  rÛ  rf  Úmdr¹   r£  )Úbase_posra  ÚdescrÇ   Útable_attrsrQ   rR   rq     s0    

özTable.indexables.<locals>.fc                   s   g | ]\}}ˆ ||ƒ‘qS rQ   rQ   )rb   r–  rö  )rq   rQ   rR   rf   :  s     z$Table.indexables.<locals>.<listcomp>)ræ  rp   rä  r“  rÎ  rl  r  r¸  r�   rQ  r’   ri   rU  rÏ  )rÇ   Ú_indexablesr–  r-  r[   r  rØ  r¹   rÅ  rf  Ú	index_colrQ   )rÙ  ra  rÚ  rq   rÇ   rÛ  rR   rÒ  ò  s2    


ø

% zTable.indexablesr�   r   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 rQ   )rº  r¾  ry  rQ   rQ   rR   rf   c  s      z&Table.create_index.<locals>.<listcomp>re  rf  Ú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   r`   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  rE  rL   rh   rg   rp   rl  rK  rx  r�   re  rf  Zremove_indexrÚ   rt  r­   rg  r)  rz   )rÇ   r¡   re  rf  Úkwrp   rö  rO  r�   Zcur_optlevelZcur_kindrQ   rQ   rR   rg  >  sJ    


ÿÿzTable.create_indexr€   z!list[tuple[ArrayLike, ArrayLike]]ri  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  r<  )
Ú	Selectionr²   rE  r   r�  rá  r•   rW   r“   r�   )	rÇ   rj   rŸ   r    Ú	selectionrZ  r·  r~   ÚresrQ   rQ   rR   Ú
_read_axes”  s    
üzTable._read_axes©r  c                 C  s   |S )zreturn the data for this objrQ   ©r¡  r£  r  rQ   rQ   rR   Ú
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Ú   r4   z"cannot use a multi-index on axis [z] with data_columns TNc                   s    g | ]}|d kr|ˆ kr|‘qS râ  rQ   r#  )Úexisting_data_columnsrQ   rR   rf   ×  s    þz/Table.validate_data_columns.<locals>.<listcomp>c                   s   g | ]}|ˆ kr|‘qS rQ   rQ   )rb   rö  )Úaxis_labelsrQ   rR   rf   ß  s      )
ri   r�  rÒ   r¦   rg   rL   rG  rQ  rU  ró   )rÇ   r’   r�   r)  r-  r�  rQ   )rè  rç  rR   Úvalidate_data_columns»  s*    ÿ


þÿ	zTable.validate_data_columnsr1   )r£  rb  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 rQ   )Ú_get_axis_numberry  )r£  rQ   rR   rf     s     z&Table._create_axes.<locals>.<listcomp>Tc                 S  s   g | ]
}|j ‘qS rQ   rM  ry  rQ   rQ   rR   rf     s     FrQ  r`   z<currently only support ndim-1 indexers in an AppendableTableÚnanc                   s   g | ]}|ˆ kr|‘qS rQ   rQ   r&  )rE  rQ   rR   rf   *  s      rÉ  r•  rÚ   rI  zIncompatible appended table [z]with existing table [Zvalues_block_)Úexisting_colr�   r•   rW   r“   r¡   r¼  r  r:  )r[   r¾  rZ  r¿  rÀ  rf  r¼  r`  r¹   rÁ  rÛ  r{  c                 S  s   g | ]}|j r|j‘qS rQ   )rº  r[   )rb   rç  rQ   rQ   rR   rf   ²  s      )
r¼   r·   rW   r“   r¶  r)  r·  r’   r�  r•   r”  )DrL   r1   r·   rº   r­   rÚ   r  r¶  rg   r’   r•   r�  rS  rÎ   ri   r¦   rE  r)  r0   rM   ÚarrayrW  rù  r•  rÛ   r�   Z_get_axis_namer‹  rW   r“   r-  rÂ  rý  rì  Ú_reindex_axisré  ræ  r/  Ú_get_blocks_and_itemsr·  r“  r5  r  rH  rY   Ú
IndexErrorr³   Ú_maybe_convert_for_string_atomrZ  rÕ  rR  r  r  rÛ  r[   rl  r�  r¼  r'   r`  r9  r?  r  r¼   rÕ  r”  rÔ  rb  )/rÇ   rE  r£  rb  r•   r’   r�   r·   Útable_existsZnew_infoÚnew_non_index_axesrû  r~   Zappend_axisZindexerZ
exist_axisr�  Ú	axis_nameZ	new_indexZnew_index_axesÚjr  r‹  r³  r®  Zvaxesr–  rµ  Úb_itemsrÖ  r[   rì  rD  Únew_nameÚdata_convertedr×  r¿  rf  r¼  r¹   rÁ  r`  r{  r  rç  ZdcsZ	new_tablerQ   )rE  r£  rR   Ú_create_axesá  s"    
ÿ
ÿ
 ÿ





  ÿ    ÿ"ÿýø


ô

ö

zTable._create_axes)r‹  rò  c                 C  sz  t | jtƒr|  d¡} dd„ }| j}tt|ƒ}t|jƒ}||ƒ}t|ƒr¾|d \}	}
t	|
ƒ 
t	|ƒ¡}| j||	d�j}t|jƒ}||ƒ}|D ]0}| j|g|	d�j}| |j¡ | ||ƒ¡ qŒ|�rrdd„ t||ƒD ƒ}g }g }|D ]„}t|jƒ}z&| |¡\}}| |¡ | |¡ W qä ttfk
�rf } 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 rQ   )rø   rY  r´  )rb   rµ  ©ÚmgrrQ   rR   rf   Ú  s     zFTable._get_blocks_and_items.<locals>.get_blk_items.<locals>.<listcomp>)r³  rú  rQ   rú  rR   Úget_blk_itemsÙ  s    z2Table._get_blocks_and_items.<locals>.get_blk_itemsr   rM  c                 S  s"   i | ]\}}t | ¡ ƒ||f“qS rQ   )rh   Útolist)rb   Úbrö  rQ   rQ   rR   rP  ó  s   ÿ
 z/Table._get_blocks_and_items.<locals>.<dictcomp>rÆ  c                 S  s   g | ]}t |ƒ‘qS rQ   rX  )rb   ÚitemrQ   rQ   rR   rf      s     z/Table._get_blocks_and_items.<locals>.<listcomp>z+cannot match existing table structure for [z] on appending data)rL   r±  rB   r²  r   rC   rg   r³  ri   r3   rV  r_  rU  r5  rh   rZ  r^  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ö  rD  ZjitemsrQ   rQ   rR   rï  Ë  sN    



þ


ÿýzTable._get_blocks_and_itemsrà  )rá  r”   c           
        sª   |dk	rt |ƒ}|dk	rNˆjrNtˆjt ƒs.t‚ˆjD ]}||kr4| d|¡ q4ˆjD ]\}}tˆ |||ƒ‰ qT|jdk	r¦|j 	¡ D ]$\}‰}‡ ‡‡fd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 )NrM  r`   zcannot find the field [z] for filtering!)Z_AXIS_ORDERSrê  Ú	_get_axisrÎ   rÀ  Úunionr3   r”  r]  rA   rl  rZ  rL   r1   r¦   )ÚfieldÚfiltrô  Zaxis_numberZaxis_valuesZtakersrZ  ©r£  ÚoprÇ   rQ   rR   Úprocess_filter  s"    





z*Table.process_axes.<locals>.process_filter)
rg   rÀ  rL   r”  rÎ   Úinsertr)  rî  ÚfilterrŽ   )
rÇ   r£  rá  r¡   rî   r-  Úlabelsr  r  r  rQ   r  rR   Úprocess_axes
  s    

!zTable.process_axes)r‹   rÁ   rF  r”   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'  rp   )r[   rF  c                 S  s   i | ]}|j |j“qS rQ   )r¾  r¿  ry  rQ   rQ   rR   rP  S  s      z,Table.create_description.<locals>.<dictcomp>ræ  é	   )r‹   rŒ   rÁ   rÂ   )ÚmaxrÃ  rE  r¿   r}   r   rÀ   rÅ   )rÇ   rŒ   r‹   rÁ   rF  rH  rÂ   rQ   rQ   rR   Úcreate_descriptionD  s     	

ý


zTable.create_descriptionre  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  Nr`   re  )rd  r  rà  Úselect_coordsr  rŽ   r!  r¶  r  ÚilocrZ  r3   )
rÇ   rj   rŸ   r    rá  Zcoordsr  r  r  r{  rQ   rQ   rR   r  c  s    

  
ÿ zTable.read_coordinatesr   c                 C  sº   |   ¡  |  ¡ sdS |dk	r$tdƒ‚| jD ]z}||jkr*|jsNtd|› d�ƒ‚t| jj	|ƒ}| 
| j¡ |j|||… | j| j| jd�}tt|d |jƒ|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 indexabler<  r`   rZ   z] not found in the table)rd  r  r­   rE  r[   rº  r¦   rl  rp   rK  r   r�  rá  r•   rW   r“   r6   rÞ  r¼  r³   )rÇ   r  rj   rŸ   r    r~   rö  Z
col_valuesrQ   rQ   rR   r!  }  s*    


ÿ
üzTable.read_column)Nrw   NNNNNN)N)NNN)NN)TNNN)N)NNN)NNN)4rÛ   r°  r±  r²  rL  rM  r³  r”  r6  rÈ   r´  r¹  rã   rÔ   rb  rÀ  rÁ  rÃ  r¥  ra  rp   rÛ  ræ  rE  r»  rÇ  rÈ  rÌ  rÎ  rÏ  rÐ  ró  r  r_  r`  rd  rÔ  r#   rÒ  rg  rã  rF  ræ  ré  rù  Ústaticmethodrï  r
  r  r  r!  rG  rQ   rQ   r  rR   rñ   Á  s²   
        õ"




	
L     ÿW   ÿ"*    ù k>:      ÿ   û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€   re  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 readNrf  rg  rQ   rQ   rR   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 writeNrf  rh  rQ   rQ   rR   r§  ¾  s    zWORMTable.write)NNNN)rÛ   r°  r±  r²  r‡  r  r§  rQ   rQ   rQ   rR   rž  ©  s       ûrž  c                   @  sd   e Zd ZdZ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d„Zddddœdd„ZdS )rî  ú(support the new appendable table formatsZ
appendableNFTr‚   r†   )r�   r‘   r”   c                 C  s²   |s| j r| j | jd¡ | j||||||d�}|jD ]}| ¡  q6|j s~|j||||	d�}| ¡  ||d< |jj	|jf|Ž |j
|j_
|jD ]}| ||¡ qŽ|j||
d� d S )Nrp   )rE  r£  rb  r�   r•   r’   )rŒ   r‹   rÁ   rF  r:  )r‘   )r¥  r½   r©  r·   rù  rE  rí  r  r_  Zcreate_tabler�  rä  rõ  Ú
write_data)rÇ   r£  rE  r�   rŒ   r‹   rÁ   r�   r£   rF  r‘   r•   r’   r:  rp   r~   ÚoptionsrQ   rQ   rR   r§  Í  s4    
ú	

ü

zAppendableTable.writer€   )r£   r‘   r”   c                   sÌ  | j j}| j}g }|rT| jD ]6}t|jƒjdd�}t|tj	ƒr| 
|jddd�¡ qt|ƒrˆ|d }|dd… D ]}||@ }qp| ¡ }nd}dd	„ | jD ƒ}	t|	ƒ}
|
dks´t|
ƒ‚d
d	„ | jD ƒ}dd	„ |D ƒ}g }t|ƒD ]6\}}|f| j ||
|   j }| 
||  |¡¡ qÞ|dk�r$d}tjt||ƒ| j d�}|| d }t|ƒD ]x}|| ‰t|d | |ƒ‰ ˆˆ k�r| �qÈ| j|‡ ‡fdd	„|	D ƒ|dk	�rª|ˆˆ … nd‡ ‡fdd	„|D ƒd� �qNdS )z`
        we form the data into a 2-d including indexes,values,mask write chunk-by-chunk
        r   rM  Úu1Fr:  r`   Nc                 S  s   g | ]
}|j ‘qS rQ   )ré  ry  rQ   rQ   rR   rf   $  s     z.AppendableTable.write_data.<locals>.<listcomp>c                 S  s   g | ]}|  ¡ ‘qS rQ   )rã  ry  rQ   rQ   rR   rf   *  s     c              	   S  s,   g | ]$}|  t t |j¡|jd  ¡¡‘qS r�  )Z	transposerM   Zrollr  rS  r5  rQ   rQ   rR   rf   +  s     rµ  r2  c                   s   g | ]}|ˆˆ … ‘qS rQ   rQ   ry  ©Zend_iZstart_irQ   rR   rf   ?  s     c                   s   g | ]}|ˆˆ … ‘qS rQ   rQ   r5  r  rQ   rR   rf   A  s     )ÚindexesrE  rZ  )rÛ  r•  rÃ  r·  r9   r{  rI  rL   rM   rÚ  r�   rA  ri   r?  r¶  rÎ   r“  r  Úreshaper¢  r¶  rR  Úwrite_data_chunk)rÇ   r£   r‘   r•  r  Zmasksr~   rE  Úmr  ÚnindexesrZ  Úbvaluesr–  rO  Z	new_shapeÚrowsÚchunksrQ   r  rR   r  	  sL    




üzAppendableTable.write_datarÖ  zlist[np.ndarray]znpt.NDArray[np.bool_] | None)r  r  rE  rZ  r”   c                 C  sä   |D ]}t  |j¡s dS q|d jd }|t|ƒkrFt j|| jd�}| jj}t|ƒ}t|ƒD ]\}	}
|
|||	 < q^t|ƒD ]\}	}||||	|  < q||d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   r2  Fr:  )rM   r›  r  ri   r¢  rÛ  r•  r“  r?  rA  r‚   rI  rp   r�   r  )rÇ   r  r  rE  rZ  rO  r  r•  r  r–  rû  r  rQ   rQ   rR   r  D  s&    z AppendableTable.write_data_chunkre  c                 C  sb  |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|ƒ ¡ }t |ƒ}	|	�r^| ¡ }
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>  re  r`   r   r8  )ri   r  r½   r©  r·   rp   Zremove_rowsr  r  rà  r  r6   Zsort_valuesÚdiffrg   r�   r�   r  r^  ÚreversedrY  rR  )rÇ   rj   rŸ   r    r  rp   rá  rZ  Zsorted_seriesÚlnr  r¯   Zpgr÷   r  rQ   rQ   rR   rC  p  sF    

 ÿ
zAppendableTable.delete)NFNNNNNNFNNT)F)NNN)	rÛ   r°  r±  r²  r‡  r§  r  r  rC  rQ   rQ   rQ   rR   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’  rQ  rN  rO  r‚   rÉ   c                 C  s   | j d jdkS )Nr   r`   )r¶  r-  rË   rQ   rQ   rR   rÇ  µ  s    z"AppendableFrameTable.is_transposedrä  c                 C  s   |r
|j }|S )zthese are written transposed)r�  rå  rQ   rQ   rR   ræ  ¹  s    zAppendableFrameTable.get_objectNr€   re  c                   s0  ˆ   |¡ ˆ  ¡ 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 �]N\}}|ˆ 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�}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Í  )rb   r–  r¬  rË   rQ   rR   rf   ×  s      z-AppendableFrameTable.read.<locals>.<listcomp>r`   rÚ   r4   r•  T©Zinplacer[   rZ   r«  rM  )rá  r¡   )!rd  r  rã  ri   r)  r�  rÒ   r“  rE  rÎ   r·  r3   r4   Úfrom_tuplesÚ	set_namesrÇ  rl  r�  rS  rL   rM   rÚ  r  r  r1   Z_from_arraysZdtypesrÛ  rI  r�   r8   rà  r
  )rÇ   rj   r¡   rŸ   r    ry  r�  ZindsÚindr�   Úframesr–  r~   Z
index_valsré  rK  r•  rZ  Zindex_Zcols_r¯  rá  rQ   rË   rR   r  À  sZ    	
ÿý



"
zAppendableFrameTable.read)NNNN)rÛ   r°  r±  r²  rL  r‡  rS  r1   rO  r³  r´  rÇ  rF  ræ  r  rQ   rQ   rQ   rR   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�  rQ  r‚   rÉ   c                 C  s   dS r  rQ   rË   rQ   rQ   rR   rÇ    s    z#AppendableSeriesTable.is_transposedrä  c                 C  s   |S rT   rQ   rå  rQ   rQ   rR   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 tablerZ  ©r£  r’   )rL   r1   r[   Zto_framer  r§  r¡   rý  )rÇ   r£  r’   rµ   r[   r  rQ   rR   r§  !  s    


zAppendableSeriesTable.writer€   r6   ri  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!  rZ  )rÀ  rL   r”  rg   rÎ   r  r  r  Ú	set_indexr  r[   )rÇ   rj   r¡   rŸ   r    rÀ  rî   rP   r  rQ   rR   r  (  s    

zAppendableSeriesTable.read)N)NNNN)rÛ   r°  r±  r²  rL  r‡  rS  r6   rO  r´  rÇ  rF  ræ  r§  r  rG  rQ   rQ   r  rR   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&  rZ  r£  )r[   rÁ  r”  rL   rg   rÎ   r�   r3   r¡   r  r§  )rÇ   r£  rµ   r[   ZnewobjrK  r  rQ   rR   r§  H  s    



z AppendableMultiSeriesTable.write)rÛ   r°  r±  r²  rL  r‡  r§  rG  rQ   rQ   r  rR   r›  B  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‰  rQ  zlist[Hashable]r”  rY   rÉ   c                 C  s   | j S rT   )rL  rË   rQ   rQ   rR   ri  \  s    zGenericTable.pandas_typec                 C  s   t | jdd ƒp| jS rÄ  rÅ  rË   rQ   rQ   rR   ra  `  s    zGenericTable.storabler†   c                 C  sL   g | _ d| _g | _dd„ | jD ƒ| _dd„ | jD ƒ| _dd„ | jD ƒ| _dS )r}  Nc                 S  s   g | ]}|j r|‘qS rQ   rÑ  ry  rQ   rQ   rR   rf   j  s      z*GenericTable.get_attrs.<locals>.<listcomp>c                 S  s   g | ]}|j s|‘qS rQ   rÑ  ry  rQ   rQ   rR   rf   k  s      c                 S  s   g | ]
}|j ‘qS rQ   rZ   ry  rQ   rQ   rR   rf   l  s     )r)  r•   r”  rÒ  r¶  r·  r’   rË   rQ   rQ   rR   r`  d  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-  rp   r¹   rÁ  )r[   rÀ  rZ  r¿  rp   r¹   rÁ  )ræ  r  r  rp   r“  Z_v_namesrL   rY   rÎ   rl  rJ  r�   )
rÇ   rH  rØ  r¹   rÝ  rÜ  r–  rî   r  ra  rQ   rQ   rR   rÒ  n  s6    
    ÿ

ù	zGenericTable.indexablesc                 K  s   t dƒ‚d S )Nz cannot write on an generic tablerf  rh  rQ   rQ   rR   r§  ‘  s    zGenericTable.writeN)rÛ   r°  r±  r²  rL  r‡  rS  r1   rO  r³  r´  ri  ra  r`  r#   rÒ  r§  rQ   rQ   rQ   rR   r™  S  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“  rQ  z^level_\d+$rY   rÉ   c                 C  s   dS )NZappendable_multirQ   rË   rQ   rQ   rR   r¹  �  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”  rL   rg   rÎ   r  r  r§  )rÇ   r£  r’   rµ   rî   r  rQ   rR   r§  ¡  s    

zAppendableMultiFrameTable.writer€   re  c                   sD   t ƒ j||||d�}| ˆ j¡}|j ‡ fdd„|jjD ƒ¡|_|S )Nr,  c                   s    g | ]}ˆ j  |¡rd n|‘qS rT   )Ú
_re_levelsÚsearch)rb   r[   rË   rQ   rR   rf   º  s     z2AppendableMultiFrameTable.read.<locals>.<listcomp>)r  r  r(  r”  r�   r#  r•  )rÇ   rj   r¡   rŸ   r    r¯  r  rË   rR   r  ­  s    ÿzAppendableMultiFrameTable.read)N)NNNN)rÛ   r°  r±  r²  r‡  r1   rO  rS  ÚreÚcompiler)  r´  r¹  r§  r  rG  rQ   rQ   r  rR   r�  •  s   
    ûr�  r1   r3   )r£  r-  r	  r”   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   rA   ÚequalsÚuniquer\  ÚslicerS  r]  rh   )r£  r-  r	  rÍ  r¬  ZslicerrQ   rQ   rR   rî  À  s    

rî  r   zstr | tzinfo)r¼  r”   c                 C  s   t  | ¡}|S )z+for a tz-aware type, return an encoded zone)r   Zget_timezone)r¼  ÚzonerQ   rQ   rR   r�  Ø  s    
r�  znp.ndarray | Indexr2   )rZ  r¼  r/  r”   c                 C  s   d S rT   rQ   ©rZ  r¼  r/  rQ   rQ   rR   rÞ  Þ  s    rÞ  rÖ  c                 C  s   d S rT   rQ   r2  rQ   rQ   rR   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
    NrZ   ru  úM8[ns]r2  )rL   r2   r¼  rÎ   r[   r¤  r?  rS   rw  rx  rM   r=  )rZ  r¼  r/  r[   rQ   rQ   rR   rÞ  ê  s    

)r[   r�   rW   r“   r”   c              
   C  s~  t | tƒst‚|j}t|ƒ\}}t|ƒ}t |¡}t |tƒsPt	|j
ƒsPt|j
ƒrvt| |||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ƒ�rH|j
tk�sLt‚|dk�s^t|ƒ‚tƒ  ¡ }t| ||||d�S d S )Nr»  r¼  )rZ  rf  r¿  r»  r¼  r½  zMultiIndex not supported here!Fr   r   c                 S  s   g | ]}|  ¡ ‘qS rQ   )Ú	toordinalr5  rQ   rQ   rR   rf   6  s     z"_convert_index.<locals>.<listcomp>r2  )r½  rê  )ÚintegerZfloating)rZ  rf  r¿  r½  r>  )rL   rY   rÎ   r[   r  r  rH  r  r:   r/   rÛ  r&   r¸  rl  r4   r­   r   r¡  rM   r=  Zint32r}   Z	Time32ColÚ_convert_string_arrayrÃ  rë  rÚ  r>  r¢  )r[   r�   rW   r“   r½  rD  r  rf  r  r¦  rZ  rÃ  rQ   rQ   rR   r‹    sn    
ÿþý

ù


    ÿ

û
    ÿ
r‹  )rf  rW   r“   r”   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-  r0  r   c                 S  s   g | ]}t  |¡‘qS rQ   r3  r5  rQ   rQ   rR   rf   Z  s     z$_unconvert_index.<locals>.<listcomp>r2  c                 S  s   g | ]}t  |¡‘qS rQ   r6  r5  rQ   rQ   rR   rf   \  s     )r5  Úfloatr‚   rê  r<  r>  r   zunrecognized index type )r2   r7   rM   r=  r>  r¦   rC  )r{  rf  rW   r“   r�   rQ   rQ   rR   rœ  Q  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rBtdƒ‚n&|	dkrTtdƒ‚n|	dksh|dksh|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ƒ�rBt| | ¡�p>| d¡�p>d	ƒ}t|�pLd	|ƒ}|d k	�r~| |¡}|d k	�r~||k�r~|}|jd|› �dd�}|S )NFr   r   z+[date] is not implemented as a table columnrk  z>too many timezones in this block, create separate data columnsrê  r>  r   zNo.zCannot serialize the column [z2]
because its data contents are not [string] but [z] object dtyperZ  z|Sr:  )rÛ  r>  r   rM   rÚ  r[   r   r¡  r­   r9   r|  rR  r  ri   r6  r  rÃ  rL   rG  r]   rÒ   r  rð  rA  )r[   r  rì  r�   r•   rW   r“   r¡   r  r¦  rE  r{  r–  rç  Zerror_column_labelrø  rÃ  ZecirQ   rQ   rR   rñ  j  sJ    

ÿÿ 

rñ  )r{  rW   r“   r”   c                 C  s\   t | ƒr(t|  ¡ ƒ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]
    r`   ÚSr2  )ri   r6   r?  rY   ÚencoderB  r  r  r%   r  Ú
libwritersÚmax_len_string_arrayrM   r=  )r{  rW   r“   ÚensuredrÃ  rQ   rQ   rR   r6  µ  s     ÿþÿr6  c                 C  s˜   | j }tj|  ¡ td�} t| ƒrvt t| ƒ¡}d|› �}t	| d t
ƒr^t| ƒ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.
    r2  ÚUr   )r“   Fr:  Nrë  )r  rM   r=  r?  r>  ri   r:  r;  r%   rL   rz  r6   rY   rO   rB  rA  Z!string_array_replace_from_nan_repr  )r{  r•   rW   r“   r  rÃ  rÛ  rQ   rQ   rR   rC  Ô  s    
rC  )rZ  rß  rW   r“   c                 C  s6   t |tƒstt|ƒƒ‚t|ƒr2t|||ƒ}|| ƒ} | S rT   )rL   rY   rÎ   rÚ   Ú_need_convertÚ_get_converter)rZ  rß  rW   r“   ÚconvrQ   rQ   rR   rÝ  û  s
    rÝ  ©rf  rW   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 )Nr3  r2  )rM   r=  ©r'  rQ   rQ   rR   r™     ó    z _get_converter.<locals>.<lambda>rê  c                   s   t | d ˆ ˆd�S )Nr<  )rC  rB  rŽ  rQ   rR   r™     s
      ÿzinvalid kind )r¦   rA  rQ   rŽ  rR   r?    s
    r?  r   c                 C  s   | dkrdS dS )N)r-  rê  TFrQ   r  rQ   rQ   rR   r>    s    r>  zSequence[int])r[   rR  r”   c                 C  sl   t |tƒst|ƒdk rtdƒ‚|d dkrh|d dkrh|d dkrht d| ¡}|rh| ¡ d }d|› �} | S )	zö
    Prior to 0.10.1, we named values blocks like: values_block_0 an the
    name values_0, adjust the given name if necessary.

    Parameters
    ----------
    name : str
    version : Tuple[int, int, int]

    Returns
    -------
    str
    é   z6Version is incorrect, expected sequence of 3 integers.r   r`   rP  rQ  zvalues_block_(\d+)Zvalues_)rL   rY   ri   r¦   r+  r*  r¯   )r[   rR  r  ÚgrprQ   rQ   rR   rÕ    s    $
rÕ  )Ú	dtype_strr”   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ê  rz  r7  rÞ  r]   r!  r5  r-  Ú	timedeltar0  r‚   r  r#  r>  zcannot interpret dtype of [r%  )rS   rt  r¦   )rF  rf  rQ   rQ   rR   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.
    rY  r   )r  ÚMrØ  )rL   r;   r  rÛ  r[   r«  rf  rM   r=  r£  r5   r¤  )r{  r  rQ   rQ   rR   r  N  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†   )rp   rŸ   r    r”   c              	   C  sR  || _ || _|| _|| _d | _d | _d | _d | _t|ƒ�rt	t
ƒ�Ð tj|dd�}|dksd|dk�rt |¡}|jtjkr¸| j| j }}|d kr”d}|d kr¤| j j}t ||¡| | _nVt|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�rN|  |¡| _| jd k	�rN| j ¡ \| _| _d S )NFr   r5  Úbooleanr   z3where must have index locations >= start and < stop)rp   rj   rŸ   r    Ú	conditionr  Ztermsr2  r,   r   r¦   r   r¡  rM   r=  rÛ  Zbool_r  r  Ú
issubclassrÚ   r5  r@  ÚgenerateÚevaluate)rÇ   rp   rj   rŸ   r    ÚinferredrQ   rQ   rR   rÈ   p  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Ì  rW   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
                )	rp   rÌ  r>   rW   Ú	NameErrorrÉ  ró   r   r¦   )rÇ   rj   rÓ  rD  Zqkeysr  rQ   rQ   rR   rL  Ÿ  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
        Nre  )	rJ  rp   Z
read_whererŽ   rŸ   r    r2  r  r  rË   rQ   rQ   rR   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 )rP  Nr   T)rŸ   r    r-  )
rŸ   r    rp   r  rJ  Zget_where_listrŽ   r2  rM   r  )rÇ   rŸ   r    r  rQ   rQ   rR   r  Â  s(    
   ÿ
zSelection.select_coords)NNN)rÛ   r°  r±  r²  rÈ   rL  r²   r  rQ   rQ   rQ   rR   rà  d  s      û/rà  )r~   NNFNTNNNNrw   rK   )	Nrž   rw   NNNNFN)N)F)F)F)¬r²  Ú
__future__r   Ú
contextlibr   r|  rk  r   r   r3  rª   r+  Útextwrapr   Útypingr   r   r	   r
   r   r   r   r   r   r   rû   ÚnumpyrM   Zpandas._configr   r   Zpandas._libsr   r   r:  Zpandas._libs.tslibsr   Zpandas._typingr   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-   r.   r/   Zpandas.core.dtypes.missingr0   ré   r1   r2   r3   r4   r5   r6   r7   r8   r9   Zpandas.core.apir:   Zpandas.core.arraysr;   r<   r=   Zpandas.core.commonÚcoreÚcommonrA  Z pandas.core.computation.pytablesr>   r?   Zpandas.core.constructionr@   Zpandas.core.indexes.apirA   Zpandas.core.internalsrB   rC   Zpandas.io.commonrD   Zpandas.io.formats.printingrE   rF   ry   rG   rH   rI   rJ   r\  rU   rS   rX   r\   ra   rk   rl   r³  rm   rn   r‚  rT  rs   rt   Zconfig_prefixZregister_optionZis_boolZis_one_of_factoryrx   r|   r}   r�   r¶   r°   rœ   r  r¸  r  r  rH  rJ  rK  rj  r–  r§  r—  rñ   rž  rî  rœ  rš  r›  r™  r�  rî  r�  rÞ  r‹  rœ  rñ  r6  rC  rÝ  r?  r>  rÕ  r  r  rà  rQ   rQ   rQ   rR   Ú<module>   s.  0 4,
ü            ñ,:         ö            _p  )!   3  e!`       o gd1B+ ÿ ÿ&AK'!