U
    ?vf                    @  s"  U d Z ddlmZ ddlmZ ddlZddlmZmZ ddl	Z	ddl
Z
ddlZddlmZ ddlmZ ddlmZmZmZmZmZmZmZmZmZmZ ddlZddlZdd	lmZm Z  dd
l!m"Z"m#Z$ ddl%m&Z& ddl'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z. ddl/m0Z0 ddl1m2Z2 ddl3m4Z4m5Z5m6Z6m7Z7m8Z8 ddl9m:Z: ddl;m<Z< ddl=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJ ddlKmLZL ddlMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZW ddlXmYZYmZZZm[Z[ ddl\m]  m^Z_ ddl`maZambZb ddlcmdZd ddlemfZf ddlgmhZhmiZi ddljmkZk ddllmmZmmnZn erZddlompZpmqZqmrZr ddlgmsZs dZtdZud d! Zvd"d#d$d%d&Zwd'd( ZxeaZyd)d*d+d,Zzd-Z{d.e|d/< d0Z}d.e|d1< d2Z~d.e|d3< d4d4d5d5d6ZeNdgiZd7Zd.e|d8< d9Zd.e|d:< ed;8 ejd<d=eejd> ejd?deed4d5dgd> W 5 Q R X dad=ad@dA ZddEd#dFd#dGd"dHd"dHdIdJdKd#d#dLdMdNdOZddEd#d#dQdGdGdRdHdGdS	dTdUZdVdVdHdWdXdYZG dZd[ d[ZG d\d] d]ZG d^d_ d_ZG d`da daeZG dbdc dceZG ddde deeZG dfdg dgeZG dhdi diZG djdk dkeZG dldm dmeZG dndo doeZG dpdq dqeZG drds dseZG dtdu dueZG dvdw dweZG dxdy dyeZG dzd{ d{eZG d|d} d}eZG d~d deZG dd deZddddddddZdddddZeddddHddddZedddLdHddddZddddHddddZd#dd#d#d_dddZd#d#d#ddddZd#dddddZdd#d#ddddZdd#d#ddddZdd#d#d#dddZd#d#d#dddZd#dHdddZd#dd#dddZd#d#dddZddddZG dd dZdS )zY
High level interface to PyTables for reading and writing pandas data structures
to disk
    )annotations)suppressN)datetzinfo)dedent)TracebackType)
TYPE_CHECKINGAnyCallableFinalHashableIteratorLiteralSequencecastoverload)config
get_option)libwriters)	timezones)AnyArrayLike	ArrayLikeAxisIntDtypeArgFilePathShapenpt)import_optional_dependency)patch_pickle)AttributeConflictWarningClosedFileErrorIncompatibilityWarningPerformanceWarningPossibleDataLossError)cache_readonly)find_stack_level)ensure_objectis_bool_dtypeis_categorical_dtypeis_complex_dtypeis_datetime64_dtypeis_datetime64tz_dtypeis_extension_array_dtypeis_integer_dtypeis_list_likeis_object_dtypeis_string_dtypeis_timedelta64_dtypeneeds_i8_conversion)array_equivalent)
	DataFrameDatetimeIndexIndex
MultiIndexPeriodIndex
RangeIndexSeriesTimedeltaIndexconcatisna)CategoricalDatetimeArrayPeriodArray)PyTablesExprmaybe_expression)extract_array)ensure_index)ArrayManagerBlockManager)stringify_path)adjoinpprint_thing)ColFileNode)Blockz0.15.2UTF-8c                 C  s   t | tjr| d} | S )z(if we have bytes, decode them to unicoderO   )
isinstancenpZbytes_decode)s rT   6/tmp/pip-unpacked-wheel-vdrwu74i/pandas/io/pytables.py_ensure_decoded   s    
rV   
str | Nonestr)encodingreturnc                 C  s   | d krt } | S N)_default_encodingrY   rT   rT   rU   _ensure_encoding   s    r^   c                 C  s   t | trt| } | S )z
    Ensure that an index / column name is a str (python 3); otherwise they
    may be np.string dtype. Non-string dtypes are passed through unchanged.

    https://github.com/pandas-dev/pandas/issues/13492
    )rP   rX   namerT   rT   rU   _ensure_str   s    
ra   intscope_levelc                   sV   |d  t | ttfr* fdd| D } nt| r>t|  d} | dksNt| rR| S dS )z
    Ensure that the where is a Term or a list of Term.

    This makes sure that we are capturing the scope of variables that are
    passed create the terms here with a frame_level=2 (we are 2 levels down)
       c                   s0   g | ](}|d k	rt |r(t| d dn|qS )Nre   rc   )rC   Term).0ZtermlevelrT   rU   
<listcomp>   s   z _ensure_term.<locals>.<listcomp>rc   N)rP   listtuplerC   rf   len)whererd   rT   rh   rU   _ensure_term   s    	
ro   z
where criteria is being ignored as this version [%s] is too old (or
not-defined), read the file in and write it out to a new file to upgrade (with
the copy_to method)
r   incompatibility_doczu
the [%s] attribute of the existing index is [%s] which conflicts with the new
[%s], resetting the attribute to None
attribute_conflict_docz
your performance may suffer as PyTables will pickle object types that it cannot
map directly to c-types [inferred_type->%s,key->%s] [items->%s]
performance_docfixedtable)frs   trt   z;
: boolean
    drop ALL nan rows when appending to a table

dropna_docz~
: format
    default format writing format, if None, then
    put will default to 'fixed' and append will default to 'table'

format_doczio.hdfZdropna_tableF)Z	validatordefault_formatc               	   C  s8   t d kr4dd l} | a tt | jjdkaW 5 Q R X t S )Nr   strict)
_table_modtablesr   AttributeErrorfileZ_FILE_OPEN_POLICY!_table_file_open_policy_is_strict)r|   rT   rT   rU   _tables   s    

r   aTrz   zFilePath | HDFStoreDataFrame | Series
int | Noneboolint | dict[str, int] | Nonebool | None Literal[True] | list[str] | NoneNone)path_or_bufkeyvaluemode	complevelcomplibappendformatindexmin_itemsizedropnadata_columnserrorsrY   rZ   c              
     s   |r$ 	f
dd}n 	f
dd}t | } t| trzt| |||d}|| W 5 Q R X n||  dS )z+store this object, close it if we opened itc                   s   | j 	 d
S )N)r   r   r   nan_repr   r   r   rY   )r   store
r   r   rY   r   r   r   r   r   r   r   rT   rU   <lambda>  s   zto_hdf.<locals>.<lambda>c                   s   | j 	 d
S )N)r   r   r   r   r   r   rY   r   putr   r   rT   rU   r     s   )r   r   r   N)rH   rP   rX   HDFStore)r   r   r   r   r   r   r   r   r   r   r   r   r   r   rY   ru   r   rT   r   rU   to_hdf   s     
   r   rzstr | list | Nonezlist[str] | None)	r   r   r   rn   startstopcolumnsiterator	chunksizec
                 K  s  |dkrt d| d|dk	r,t|dd}t| trN| jsDtd| }d}nvt| } t| tshtd	zt	j
| }W n tt fk
r   d}Y nX |std
|  dt| f||d|
}d}zx|dkr"| }t|dkrt d|d }|dd D ]}t||s t dq |j}|j|||||||	|dW S  t ttfk
r   t| ts|tt |  W 5 Q R X  Y nX dS )a"	  
    Read from the store, close it if we opened it.

    Retrieve pandas object stored in file, optionally based on where
    criteria.

    .. warning::

       Pandas uses PyTables for reading and writing HDF5 files, which allows
       serializing object-dtype data with pickle when using the "fixed" format.
       Loading pickled data received from untrusted sources can be unsafe.

       See: https://docs.python.org/3/library/pickle.html for more.

    Parameters
    ----------
    path_or_buf : str, path object, pandas.HDFStore
        Any valid string path is acceptable. Only supports the local file system,
        remote URLs and file-like objects are not supported.

        If you want to pass in a path object, pandas accepts any
        ``os.PathLike``.

        Alternatively, pandas accepts an open :class:`pandas.HDFStore` object.

    key : object, optional
        The group identifier in the store. Can be omitted if the HDF file
        contains a single pandas object.
    mode : {'r', 'r+', 'a'}, default 'r'
        Mode to use when opening the file. Ignored if path_or_buf is a
        :class:`pandas.HDFStore`. Default is 'r'.
    errors : str, default 'strict'
        Specifies how encoding and decoding errors are to be handled.
        See the errors argument for :func:`open` for a full list
        of options.
    where : list, optional
        A list of Term (or convertible) objects.
    start : int, optional
        Row number to start selection.
    stop  : int, optional
        Row number to stop selection.
    columns : list, optional
        A list of columns names to return.
    iterator : bool, optional
        Return an iterator object.
    chunksize : int, optional
        Number of rows to include in an iteration when using an iterator.
    **kwargs
        Additional keyword arguments passed to HDFStore.

    Returns
    -------
    object
        The selected object. Return type depends on the object stored.

    See Also
    --------
    DataFrame.to_hdf : Write a HDF file from a DataFrame.
    HDFStore : Low-level access to HDF files.

    Examples
    --------
    >>> df = pd.DataFrame([[1, 1.0, 'a']], columns=['x', 'y', 'z'])  # doctest: +SKIP
    >>> df.to_hdf('./store.h5', 'data')  # doctest: +SKIP
    >>> reread = pd.read_hdf('./store.h5')  # doctest: +SKIP
    )r   r+r   zmode zG is not allowed while performing a read. Allowed modes are r, r+ and a.Nre   rc   z&The HDFStore must be open for reading.Fz5Support for generic buffers has not been implemented.zFile z does not exist)r   r   Tr   z]Dataset(s) incompatible with Pandas data types, not table, or no datasets found in HDF5 file.z?key must be provided when HDF5 file contains multiple datasets.)rn   r   r   r   r   r   
auto_close)
ValueErrorro   rP   r   is_openOSErrorrH   rX   NotImplementedErrorospathexists	TypeErrorFileNotFoundErrorgroupsrm   _is_metadata_of_v_pathnameselectKeyErrorr   r}   close)r   r   r   r   rn   r   r   r   r   r   kwargsr   r   r   r   Zcandidate_only_groupZgroup_to_checkrT   rT   rU   read_hdf6  sj    O






r   rM   )groupparent_grouprZ   c                 C  sF   | j |j krdS | }|j dkrB|j}||kr:|jdkr:dS |j}qdS )zDCheck if a given group is a metadata group for a given parent_group.Fre   metaT)Z_v_depthZ	_v_parent_v_name)r   r   currentparentrT   rT   rU   r     s    
r   c                   @  s(  e Zd ZU dZded< ded< ddd	d
ddddZddddZedd ZeddddZ	ddddZ
dddddZdddddZdddd Zdd
dd!d"Zd#dd$d%Zddd&d'Zd dd(d)Zd*d+d,dd-d.d/Zddd1d2d3d4Zd5dd6d7Zd8dd9d:Zdddd;d<d=Zddd>d?Zed
dd@dAZdd
ddBdCdDZdddEdFZddd
d
dGdHdIZddd	d	dJdKdLZdddd	d	dMdNdOZdd
d
dPdQdRZdddUd
d
d	dVdWdd
d
ddXdYdZZddddd[d\Z dddUd]d
d	dVd^dWddd_
d`daZ!ddbd
ddcdddeZ"ddd	dfddgdhdiZ#djddkdlZ$dddndodpdqZ%ddrddsdtZ&dduddvdwZ'ddd
d	d
d
d dydzd{Z(ddd|d}Z)d~d Z*dddddZ+dddddudddZ,dddUd]d
d	dVd
dd
dd
ddZ-ddddZ.dd
ddddZ/dddddZ0dS )r   aa	  
    Dict-like IO interface for storing pandas objects in PyTables.

    Either Fixed or Table format.

    .. warning::

       Pandas uses PyTables for reading and writing HDF5 files, which allows
       serializing object-dtype data with pickle when using the "fixed" format.
       Loading pickled data received from untrusted sources can be unsafe.

       See: https://docs.python.org/3/library/pickle.html for more.

    Parameters
    ----------
    path : str
        File path to HDF5 file.
    mode : {'a', 'w', 'r', 'r+'}, default 'a'

        ``'r'``
            Read-only; no data can be modified.
        ``'w'``
            Write; a new file is created (an existing file with the same
            name would be deleted).
        ``'a'``
            Append; an existing file is opened for reading and writing,
            and if the file does not exist it is created.
        ``'r+'``
            It is similar to ``'a'``, but the file must already exist.
    complevel : int, 0-9, default None
        Specifies a compression level for data.
        A value of 0 or None disables compression.
    complib : {'zlib', 'lzo', 'bzip2', 'blosc'}, default 'zlib'
        Specifies the compression library to be used.
        As of v0.20.2 these additional compressors for Blosc are supported
        (default if no compressor specified: 'blosc:blosclz'):
        {'blosc:blosclz', 'blosc:lz4', 'blosc:lz4hc', 'blosc:snappy',
         'blosc:zlib', 'blosc:zstd'}.
        Specifying a compression library which is not available issues
        a ValueError.
    fletcher32 : bool, default False
        If applying compression use the fletcher32 checksum.
    **kwargs
        These parameters will be passed to the PyTables open_file method.

    Examples
    --------
    >>> bar = pd.DataFrame(np.random.randn(10, 4))
    >>> store = pd.HDFStore('test.h5')
    >>> store['foo'] = bar   # write to HDF5
    >>> bar = store['foo']   # retrieve
    >>> store.close()

    **Create or load HDF5 file in-memory**

    When passing the `driver` option to the PyTables open_file method through
    **kwargs, the HDF5 file is loaded or created in-memory and will only be
    written when closed:

    >>> bar = pd.DataFrame(np.random.randn(10, 4))
    >>> store = pd.HDFStore('test.h5', driver='H5FD_CORE')
    >>> store['foo'] = bar
    >>> store.close()   # only now, data is written to disk
    zFile | None_handlerX   _moder   NFr   r   r   )r   r   
fletcher32rZ   c                 K  s   d|krt dtd}|d k	r@||jjkr@t d|jj d|d krX|d k	rX|jj}t|| _|d krnd}|| _d | _|r|nd| _	|| _
|| _d | _| jf d|i| d S )	Nr   z-format is not a defined argument for HDFStorer|   zcomplib only supports z compression.r   r   r   )r   r   filtersZall_complibsZdefault_complibrH   _pathr   r   
_complevel_complib_fletcher32_filtersopen)selfr   r   r   r   r   r   r|   rT   rT   rU   __init__$  s&    	
zHDFStore.__init__rZ   c                 C  s   | j S r[   r   r   rT   rT   rU   
__fspath__E  s    zHDFStore.__fspath__c                 C  s   |    | jdk	st| jjS )zreturn the root nodeN)_check_if_openr   AssertionErrorrootr   rT   rT   rU   r   H  s    zHDFStore.rootc                 C  s   | j S r[   r   r   rT   rT   rU   filenameO  s    zHDFStore.filenamer   c                 C  s
   |  |S r[   )getr   r   rT   rT   rU   __getitem__S  s    zHDFStore.__getitem__r   rZ   c                 C  s   |  || d S r[   r   )r   r   r   rT   rT   rU   __setitem__V  s    zHDFStore.__setitem__c                 C  s
   |  |S r[   )remover   rT   rT   rU   __delitem__Y  s    zHDFStore.__delitem__r_   c              	   C  sF   z|  |W S  ttfk
r$   Y nX tdt| j d| ddS )z$allow attribute access to get stores'z' object has no attribute 'N)r   r   r!   r}   type__name__)r   r`   rT   rT   rU   __getattr__\  s    zHDFStore.__getattr__c                 C  s4   |  |}|dk	r0|j}|||dd fkr0dS dS )zx
        check for existence of this key
        can match the exact pathname or the pathnm w/o the leading '/'
        Nre   TF)get_noder   )r   r   noder`   rT   rT   rU   __contains__f  s    
zHDFStore.__contains__rb   c                 C  s   t |  S r[   )rm   r   r   rT   rT   rU   __len__r  s    zHDFStore.__len__c                 C  s   t | j}t|  d| dS )N
File path: 
)rJ   r   r   )r   pstrrT   rT   rU   __repr__u  s    
zHDFStore.__repr__c                 C  s   | S r[   rT   r   rT   rT   rU   	__enter__y  s    zHDFStore.__enter__ztype[BaseException] | NonezBaseException | NonezTracebackType | None)exc_type	exc_value	tracebackrZ   c                 C  s   |    d S r[   )r   )r   r   r   r   rT   rT   rU   __exit__|  s    zHDFStore.__exit__pandas	list[str])includerZ   c                 C  s^   |dkrdd |   D S |dkrJ| jdk	s0tdd | jjddd	D S td
| ddS )a#  
        Return a list of keys corresponding to objects stored in HDFStore.

        Parameters
        ----------

        include : str, default 'pandas'
                When kind equals 'pandas' return pandas objects.
                When kind equals 'native' return native HDF5 Table objects.

                .. versionadded:: 1.1.0

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

        Raises
        ------
        raises ValueError if kind has an illegal value
        r   c                 S  s   g | ]
}|j qS rT   r   rg   nrT   rT   rU   rj     s     z!HDFStore.keys.<locals>.<listcomp>ZnativeNc                 S  s   g | ]
}|j qS rT   r   r   rT   rT   rU   rj     s    /Table)	classnamez8`include` should be either 'pandas' or 'native' but is 'r   )r   r   r   Z
walk_nodesr   )r   r   rT   rT   rU   keys  s    
zHDFStore.keyszIterator[str]c                 C  s   t |  S r[   )iterr   r   rT   rT   rU   __iter__  s    zHDFStore.__iter__zIterator[tuple[str, list]]c                 c  s   |   D ]}|j|fV  qdS )z'
        iterate on key->group
        N)r   r   )r   grT   rT   rU   items  s    zHDFStore.items)r   rZ   c                 K  s   t  }| j|krR| jdkr$|dkr$n(|dkrL| jrLtd| j d| j d|| _| jr`|   | jr| jdkrt  j| j| j| j	d| _
tr| jrd	}t||j| j| jf|| _d
S )a9  
        Open the file in the specified mode

        Parameters
        ----------
        mode : {'a', 'w', 'r', 'r+'}, default 'a'
            See HDFStore docstring or tables.open_file for info about modes
        **kwargs
            These parameters will be passed to the PyTables open_file method.
        )r   w)r   r   )r   zRe-opening the file [z] with mode [z] will delete the current file!r   )r   zGCannot open HDF5 file, which is already opened, even in read-only mode.N)r   r   r   r$   r   r   r   Filtersr   r   r   r   r   	open_filer   )r   r   r   r|   msgrT   rT   rU   r     s.    
  
zHDFStore.openc                 C  s   | j dk	r| j   d| _ dS )z0
        Close the PyTables file handle
        N)r   r   r   rT   rT   rU   r     s    

zHDFStore.closec                 C  s   | j dkrdS t| j jS )zF
        return a boolean indicating whether the file is open
        NF)r   r   Zisopenr   rT   rT   rU   r     s    
zHDFStore.is_open)fsyncrZ   c              	   C  s@   | j dk	r<| j   |r<tt t| j   W 5 Q R X dS )a  
        Force all buffered modifications to be written to disk.

        Parameters
        ----------
        fsync : bool (default False)
          call ``os.fsync()`` on the file handle to force writing to disk.

        Notes
        -----
        Without ``fsync=True``, flushing may not guarantee that the OS writes
        to disk. With fsync, the operation will block until the OS claims the
        file has been written; however, other caching layers may still
        interfere.
        N)r   flushr   r   r   r   fileno)r   r   rT   rT   rU   r     s
    


zHDFStore.flushc              
   C  sJ   t  : | |}|dkr*td| d| |W  5 Q R  S Q R X dS )z
        Retrieve pandas object stored in file.

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

        Returns
        -------
        object
            Same type as object stored in file.
        NNo object named  in the file)r   r   r   _read_groupr   r   r   rT   rT   rU   r     s
    
zHDFStore.get)r   r   r   c	                   st   |  |}	|	dkr"td| dt|dd}| |	   fdd}
t| |
|j|||||d
}| S )	a  
        Retrieve pandas object stored in file, optionally based on where criteria.

        .. warning::

           Pandas uses PyTables for reading and writing HDF5 files, which allows
           serializing object-dtype data with pickle when using the "fixed" format.
           Loading pickled data received from untrusted sources can be unsafe.

           See: https://docs.python.org/3/library/pickle.html for more.

        Parameters
        ----------
        key : str
            Object being retrieved from file.
        where : list or None
            List of Term (or convertible) objects, optional.
        start : int or None
            Row number to start selection.
        stop : int, default None
            Row number to stop selection.
        columns : list or None
            A list of columns that if not None, will limit the return columns.
        iterator : bool or False
            Returns an iterator.
        chunksize : int or None
            Number or rows to include in iteration, return an iterator.
        auto_close : bool or False
            Should automatically close the store when finished.

        Returns
        -------
        object
            Retrieved object from file.
        Nr   r  re   rc   c                   s   j | || dS )N)r   r   rn   r   read_start_stop_wherer   rS   rT   rU   funcQ  s    zHDFStore.select.<locals>.funcrn   nrowsr   r   r   r   r   )r   r   ro   _create_storer
infer_axesTableIteratorr  
get_result)r   r   rn   r   r   r   r   r   r   r   r  itrT   r
  rU   r     s(    .

zHDFStore.selectr   r   r   c                 C  s8   t |dd}| |}t|ts(td|j|||dS )a  
        return the selection as an Index

        .. warning::

           Pandas uses PyTables for reading and writing HDF5 files, which allows
           serializing object-dtype data with pickle when using the "fixed" format.
           Loading pickled data received from untrusted sources can be unsafe.

           See: https://docs.python.org/3/library/pickle.html for more.


        Parameters
        ----------
        key : str
        where : list of Term (or convertible) objects, optional
        start : integer (defaults to None), row number to start selection
        stop  : integer (defaults to None), row number to stop selection
        re   rc   z&can only read_coordinates with a tablern   r   r   )ro   
get_storerrP   r   r   read_coordinates)r   r   rn   r   r   tblrT   rT   rU   select_as_coordinatesd  s
    

zHDFStore.select_as_coordinates)r   columnr   r   c                 C  s,   |  |}t|tstd|j|||dS )a~  
        return a single column from the table. This is generally only useful to
        select an indexable

        .. warning::

           Pandas uses PyTables for reading and writing HDF5 files, which allows
           serializing object-dtype data with pickle when using the "fixed" format.
           Loading pickled data received from untrusted sources can be unsafe.

           See: https://docs.python.org/3/library/pickle.html for more.

        Parameters
        ----------
        key : str
        column : str
            The column of interest.
        start : int or None, default None
        stop : int or None, default None

        Raises
        ------
        raises KeyError if the column is not found (or key is not a valid
            store)
        raises ValueError if the column can not be extracted individually (it
            is part of a data block)

        z!can only read_column with a tabler  r   r   )r  rP   r   r   read_column)r   r   r  r   r   r  rT   rT   rU   select_column  s    #

zHDFStore.select_column)r   r   c
                   sv  t |dd}t|ttfr.t|dkr.|d }t|trRj|||||||	dS t|ttfshtdt|sxtd|dkr|d }fdd	|D 	|}
d}t
|
|fgt|D ]\\}}|dkrtd
| d|jstd|j d|dkr
|j}q|j|krtdqdd	 D }dd |D    fdd}t|
||||||||	d
}|jddS )a  
        Retrieve pandas objects from multiple tables.

        .. warning::

           Pandas uses PyTables for reading and writing HDF5 files, which allows
           serializing object-dtype data with pickle when using the "fixed" format.
           Loading pickled data received from untrusted sources can be unsafe.

           See: https://docs.python.org/3/library/pickle.html for more.

        Parameters
        ----------
        keys : a list of the tables
        selector : the table to apply the where criteria (defaults to keys[0]
            if not supplied)
        columns : the columns I want back
        start : integer (defaults to None), row number to start selection
        stop  : integer (defaults to None), row number to stop selection
        iterator : bool, return an iterator, default False
        chunksize : nrows to include in iteration, return an iterator
        auto_close : bool, default False
            Should automatically close the store when finished.

        Raises
        ------
        raises KeyError if keys or selector is not found or keys is empty
        raises TypeError if keys is not a list or tuple
        raises ValueError if the tables are not ALL THE SAME DIMENSIONS
        re   rc   r   )r   rn   r   r   r   r   r   r   zkeys must be a list/tuplez keys must have a non-zero lengthNc                   s   g | ]}  |qS rT   )r  rg   kr   rT   rU   rj     s     z/HDFStore.select_as_multiple.<locals>.<listcomp>zInvalid table []zobject [z>] is not a table, and cannot be used in all select as multiplez,all tables must have exactly the same nrows!c                 S  s   g | ]}t |tr|qS rT   )rP   r   rg   xrT   rT   rU   rj     s     
 c                 S  s   h | ]}|j d  d  qS r   )non_index_axesrg   rv   rT   rT   rU   	<setcomp>  s     z.HDFStore.select_as_multiple.<locals>.<setcomp>c                   s*    fddD }t |dd S )Nc                   s   g | ]}|j  d qS )rn   r   r   r   r  r$  )r  r  r	  r   rT   rU   rj     s   z=HDFStore.select_as_multiple.<locals>.func.<locals>.<listcomp>F)axisverify_integrity)r=   _consolidate)r  r  r	  objs)r'  r   tblsr  rU   r  
  s    z)HDFStore.select_as_multiple.<locals>.funcr  Tcoordinates)ro   rP   rk   rl   rm   rX   r   r   r   r  	itertoolschainzipr   is_tablepathnamer  popr  r  )r   r   rn   selectorr   r   r   r   r   r   rS   r  rv   r  Z_tblsr  r  rT   )r'  r   r   r+  rU   select_as_multiple  sd    +

 


zHDFStore.select_as_multipleTrz   r   r   r   )r   r   r   r   r   r   r   r   track_timesr   rZ   c                 C  sH   |dkrt dpd}| |}| j|||||||||	|
||||d dS )a  
        Store object in HDFStore.

        Parameters
        ----------
        key : str
        value : {Series, DataFrame}
        format : 'fixed(f)|table(t)', default is 'fixed'
            Format to use when storing object in HDFStore. Value can be one of:

            ``'fixed'``
                Fixed format.  Fast writing/reading. Not-appendable, nor searchable.
            ``'table'``
                Table format.  Write as a PyTables Table structure which may perform
                worse but allow more flexible operations like searching / selecting
                subsets of the data.
        index : bool, default True
            Write DataFrame index as a column.
        append : bool, default False
            This will force Table format, append the input data to the existing.
        data_columns : list of columns or True, default None
            List of columns to create as data columns, or True to use all columns.
            See `here
            <https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#query-via-data-columns>`__.
        encoding : str, default None
            Provide an encoding for strings.
        track_times : bool, default True
            Parameter is propagated to 'create_table' method of 'PyTables'.
            If set to False it enables to have the same h5 files (same hashes)
            independent on creation time.
        dropna : bool, default False, optional
            Remove missing values.

            .. versionadded:: 1.1.0
        Nio.hdf.default_formatrs   )r   r   r   r   r   r   r   r   rY   r   r6  r   )r   _validate_format_write_to_group)r   r   r   r   r   r   r   r   r   r   r   rY   r   r6  r   rT   rT   rU   r   %  s&    4
zHDFStore.putc              
   C  s   t |dd}z| |}W n tk
r0    Y np tk
rD    Y n\ tk
r } z>|dk	rftd|| |}|dk	r|jdd W Y dS W 5 d}~X Y nX t	|||r|j
jdd n|jstd|j|||dS dS )	a:  
        Remove pandas object partially by specifying the where condition

        Parameters
        ----------
        key : str
            Node to remove or delete rows from
        where : list of Term (or convertible) objects, optional
        start : integer (defaults to None), row number to start selection
        stop  : integer (defaults to None), row number to stop selection

        Returns
        -------
        number of rows removed (or None if not a Table)

        Raises
        ------
        raises KeyError if key is not a valid store

        re   rc   Nz5trying to remove a node with a non-None where clause!T	recursivez7can only remove with where on objects written as tablesr  )ro   r  r   r   	Exceptionr   r   Z	_f_removecomall_noner   r1  delete)r   r   rn   r   r   rS   errr   rT   rT   rU   r   m  s2    
zHDFStore.removezbool | list[str]r   )
r   r   r   r   r   r   r   r   r   rZ   c                 C  sl   |	dk	rt d|dkr td}|dkr4tdp2d}| |}| j|||||||||
|||||||d dS )a  
        Append to Table in file.

        Node must already exist and be Table format.

        Parameters
        ----------
        key : str
        value : {Series, DataFrame}
        format : 'table' is the default
            Format to use when storing object in HDFStore.  Value can be one of:

            ``'table'``
                Table format. Write as a PyTables Table structure which may perform
                worse but allow more flexible operations like searching / selecting
                subsets of the data.
        index : bool, default True
            Write DataFrame index as a column.
        append       : bool, default True
            Append the input data to the existing.
        data_columns : list of columns, or True, default None
            List of columns to create as indexed data columns for on-disk
            queries, or True to use all columns. By default only the axes
            of the object are indexed. See `here
            <https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#query-via-data-columns>`__.
        min_itemsize : dict of columns that specify minimum str sizes
        nan_rep      : str to use as str nan representation
        chunksize    : size to chunk the writing
        expectedrows : expected TOTAL row size of this table
        encoding     : default None, provide an encoding for str
        dropna : bool, default False, optional
            Do not write an ALL nan row to the store settable
            by the option 'io.hdf.dropna_table'.

        Notes
        -----
        Does *not* check if data being appended overlaps with existing
        data in the table, so be careful
        Nz>columns is not a supported keyword in append, try data_columnszio.hdf.dropna_tabler7  rt   )r   axesr   r   r   r   r   r   r   expectedrowsr   r   rY   r   )r   r   r8  r9  )r   r   r   r   rA  r   r   r   r   r   r   r   r   rB  r   r   rY   r   rT   rT   rU   r     s6    ;
zHDFStore.appenddict)dr   rZ   c                   s  |dk	rt dt|ts"td||kr2tdtttjttt	  d }d}	g }
|
 D ]0\}  dkr|	dk	rtd|}	qh|
  qh|	dk	rֈj| }|t|
}t||}||||	< |dkr|| }|r*fdd| D }t|}|D ]}||}qj| |d	d}|
 D ]h\} ||krT|nd}j |d
}|dk	r fdd|
 D nd}| j||f||d| q>dS )a  
        Append to multiple tables

        Parameters
        ----------
        d : a dict of table_name to table_columns, None is acceptable as the
            values of one node (this will get all the remaining columns)
        value : a pandas object
        selector : a string that designates the indexable table; all of its
            columns will be designed as data_columns, unless data_columns is
            passed, in which case these are used
        data_columns : list of columns to create as data columns, or True to
            use all columns
        dropna : if evaluates to True, drop rows from all tables if any single
                 row in each table has all NaN. Default False.

        Notes
        -----
        axes parameter is currently not accepted

        Nztaxes is currently not accepted as a parameter to append_to_multiple; you can create the tables independently insteadzQappend_to_multiple must have a dictionary specified as the way to split the valuez=append_to_multiple requires a selector that is in passed dictr   z<append_to_multiple can only have one value in d that is Nonec                 3  s    | ]} | j d djV  qdS )all)howN)r   r   )rg   cols)r   rT   rU   	<genexpr>I  s     z.HDFStore.append_to_multiple.<locals>.<genexpr>r   r'  c                   s   i | ]\}}| kr||qS rT   rT   rg   r   r   )vrT   rU   
<dictcomp>Y  s       z/HDFStore.append_to_multiple.<locals>.<dictcomp>)r   r   )r   rP   rC  r   rk   setrangendim	_AXES_MAPr   r   extendrA  
differencer7   sortedget_indexertakevaluesnextintersectionlocr3  reindexr   )r   rD  r   r4  r   rA  r   r   r'  Z
remain_keyZremain_valuesr  orderedZorddZidxsZvalid_indexr   r   dcvalfilteredrT   )rK  r   rU   append_to_multiple  sZ    
&

zHDFStore.append_to_multiplerW   )r   optlevelkindrZ   c                 C  sB   t   | |}|dkrdS t|ts.td|j|||d dS )a  
        Create a pytables index on the table.

        Parameters
        ----------
        key : str
        columns : None, bool, or listlike[str]
            Indicate which columns to create an index on.

            * False : Do not create any indexes.
            * True : Create indexes on all columns.
            * None : Create indexes on all columns.
            * listlike : Create indexes on the given columns.

        optlevel : int or None, default None
            Optimization level, if None, pytables defaults to 6.
        kind : str or None, default None
            Kind of index, if None, pytables defaults to "medium".

        Raises
        ------
        TypeError: raises if the node is not a table
        Nz1cannot create table index on a Fixed format store)r   r`  ra  )r   r  rP   r   r   create_index)r   r   r   r`  ra  rS   rT   rT   rU   create_table_index_  s    

zHDFStore.create_table_indexrk   c                 C  s<   t   |   | jdk	sttdk	s(tdd | j D S )z
        Return a list of all the top-level nodes.

        Each node returned is not a pandas storage object.

        Returns
        -------
        list
            List of objects.
        Nc                 S  sP   g | ]H}t |tjjst|jd dsHt|ddsHt |tjjr|jdkr|qS )pandas_typeNrt   )	rP   r{   linkLinkgetattr_v_attrsrt   r   r   )rg   r   rT   rT   rU   rj     s    
z#HDFStore.groups.<locals>.<listcomp>)r   r   r   r   r{   walk_groupsr   rT   rT   rU   r     s    zHDFStore.groupsr   z*Iterator[tuple[str, list[str], list[str]]])rn   rZ   c                 c  s   t   |   | jdk	sttdk	s(t| j|D ]}t|jdddk	rLq4g }g }|j	 D ]B}t|jdd}|dkrt
|tjjr||j q^||j q^|jd||fV  q4dS )aS  
        Walk the pytables group hierarchy for pandas objects.

        This generator will yield the group path, subgroups and pandas object
        names for each group.

        Any non-pandas PyTables objects that are not a group will be ignored.

        The `where` group itself is listed first (preorder), then each of its
        child groups (following an alphanumerical order) is also traversed,
        following the same procedure.

        Parameters
        ----------
        where : str, default "/"
            Group where to start walking.

        Yields
        ------
        path : str
            Full path to a group (without trailing '/').
        groups : list
            Names (strings) of the groups contained in `path`.
        leaves : list
            Names (strings) of the pandas objects contained in `path`.
        Nrd  r   )r   r   r   r   r{   ri  rg  rh  Z_v_childrenrV  rP   r   Groupr   r   r   rstrip)r   rn   r   r   Zleaveschildrd  rT   rT   rU   walk  s     zHDFStore.walkzNode | Nonec                 C  s   |    |dsd| }| jdk	s(ttdk	s4tz| j| j|}W n tjjk
rb   Y dS X t	|tj
s|tt||S )z9return the node with the key or None if it does not existr   N)r   
startswithr   r   r{   r   r   
exceptionsZNoSuchNodeErrorrP   rM   r   )r   r   r   rT   rT   rU   r     s    
zHDFStore.get_nodeGenericFixed | Tablec                 C  s8   |  |}|dkr"td| d| |}|  |S )z<return the storer object for a key, raise if not in the fileNr   r  )r   r   r  r  )r   r   r   rS   rT   rT   rU   r    s    

zHDFStore.get_storerr   )r   propindexesr   r   	overwriterZ   c	              	   C  s   t |||||d}	|dkr&t|  }t|ttfs:|g}|D ]}
| |
}|dk	r>|
|	krj|rj|	|
 | |
}t|trd}|rdd |j	D }|	j
|
||t|dd|jd q>|	j|
||jd q>|	S )	a;  
        Copy the existing store to a new file, updating in place.

        Parameters
        ----------
        propindexes : bool, default True
            Restore indexes in copied file.
        keys : list, optional
            List of keys to include in the copy (defaults to all).
        overwrite : bool, default True
            Whether to overwrite (remove and replace) existing nodes in the new store.
        mode, complib, complevel, fletcher32 same as in HDFStore.__init__

        Returns
        -------
        open file handle of the new store
        )r   r   r   r   NFc                 S  s   g | ]}|j r|jqS rT   )
is_indexedr`   rg   r   rT   rT   rU   rj     s      z!HDFStore.copy.<locals>.<listcomp>r   )r   r   rY   r]   )r   rk   r   rP   rl   r  r   r   r   rA  r   rg  rY   r   )r   r~   r   rq  r   r   r   r   rr  Z	new_storer  rS   datar   rT   rT   rU   copy  s>        




zHDFStore.copyc           
      C  s
  t | j}t|  d| d}| jrt|  }t|rg }g }|D ]}z<| |}|dk	r|t |j	pj| |t |p|d W qD t
k
r    Y qD tk
r } z(|| t |}	|d|	 d W 5 d}~X Y qDX qD|td||7 }n|d7 }n|d	7 }|S )
zg
        Print detailed information on the store.

        Returns
        -------
        str
        r   r   Nzinvalid_HDFStore nodez[invalid_HDFStore node: r     EmptyzFile is CLOSED)rJ   r   r   r   rS  r   rm   r  r   r2  r   r<  rI   )
r   r   outputZlkeysr   rV  r  rS   ZdetailZdstrrT   rT   rU   info(  s.    


&
zHDFStore.infoc                 C  s   | j st| j dd S )Nz file is not open!)r   r!   r   r   rT   rT   rU   r   R  s    zHDFStore._check_if_open)r   rZ   c              
   C  sJ   zt |  }W n4 tk
rD } ztd| d|W 5 d}~X Y nX |S )zvalidate / deprecate formatsz#invalid HDFStore format specified [r  N)_FORMAT_MAPlowerr   r   )r   r   r@  rT   rT   rU   r8  V  s
    $zHDFStore._validate_formatrO   zDataFrame | Series | None)r   rY   r   rZ   c              
   C  s:  |dk	rt |ttfstdtt|jdd}tt|jdd}|dkr|dkrt  tdk	sdt	t|dds~t |tj
jrd}d}qtdn$t |trd	}nd
}|dkr|d7 }d|kr,ttd}z|| }	W nD tk
r }
 z$td| dt| d| |
W 5 d}
~
X Y nX |	| |||dS |dkr|dk	r|dkrt|dd}|dk	r|jdkrrd}n|jdkrd}nB|dkrt|dd}|dk	r|jdkrd}n|jdkrd}ttttttd}z|| }	W nD tk
r( }
 z$td| dt| d| |
W 5 d}
~
X Y nX |	| |||dS )z"return a suitable class to operateNz(value must be None, Series, or DataFramerd  
table_typert   frame_tablegeneric_tablezKcannot create a storer if the object is not existing nor a value are passedseriesframeZ_table)r  r  z=cannot properly create the storer for: [_STORER_MAP] [group->,value->z	,format->rY   r   series_tabler   re   appendable_seriesappendable_multiseriesappendable_frameappendable_multiframe)r  r  r  r  r  wormz<cannot properly create the storer for: [_TABLE_MAP] [group->)rP   r;   r5   r   rV   rg  rh  r   r{   r   rt   r   SeriesFixed
FrameFixedr   r   nlevelsGenericTableAppendableSeriesTableAppendableMultiSeriesTableAppendableFrameTableAppendableMultiFrameTable	WORMTable)r   r   r   r   rY   r   ptttZ_STORER_MAPclsr@  r   Z
_TABLE_MAPrT   rT   rU   r  `  s     








zHDFStore._create_storer)
r   r   r   r   r   r   r   r   r6  rZ   c                 C  s   t |dd r|dks|rd S | ||}| j|||||d}|rr|jrZ|jrb|dkrb|jrbtd|jsz|  n|  |js|rtd|j||||||	|
||||||d t|t	r|r|j
|d d S )	Nemptyrt   r  rs   zCan only append to Tablesz0Compression not supported on Fixed format stores)objrA  r   r   r   r   r   r   rB  r   r   r   r6  )r   )rg  _identify_groupr  r1  	is_existsr   set_object_infowriterP   r   rb  )r   r   r   r   rA  r   r   r   r   r   r   r   rB  r   r   r   rY   r   r6  r   rS   rT   rT   rU   r9    s:    

zHDFStore._write_to_grouprM   r   c                 C  s   |  |}|  | S r[   )r  r  r  )r   r   rS   rT   rT   rU   r    s    
zHDFStore._read_group)r   r   rZ   c                 C  sN   |  |}| jdk	st|dk	r8|s8| jj|dd d}|dkrJ| |}|S )z@Identify HDF5 group based on key, delete/create group if needed.NTr:  )r   r   r   remove_node_create_nodes_and_group)r   r   r   r   rT   rT   rU   r    s    

zHDFStore._identify_groupc                 C  sv   | j dk	st|d}d}|D ]P}t|s.q |}|dsD|d7 }||7 }| |}|dkrl| j ||}|}q |S )z,Create nodes from key and return group name.Nr   )r   r   splitrm   endswithr   Zcreate_group)r   r   pathsr   pnew_pathr   rT   rT   rU   r    s    


z HDFStore._create_nodes_and_group)r   NNF)r   )r   )F)NNNNFNF)NNN)NN)NNNNNFNF)NTFNNNNNNrz   TF)NNN)NNTTNNNNNNNNNNrz   )NNF)NNN)r   )r   TNNNFT)NNrO   rz   )NTFNNNNNNFNNNrz   T)1r   
__module____qualname____doc____annotations__r   r   propertyr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r5  r   r   r   r_  rc  r   rm  r   r  rv  rz  r   r8  r  r9  r  r  r  rT   rT   rT   rU   r     s  
A    !

"-       N   $  +        }            $H=               "]   d   (0       ;*    `               ">r   c                   @  sp   e Zd ZU dZded< ded< ded< dddd
dd
ddddZddddZddddZdd
dddZdS )r  aa  
    Define the iteration interface on a table

    Parameters
    ----------
    store : HDFStore
    s     : the referred storer
    func  : the function to execute the query
    where : the where of the query
    nrows : the rows to iterate on
    start : the passed start value (default is None)
    stop  : the passed stop value (default is None)
    iterator : bool, default False
        Whether to use the default iterator.
    chunksize : the passed chunking value (default is 100000)
    auto_close : bool, default False
        Whether to automatically close the store at the end of iteration.
    r   r   r   r   rp  rS   NFr   r   )r   rS   r   r   r   rZ   c                 C  s   || _ || _|| _|| _| jjrN|d kr,d}|d kr8d}|d krD|}t||}|| _|| _|| _d | _	|sr|	d k	r|	d kr~d}	t
|	| _nd | _|
| _d S )Nr   順 )r   rS   r  rn   r1  minr  r   r   r-  rb   r   r   )r   r   rS   r  rn   r  r   r   r   r   r   rT   rT   rU   r   >  s,    
zTableIterator.__init__r   r   c                 c  sv   | j }| jd krtd|| jk rjt|| j | j}| d d | j|| }|}|d kst|sbq|V  q|   d S )Nz*Cannot iterate until get_result is called.)	r   r-  r   r   r  r   r  rm   r   )r   r   r   r   rT   rT   rU   r   h  s    

zTableIterator.__iter__c                 C  s   | j r| j  d S r[   )r   r   r   r   rT   rT   rU   r   x  s    zTableIterator.closer,  c                 C  s   | j d k	r4t| jtstd| jj| jd| _| S |rft| jtsLtd| jj| j| j| j	d}n| j}| 
| j| j	|}|   |S )Nz0can only use an iterator or chunksize on a table)rn   z$can only read_coordinates on a tabler  )r   rP   rS   r   r   r  rn   r-  r   r   r  r   )r   r-  rn   resultsrT   rT   rU   r  |  s"    
  zTableIterator.get_result)NNFNF)F)	r   r  r  r  r  r   r   r   r  rT   rT   rT   rU   r  &  s   
	     *r  c                   @  s  e Zd ZU dZdZded< dZded< dddgZdMd
dddddZe	ddddZ
e	d
dddZdddddZd
dddZdddddZdddd Ze	ddd!d"Zd#d
d
d$d%d&d'Zd(d) Ze	d*d+ Ze	d,d- Ze	d.d/ Ze	d0d1 Zd2dd3d4ZdNddd5d6Zddd7d8Zd9ddd:d;d<ZdOd=d>Zddd?d@dAZdddBdCZdddDdEZdddFdGZd9ddHdIdJZ d9ddHdKdLZ!d	S )PIndexCola  
    an index column description class

    Parameters
    ----------
    axis   : axis which I reference
    values : the ndarray like converted values
    kind   : a string description of this type
    typ    : the pytables type
    pos    : the position in the pytables

    Tr   is_an_indexableis_data_indexablefreqtz
index_nameNrX   rW   r   )r`   cnamerZ   c                 C  s   t |tstd|| _|| _|| _|| _|p0|| _|| _|| _	|| _
|	| _|
| _|| _|| _|| _|| _|d k	r|| | t | jtstt | jtstd S )Nz`name` must be a str.)rP   rX   r   rV  ra  typr`   r  r'  posr  r  r  r[  rt   r   metadataset_posr   )r   r`   rV  ra  r  r  r'  r  r  r  r  r[  rt   r   r  rT   rT   rU   r     s(    


zIndexCol.__init__rb   r   c                 C  s   | j jS r[   )r  itemsizer   rT   rT   rU   r    s    zIndexCol.itemsizec                 C  s   | j  dS )N_kindr_   r   rT   rT   rU   	kind_attr  s    zIndexCol.kind_attr)r  rZ   c                 C  s$   || _ |dk	r | jdk	r || j_dS )z,set the position of this column in the TableN)r  r  Z_v_pos)r   r  rT   rT   rU   r    s    zIndexCol.set_posc              	   C  sF   t tt| j| j| j| j| jf}ddd t	dddddg|D S )	N,c                 S  s   g | ]\}}| d | qS z->rT   rJ  rT   rT   rU   rj     s   z%IndexCol.__repr__.<locals>.<listcomp>r`   r  r'  r  ra  )
rl   maprJ   r`   r  r'  r  ra  joinr0  r   temprT   rT   rU   r     s    zIndexCol.__repr__r	   otherrZ   c                   s   t  fdddD S )compare 2 col itemsc                 3  s&   | ]}t |d t  |d kV  qd S r[   rg  rt  r  r   rT   rU   rH    s   z"IndexCol.__eq__.<locals>.<genexpr>)r`   r  r'  r  rE  r   r  rT   r  rU   __eq__  s    zIndexCol.__eq__c                 C  s   |  | S r[   )r  r  rT   rT   rU   __ne__  s    zIndexCol.__ne__c                 C  s"   t | jdsdS t| jj| jjS )z%return whether I am an indexed columnrG  F)hasattrrt   rg  rG  r  rs  r   rT   rT   rU   rs    s    zIndexCol.is_indexed
np.ndarrayz3tuple[np.ndarray, np.ndarray] | tuple[Index, Index]rV  rY   r   rZ   c           
      C  s  t |tjstt||jjdk	r2|| j  }t	| j
}t||||}i }t	| j|d< | jdk	rtt	| j|d< t}t|jst|jrt}n|jdkrd|krdd }z||f|}W n0 tk
r   d|krd|d< ||f|}Y nX t|| j}	|	|	fS )zV
        Convert the data from this selection to the appropriate pandas type.
        Nr`   r  i8c                 [  s   t f d| i|S )NZordinal)r9   )r!  kwdsrT   rT   rU   r     s   z"IndexCol.convert.<locals>.<lambda>)rP   rQ   ndarrayr   r   dtypefieldsr  rv  rV   ra  _maybe_convertr  r  r7   r+   r,   r6   r   _set_tzr  )
r   rV  r   rY   r   val_kindr   factoryZnew_pd_indexZfinal_pd_indexrT   rT   rU   convert  s,    

zIndexCol.convertc                 C  s   | j S )zreturn the valuesrV  r   rT   rT   rU   	take_data.  s    zIndexCol.take_datac                 C  s   | j jS r[   )rt   rh  r   rT   rT   rU   attrs2  s    zIndexCol.attrsc                 C  s   | j jS r[   rt   descriptionr   rT   rT   rU   r  6  s    zIndexCol.descriptionc                 C  s   t | j| jdS )z!return my current col descriptionN)rg  r  r  r   rT   rT   rU   col:  s    zIndexCol.colc                 C  s   | j S zreturn my cython valuesr  r   rT   rT   rU   cvalues?  s    zIndexCol.cvaluesr   c                 C  s
   t | jS r[   )r   rV  r   rT   rT   rU   r   D  s    zIndexCol.__iter__c                 C  sP   t | jdkrLt|tr$|| j}|dk	rL| jj|k rLt j	|| j
d| _dS )z
        maybe set a string col itemsize:
            min_itemsize can be an integer or a dict with this columns name
            with an integer size
        stringN)r  r  )rV   ra  rP   rC  r   r`   r  r  r   	StringColr  )r   r   rT   rT   rU   maybe_set_sizeG  s
    
zIndexCol.maybe_set_sizec                 C  s   d S r[   rT   r   rT   rT   rU   validate_namesT  s    zIndexCol.validate_namesAppendableTable)handlerr   rZ   c                 C  s:   |j | _ |   | | | | | | |   d S r[   )rt   validate_colvalidate_attrvalidate_metadatawrite_metadataset_attr)r   r  r   rT   rT   rU   validate_and_setW  s    


zIndexCol.validate_and_setc                 C  s^   t | jdkrZ| j}|dk	rZ|dkr*| j}|j|k rTtd| d| j d|j d|jS dS )z:validate this column: return the compared against itemsizer  Nz#Trying to store a string with len [z] in [z)] column but
this column has a limit of [zC]!
Consider using min_itemsize to preset the sizes on these columns)rV   ra  r  r  r   r  )r   r  crT   rT   rU   r  _  s    
zIndexCol.validate_col)r   rZ   c                 C  sB   |r>t | j| jd }|d k	r>|| jkr>td| d| j dd S )Nzincompatible kind in col [ - r  )rg  r  r  ra  r   )r   r   Zexisting_kindrT   rT   rU   r  r  s    zIndexCol.validate_attrc                 C  s   | j D ]}t| |d}|| ji }||}||kr|dk	r||kr|dkrt|||f }tj|tt	 d d||< t
| |d qtd| j d| d| d| d	q|dk	s|dk	r|||< qdS )	z
        set/update the info for this indexable with the key/value
        if there is a conflict raise/warn as needed
        N)r  r  
stacklevelzinvalid info for [z] for [z], existing_value [z] conflicts with new value [r  )_info_fieldsrg  
setdefaultr`   r   rq   warningswarnr    r&   setattrr   )r   rz  r   r   idxZexisting_valuewsrT   rT   rU   update_info{  s&    

  zIndexCol.update_infoc                 C  s$   | | j}|dk	r | j| dS )z!set my state from the passed infoN)r   r`   __dict__update)r   rz  r  rT   rT   rU   set_info  s    zIndexCol.set_infoc                 C  s   t | j| j| j dS )zset the kind for this columnN)r  r  r  ra  r   rT   rT   rU   r    s    zIndexCol.set_attr)r  rZ   c                 C  sB   | j dkr>| j}|| j}|dk	r>|dk	r>t||s>tddS )z:validate that kind=category does not change the categoriescategoryNzEcannot append a categorical with different categories to the existing)r   r  read_metadatar  r4   r   )r   r  Znew_metadataZcur_metadatarT   rT   rU   r    s    
zIndexCol.validate_metadatac                 C  s   | j dk	r|| j| j  dS )zset the meta dataN)r  r  r  )r   r  rT   rT   rU   r    s    
zIndexCol.write_metadata)NNNNNNNNNNNNN)N)N)"r   r  r  r  r  r  r  r  r   r  r  r  r  r   r  r  rs  r  r  r  r  r  r  r   r  r  r  r  r  r  r  r  r  r  rT   rT   rT   rU   r    sb   

             +/




	 r  c                   @  sD   e Zd ZdZeddddZddddd	d
dZddddZdS )GenericIndexColz:an index which is not represented in the data of the tabler   r   c                 C  s   dS NFrT   r   rT   rT   rU   rs    s    zGenericIndexCol.is_indexedr  rX   ztuple[Index, Index]r  c                 C  s,   t |tjstt|tt|}||fS )z
        Convert the data from this selection to the appropriate pandas type.

        Parameters
        ----------
        values : np.ndarray
        nan_rep : str
        encoding : str
        errors : str
        )rP   rQ   r  r   r   r:   rm   )r   rV  r   rY   r   r   rT   rT   rU   r    s    zGenericIndexCol.convertr   c                 C  s   d S r[   rT   r   rT   rT   rU   r    s    zGenericIndexCol.set_attrN)r   r  r  r  r  rs  r  r  rT   rT   rT   rU   r    s
   r  c                      s>  e Zd ZdZdZdZddgZd;dddd	d
 fddZeddddZ	eddddZ
ddddZdddddZdd	dddZdd Zeddd d!d"Zed#d$ Zedd%d&d'd(Zeddd&d)d*Zed+d, Zed-d. Zed/d0 Zed1d2 Zd	dd3d4Zd5ddd6d7d8Zd	dd9d:Z  ZS )<DataCola3  
    a data holding column, by definition this is not indexable

    Parameters
    ----------
    data   : the actual data
    cname  : the column name in the table to hold the data (typically
                values)
    meta   : a string description of the metadata
    metadata : the actual metadata
    Fr  r[  NrX   rW   zDtypeArg | Noner   )r`   r  r  rZ   c                   s2   t  j|||||||||	|
|d || _|| _d S )N)r`   rV  ra  r  r  r  r  r[  rt   r   r  )superr   r  ru  )r   r`   rV  ra  r  r  r  r  r[  rt   r   r  r  ru  	__class__rT   rU   r     s    zDataCol.__init__r   c                 C  s   | j  dS )N_dtyper_   r   rT   rT   rU   
dtype_attr	  s    zDataCol.dtype_attrc                 C  s   | j  dS )N_metar_   r   rT   rT   rU   	meta_attr	  s    zDataCol.meta_attrc              	   C  sF   t tt| j| j| j| j| jf}ddd t	dddddg|D S )	Nr  c                 S  s   g | ]\}}| d | qS r  rT   rJ  rT   rT   rU   rj   	  s   z$DataCol.__repr__.<locals>.<listcomp>r`   r  r  ra  shape)
rl   r  rJ   r`   r  r  ra  r  r  r0  r  rT   rT   rU   r   	  s     zDataCol.__repr__r	   r   r  c                   s   t  fdddD S )r  c                 3  s&   | ]}t |d t  |d kV  qd S r[   r  rt  r  rT   rU   rH  	  s   z!DataCol.__eq__.<locals>.<genexpr>)r`   r  r  r  r  r  rT   r  rU   r  	  s    zDataCol.__eq__r   )ru  rZ   c                 C  s@   |d k	st | jd kst t|\}}|| _|| _t|| _d S r[   )r   r  _get_data_and_dtype_nameru  _dtype_to_kindra  )r   ru  
dtype_namerT   rT   rU   set_data$	  s    zDataCol.set_datac                 C  s   | j S )zreturn the dataru  r   rT   rT   rU   r  .	  s    zDataCol.take_datarK   )rV  rZ   c                 C  s   |j }|j}|j}|jdkr&d|jf}t|trJ|j}| j||j j	d}ntt
|sZt|rf| |}nXt|rz| |}nDt|rt j||d d}n&t|r| ||}n| j||j	d}|S )zW
        Get an appropriately typed and shaped pytables.Col object for values.
        re   ra  r   r  r  )r  r  r  rO  sizerP   r?   codesget_atom_datar`   r+   r,   get_atom_datetime64r2   get_atom_timedelta64r*   r   Z
ComplexColr1   get_atom_string)r  rV  r  r  r  r  atomrT   rT   rU   	_get_atom2	  s$    


zDataCol._get_atomc                 C  s   t  j||d dS )Nr   r  r   r  r  r  r  rT   rT   rU   r  R	  s    zDataCol.get_atom_stringz	type[Col]ra  rZ   c                 C  sR   | dr$|dd }d| d}n"| dr4d}n| }| d}tt |S )z0return the PyTables column class for this columnuint   NZUIntrK   periodInt64Col)rn  
capitalizerg  r   )r  ra  Zk4Zcol_nameZkcaprT   rT   rU   get_atom_coltypeV	  s    


zDataCol.get_atom_coltypec                 C  s   | j |d|d dS )Nr  r   r  r  r  r  ra  rT   rT   rU   r  e	  s    zDataCol.get_atom_datac                 C  s   t  j|d dS Nr   r  r   r  r  r  rT   rT   rU   r  i	  s    zDataCol.get_atom_datetime64c                 C  s   t  j|d dS r!  r"  r#  rT   rT   rU   r  m	  s    zDataCol.get_atom_timedelta64c                 C  s   t | jdd S )Nr  )rg  ru  r   rT   rT   rU   r  q	  s    zDataCol.shapec                 C  s   | j S r  r
  r   rT   rT   rU   r  u	  s    zDataCol.cvaluesc                 C  s`   |r\t | j| jd}|dk	r2|t| jkr2tdt | j| jd}|dk	r\|| jkr\tddS )zAvalidate that we have the same order as the existing & same dtypeNz4appended items do not match existing items in table!z@appended items dtype do not match existing items dtype in table!)rg  r  r  rk   rV  r   r  r  )r   r   Zexisting_fieldsZexisting_dtyperT   rT   rU   r  z	  s    zDataCol.validate_attrr  )rV  rY   r   c                 C  s  t |tjstt||jjdk	r.|| j }| jdk	s<t| jdkr\t	|\}}t
|}n|}| j}| j}t |tjs|tt| j}| j}	| j}
| j}|dk	stt|}|dkrt||dd}n(|dkrtj|dd}n|dkr8ztjd	d
 |D td}W n. tk
r4   tjdd
 |D td}Y nX n|dkr|	}| }|dkrhtg tjd}n<t|}| r||  }||dk  |t j8  < tj|||
d}n8z|j|dd}W n$ t k
r   |jddd}Y nX t|dkrt!||||d}| j"|fS )aR  
        Convert the data from this selection to the appropriate pandas type.

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

        Returns
        -------
        index : listlike to become an Index
        data : ndarraylike to become a column
        N
datetime64Tcoercetimedelta64m8[ns]r  r   c                 S  s   g | ]}t |qS rT   r   fromordinalrg   rK  rT   rT   rU   rj   	  s     z#DataCol.convert.<locals>.<listcomp>c                 S  s   g | ]}t |qS rT   r   fromtimestampr,  rT   rT   rU   rj   	  s     r  )
categoriesr[  Frv  Or  r   rY   r   )#rP   rQ   r  r   r   r  r  r  r  r  r  ra  rV   r   r  r[  r  r  asarrayobjectr   ravelr7   Zfloat64r>   anyastyperb   Zcumsum_valuesr?   Z
from_codesr   _unconvert_string_arrayrV  )r   rV  r   rY   r   	convertedr  ra  r   r  r[  r  r  r0  r  maskrT   rT   rU   r  	  st    




 
 



      zDataCol.convertc                 C  sH   t | j| j| j t | j| j| j | jdk	s2tt | j| j| j dS )zset the data for this columnN)	r  r  r  rV  r  r   r  r   r  r   rT   rT   rU   r  	  s    zDataCol.set_attr)NNNNNNNNNNNN)r   r  r  r  r  r  r  r   r  r  r  r   r  r	  r  classmethodr  r  r  r  r  r  r  r  r  r  r  __classcell__rT   rT   r  rU   r    sX                





dr  c                   @  sZ   e Zd ZdZdZddddZedd Zed	d
dddZedd Z	edd Z
dS )DataIndexableColz+represent a data column that can be indexedTr   r   c                 C  s   t t| jstdd S )N-cannot have non-object label DataIndexableCol)r0   r7   rV  r   r   rT   rT   rU   r  	  s    zDataIndexableCol.validate_namesc                 C  s   t  j|dS )N)r  r  r  rT   rT   rU   r  	  s    z DataIndexableCol.get_atom_stringrX   rK   r  c                 C  s   | j |d S )Nr  r  r   rT   rT   rU   r  
  s    zDataIndexableCol.get_atom_datac                 C  s
   t   S r[   r"  r#  rT   rT   rU   r  
  s    z$DataIndexableCol.get_atom_datetime64c                 C  s
   t   S r[   r"  r#  rT   rT   rU   r  	
  s    z%DataIndexableCol.get_atom_timedelta64N)r   r  r  r  r  r  r=  r  r  r  r  rT   rT   rT   rU   r?  	  s   

r?  c                   @  s   e Zd ZdZdS )GenericDataIndexableColz(represent a generic pytables data columnN)r   r  r  r  rT   rT   rT   rU   rA  
  s   rA  c                   @  s  e Zd ZU dZded< dZded< ded< ded	< d
ed< dZded< dNd
dddddddZeddddZ	eddddZ
edd Zdddd Zddd!d"Zd dd#d$Zed%d& Zed'd( Zed)d* Zed+d, Zeddd-d.Zeddd/d0Zed1d2 Zddd3d4Zddd5d6Zed7d8 Zeddd9d:Zed;d< Zd=dd>d?ZdOdddAdBZdddCdDZdPdEdEdFdGdHZdIdJ ZdQdEdEddKdLdMZ d@S )RFixedz
    represent an object in my store
    facilitate read/write of various types of objects
    this is an abstract base class

    Parameters
    ----------
    parent : HDFStore
    group : Node
        The group node where the table resides.
    rX   pandas_kindrs   format_typetype[DataFrame | Series]obj_typerb   rO  r   r   Fr   r1  rO   rz   rM   rW   r   )r   r   rY   r   rZ   c                 C  sZ   t |tstt|td k	s"tt |tjs:tt||| _|| _t|| _	|| _
d S r[   )rP   r   r   r   r{   rM   r   r   r^   rY   r   )r   r   r   rY   r   rT   rT   rU   r   &
  s    
zFixed.__init__r   c                 C  s*   | j d dko(| j d dko(| j d dk S )Nr   re   
      )versionr   rT   rT   rU   is_old_version5
  s    zFixed.is_old_versionztuple[int, int, int]c                 C  sb   t t| jjdd}z0tdd |dD }t|dkrB|d }W n tk
r\   d}Y nX |S )	zcompute and set our versionpandas_versionNc                 s  s   | ]}t |V  qd S r[   rb   r   rT   rT   rU   rH  >
  s     z Fixed.version.<locals>.<genexpr>.rH  r"  )r   r   r   )rV   rg  r   rh  rl   r  rm   r}   )r   rI  rT   rT   rU   rI  9
  s    
zFixed.versionc                 C  s   t t| jjdd S )Nrd  )rV   rg  r   rh  r   rT   rT   rU   rd  E
  s    zFixed.pandas_typec                 C  s^   |    | j}|dk	rXt|ttfrDddd |D }d| d}| jdd| d	S | jS )
(return a pretty representation of myselfNr  c                 S  s   g | ]}t |qS rT   rJ   r   rT   rT   rU   rj   O
  s     z"Fixed.__repr__.<locals>.<listcomp>[r  12.12z	 (shape->))r  r  rP   rk   rl   r  rd  )r   rS   ZjshaperT   rT   rU   r   I
  s    zFixed.__repr__c                 C  s   t | j| j_t t| j_dS )zset my pandas type & versionN)rX   rC  r  rd  _versionrK  r   rT   rT   rU   r  T
  s    zFixed.set_object_infoc                 C  s   t  | }|S r[   r1  )r   Znew_selfrT   rT   rU   rv  Y
  s    
z
Fixed.copyc                 C  s   | j S r[   )r  r   rT   rT   rU   r  ]
  s    zFixed.shapec                 C  s   | j jS r[   r   r   r   rT   rT   rU   r2  a
  s    zFixed.pathnamec                 C  s   | j jS r[   )r   r   r   rT   rT   rU   r   e
  s    zFixed._handlec                 C  s   | j jS r[   )r   r   r   rT   rT   rU   r   i
  s    zFixed._filtersc                 C  s   | j jS r[   )r   r   r   rT   rT   rU   r   m
  s    zFixed._complevelc                 C  s   | j jS r[   )r   r   r   rT   rT   rU   r   q
  s    zFixed._fletcher32c                 C  s   | j jS r[   )r   rh  r   rT   rT   rU   r  u
  s    zFixed.attrsc                 C  s   dS zset our object attributesNrT   r   rT   rT   rU   	set_attrsy
  s    zFixed.set_attrsc                 C  s   dS )zget our object attributesNrT   r   rT   rT   rU   	get_attrs|
  s    zFixed.get_attrsc                 C  s   | j S )zreturn my storabler  r   rT   rT   rU   storable
  s    zFixed.storablec                 C  s   dS r  rT   r   rT   rT   rU   r  
  s    zFixed.is_existsc                 C  s   t | jdd S )Nr  )rg  rX  r   rT   rT   rU   r  
  s    zFixed.nrowszLiteral[True] | Nonec                 C  s   |dkrdS dS )z%validate against an existing storableNTrT   r  rT   rT   rU   validate
  s    zFixed.validateNc                 C  s   dS )+are we trying to operate on an old version?NrT   )r   rn   rT   rT   rU   validate_version
  s    zFixed.validate_versionc                 C  s   | j }|dkrdS |   dS )zr
        infer the axes of my storer
        return a boolean indicating if we have a valid storer or not
        NFT)rX  rW  )r   rS   rT   rT   rU   r  
  s
    zFixed.infer_axesr   r   r   c                 C  s   t dd S )Nz>cannot read on an abstract storer: subclasses should implementr   r   rn   r   r   r   rT   rT   rU   r  
  s    z
Fixed.readc                 K  s   t dd S )Nz?cannot write on an abstract storer: subclasses should implementr]  r   r   rT   rT   rU   r  
  s    zFixed.writer   r   rZ   c                 C  s0   t |||r$| jj| jdd dS tddS )zs
        support fully deleting the node in its entirety (only) - where
        specification must be None
        Tr:  Nz#cannot delete on an abstract storer)r=  r>  r   r  r   r   )r   rn   r   r   rT   rT   rU   r?  
  s    zFixed.delete)rO   rz   )N)NNNN)NNN)!r   r  r  r  r  rD  r1  r   r  rJ  rI  rd  r   r  rv  r  r2  r   r   r   r   r  rV  rW  rX  r  r  rY  r[  r  r  r  r?  rT   rT   rT   rU   rB  
  sl   
  







         rB  c                   @  sF  e Zd ZU dZedediZdd e D Zg Z	de
d< dd	d
dZdd Zdd Zdd	ddZedd	ddZdd	ddZdd	ddZdd	ddZd:dddddd Zd;dddd!d"d#d$Zdd!dd%d&d'Zdd(dd%d)d*Zd<dddd(d"d+d,Zd=d-ddd!d.d/d0Zdd1dd2d3d4Zd>dd5d6dd7d8d9ZdS )?GenericFixedza generified fixed versiondatetimer  c                 C  s   i | ]\}}||qS rT   rT   )rg   r  rK  rT   rT   rU   rL  
  s      zGenericFixed.<dictcomp>r   
attributesrX   r   c                 C  s   | j |dS )N )_index_type_mapr   )r   r  rT   rT   rU   _class_to_alias
  s    zGenericFixed._class_to_aliasc                 C  s   t |tr|S | j|tS r[   )rP   r   _reverse_index_mapr   r7   )r   aliasrT   rT   rU   _alias_to_class
  s    
zGenericFixed._alias_to_classc                 C  s   |  tt|dd}|tkr.d	dd}|}n|tkrFd
dd}|}n|}i }d|krn|d |d< |tkrnt}d|krt|d tr|d 	d|d< n|d |d< |tkst
||fS )Nindex_classrd  c                 S  s:   t j| j|d}tj|d d}|d k	r6|d|}|S )Nr  r_   UTC)r@   _simple_newrV  r6   tz_localize
tz_convert)rV  r  r  ZdtaresultrT   rT   rU   ru   
  s
    z*GenericFixed._get_index_factory.<locals>.fc                 S  s   t j| |d}tj|d dS )Nrk  r_   )rA   rm  r9   )rV  r  r  ZparrrT   rT   rU   ru   
  s    r  r  zutf-8)NN)NN)ri  rV   rg  r6   r9   r7   r<   rP   bytesrR   r   )r   r  rj  ru   r  r   rT   rT   rU   _get_index_factory
  s*    

zGenericFixed._get_index_factoryr   c                 C  s$   |dk	rt d|dk	r t ddS )zE
        raise if any keywords are passed which are not-None
        Nzqcannot pass a column specification when reading a Fixed format store. this store must be selected in its entiretyzucannot pass a where specification when reading from a Fixed format store. this store must be selected in its entirety)r   )r   r   rn   rT   rT   rU   validate_read
  s    zGenericFixed.validate_readr   c                 C  s   dS )NTrT   r   rT   rT   rU   r    s    zGenericFixed.is_existsc                 C  s   | j | j_ | j| j_dS rU  )rY   r  r   r   rT   rT   rU   rV    s    
zGenericFixed.set_attrsc              	   C  sR   t t| jdd| _tt| jdd| _| jD ]}t| |tt| j|d q.dS )retrieve our attributesrY   Nr   rz   )r^   rg  r  rY   rV   r   rc  r  )r   r   rT   rT   rU   rW    s    
zGenericFixed.get_attrsc                 K  s   |    d S r[   )rV  r   r  r   rT   rT   rU   r    s    zGenericFixed.writeNr   r  c                 C  s   ddl }t| j|}|j}t|dd}t||jrD|d || }nztt|dd}	t|dd}
|
dk	rxtj|
|	d}n||| }|	dkrt|d	d}t	||d
d}n|	dkrtj
|dd}|r|jS |S dS )z2read an array for the specified node (off of groupr   N
transposedF
value_typer  r)  r$  r  Tr%  r'  r(  )r|   rg  r   rh  rP   ZVLArrayrV   rQ   r  r  r4  T)r   r   r   r   r|   r   r  rv  retr  r  r  rT   rT   rU   
read_array   s&    zGenericFixed.read_arrayr7   )r   r   r   rZ   c                 C  sh   t t| j| d}|dkr.| j|||dS |dkrVt| j|}| j|||d}|S td| d S )N_varietymultir\  regularzunrecognized index variety: )rV   rg  r  read_multi_indexr   read_index_noder   )r   r   r   r   Zvarietyr   r   rT   rT   rU   
read_indexB  s    zGenericFixed.read_index)r   r   rZ   c                 C  s   t |tr,t| j| dd | || nt| 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	rt|j|j_d S )Nr{  r|  r}  r   )rP   r8   r  r  write_multi_index_convert_indexrY   r   write_arrayrV  rg  r   ra  rh  r`   r6   r9   rf  r   rj  r<   r  r  _get_tz)r   r   r   r;  r   rT   rT   rU   write_indexP  s    



zGenericFixed.write_indexr8   c                 C  s   t | j| d|j tt|j|j|jD ]\}\}}}t|rJt	d| d| }t
||| j| j}| ||j t| j|}	|j|	j_||	j_t |	j| d| | | d| }
| |
| q,d S )N_nlevelsz=Saving a MultiIndex with an extension dtype is not supported._level_name_label)r  r  r  	enumerater0  levelsr  namesr-   r   r  rY   r   r  rV  rg  r   ra  rh  r`   )r   r   r   ilevlevel_codesr`   	level_keyZ
conv_levelr   	label_keyrT   rT   rU   r  g  s"    
zGenericFixed.write_multi_indexc                 C  s   t | j| d}g }g }g }t|D ]l}| d| }	t | j|	}
| j|
||d}|| ||j | d| }| j|||d}|| q&t|||ddS )Nr  r  r\  r  T)r  r  r  r(  )	rg  r  rN  r   r  r   r`   rz  r8   )r   r   r   r   r  r  r  r  r  r  r   r  r  r  rT   rT   rU   r~    s&    
   zGenericFixed.read_multi_indexrM   )r   r   r   rZ   c                 C  s   ||| }d|j kr>t|j jdkr>tj|j j|j jd}t|j j}d }d|j krlt|j j	}t|}|j }| 
|\}}	|dkr|t||| j| jdfdti|	}
n|t||| j| jdf|	}
||
_	|
S )Nr  r   r)  r`   )r   r5  r  r  )rh  rQ   prodr  r  rw  rV   ra  ra   r`   rr  _unconvert_indexrY   r   r5  )r   r   r   r   ru  ra  r`   r  r  r   r   rT   rT   rU   r    sF    
      zGenericFixed.read_index_noder   )r   r   rZ   c                 C  sJ   t d|j }| j| j|| t| j|}t|j|j	_
|j|j	_dS )zwrite a 0-len arrayre   N)rQ   r  rO  r   create_arrayr   rg  rX   r  rh  rw  r  )r   r   r   Zarrr   rT   rT   rU   write_array_empty  s
    zGenericFixed.write_array_emptyr   zIndex | None)r   r  r   rZ   c              	   C  s4  t |dd}|| jkr&| j| j| |jdk}d}t|jrFtd|s^t|dr^|j	}d}d }| j
d k	rt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}	|rn,|	d	krn t|	||f }
tj|
tt d
 | j| j|t  }|| nt |jr| j!| j||"d dt#| j|j$_%nt&|jr| j!| j||j' t#| j|}t(|j)|j$_)d|j$_%n\t*|jr| j!| j||"d dt#| j|j$_%n&|r| || n| j!| j|| |t#| j|j$_+d S )NT)Zextract_numpyr   Fz]Cannot store a category dtype in a HDF5 dataset that uses format="fixed". Use format="table".rx  )r   Zskipnar  r  r  r$  r'  ),rD   r   r   r  r  r)   r  r   r  rx  r   r   r   r   ZAtomZ
from_dtypeZcreate_carrayr  r  r   rQ   Zobject_r   infer_dtyperr   r  r  r#   r&   Zcreate_vlarray
ObjectAtomr   r+   r  viewrg  rh  rw  r,   asi8r  r  r2   rv  )r   r   r  r   r   Zempty_arrayrv  r  cainferred_typer  Zvlarrr   rT   rT   rU   r    sr    





    
  
zGenericFixed.write_array)NN)NN)NN)NN)N)r   r  r  r  r6   r9   re  r   rg  rc  r  rf  ri  rr  rs  r  r  rV  rW  r  rz  r  r  r  r~  r  r  r  rT   rT   rT   rU   ra  
  s8   
.#         &
 ra  c                      sV   e Zd ZU dZdgZded< edd Zddddd	d
dZdd fddZ	  Z
S )r  r  r`   r   c              	   C  s0   zt | jjfW S  ttfk
r*   Y d S X d S r[   )rm   r   rV  r   r}   r   rT   rT   rU   r  '  s    zSeriesFixed.shapeNr   r;   r`  c                 C  s>   |  || | jd||d}| jd||d}t||| jddS )Nr   r\  rV  F)r   r`   rv  )rs  r  rz  r;   r`   )r   rn   r   r   r   r   rV  rT   rT   rU   r  .  s    zSeriesFixed.readr   r   c                   s8   t  j|f| | d|j | d| |j| j_d S )Nr   rV  )r  r  r  r   r  r`   r  ru  r  rT   rU   r  ;  s    zSeriesFixed.write)NNNN)r   r  r  rC  rc  r  r  r  r  r  r>  rT   rT   r  rU   r  !  s   

    r  c                      sZ   e Zd ZU ddgZded< eddddZdd	d	d
dddZdd fddZ  Z	S )BlockManagerFixedrO  nblocksrb   zShape | Noner   c                 C  s   z| j }d}t| jD ]8}t| jd| d}t|dd }|d k	r||d 7 }q| jj}t|dd }|d k	rt|d|d  }ng }|| |W S  tk
r   Y d S X d S )Nr   block_itemsr  re   )	rO  rN  r  rg  r   Zblock0_valuesrk   r   r}   )r   rO  r   r  r   r  rT   rT   rU   r  G  s"    
zBlockManagerFixed.shapeNr   r5   r`  c                 C  s  |  || |  d}g }t| jD ]<}||kr<||fnd\}}	| jd| ||	d}
||
 q(|d }g }t| jD ]\}| d| d}| jd| d||	d}||	| }t
|j||d d	d
}|| q|t|dkrt|ddd}|j|d	d}|S t
|d |d dS )Nr   )NNr'  r\  r  r  r9  re   Fr   r   rv  T)r'  rv  )r   rv  r   r   )rs  rF  Z_get_block_manager_axisrN  rO  r  r   r  rz  rT  r5   rx  rm   r=   rZ  )r   rn   r   r   r   Zselect_axisrA  r  r  r  axr   dfs	blk_itemsrV  dfoutrT   rT   rU   r  b  s(    zBlockManagerFixed.readr   c                   s   t  j|f| t|jtr&|d}|j}| s<| }|j| j	_t
|jD ]0\}}|dkrn|jsntd| d| | qPt|j| j	_t
|jD ]D\}}|j|j}| jd| d|j|d | d| d| qd S )Nr  r   z/Columns index has to be unique for fixed formatr'  r9  )r   r  )r  r  rP   _mgrrF   _as_managerZis_consolidatedZconsolidaterO  r  r  rA  Z	is_uniquer   r  rm   blocksr  r   rU  mgr_locsr  rV  )r   r  r   ru  r  r  blkr  r  rT   rU   r    s     

zBlockManagerFixed.write)NNNN)
r   r  r  rc  r  r  r  r  r  r>  rT   rT   r  rU   r  B  s   
    $r  c                   @  s   e Zd ZdZeZdS )r  r  N)r   r  r  rC  r5   rF  rT   rT   rT   rU   r    s   r  c                      s  e Zd ZU dZdZdZded< ded< dZded	< d
Zded< dddddddddddd
 fddZ	e
ddddZddddZdd d!d"Zddd#d$Ze
d%dd&d'Zd(d)d*d+d,Ze
d-dd.d/Ze
d%dd0d1Ze
d2d3 Ze
d4d5 Ze
d6d7 Ze
d8d9 Ze
d:d; Ze
d-dd<d=Ze
d%dd>d?Ze
d@ddAdBZdCddDdEZdFdG ZdHddIdJZdddKdLdMZddNddOdPdQZddRdSdTZ dddUdVZ!dddWdXZ"ddddYdZZ#ddd[d\Z$e%d]d^ Z&dddd_d`daZ'ddbdbdcdddedfZ(e)d%dgdhdiZ*djdk Z+ddld%dmdndoZ,e-dld%dpdqdrZ.ddsdldtdudvZ/dbd%dbdCdwdxdyZ0ddbdbdzd{d|Z1dddbdbd}d~dZ2  Z3S )r   aa  
    represent a table:
        facilitate read/write of various types of tables

    Attrs in Table Node
    -------------------
    These are attributes that are store in the main table node, they are
    necessary to recreate these tables when read back in.

    index_axes    : a list of tuples of the (original indexing axis and
        index column)
    non_index_axes: a list of tuples of the (original index axis and
        columns on a non-indexing axis)
    values_axes   : a list of the columns which comprise the data of this
        table
    data_columns  : a list of the columns that we are allowing indexing
        (these become single columns in values_axes)
    nan_rep       : the string to use for nan representations for string
        objects
    levels        : the names of levels
    metadata      : the names of the metadata columns
    Z
wide_tablert   rX   rD  r}  re   zint | list[Hashable]r  Trk   r  Nrz   r   rM   rW   zlist[IndexCol] | Nonez list[tuple[AxisInt, Any]] | Nonezlist[DataCol] | Nonezlist | Nonezdict | Noner   )
r   r   rY   r   
index_axesr#  values_axesr   rz  rZ   c                   sP   t  j||||d |pg | _|p$g | _|p.g | _|p8g | _|	pBi | _|
| _d S )Nr  )r  r   r  r#  r  r   rz  r   )r   r   r   rY   r   r  r#  r  r   rz  r   r  rT   rU   r     s    




zTable.__init__r   c                 C  s   | j dd S )N_r   )r}  r  r   rT   rT   rU   table_type_short  s    zTable.table_type_shortc                 C  s   |    t| jrd| jnd}d| d}d}| jrZddd | jD }d| d}dd	d | jD }| jd
| d| j d| j	 d| j
 d| d| dS )rN  r  rd  z,dc->[r  rM  c                 S  s   g | ]}t |qS rT   rX   r   rT   rT   rU   rj     s     z"Table.__repr__.<locals>.<listcomp>rP  c                 S  s   g | ]
}|j qS rT   r_   rt  rT   rT   rU   rj     s     rQ  z (typ->z,nrows->z,ncols->z,indexers->[rR  )r  rm   r   r  rJ  rI  r  rd  r  r  ncols)r   Zjdcr\  verZjverZjindex_axesrT   rT   rU   r     s    4zTable.__repr__)r  c                 C  s"   | j D ]}||jkr|  S qdS )zreturn the axis for cN)rA  r`   )r   r  r   rT   rT   rU   r     s    


zTable.__getitem__c              
   C  s   |dkrdS |j | j kr2td|j  d| j  ddD ]~}t| |d}t||d}||kr6t|D ]4\}}|| }||krbtd| d| d| dqbtd| d| d| dq6dS )	z"validate against an existing tableNz'incompatible table_type with existing [r  r  )r  r#  r  zinvalid combination of [z] on appending data [z] vs current table [)r}  r   rg  r  r   r<  )r   r  r  svovr  saxZoaxrT   rT   rU   rY    s&    zTable.validater   c                 C  s   t | jtS )z@the levels attribute is 1 or a list in the case of a multi-index)rP   r  rk   r   rT   rT   rU   is_multi_index  s    zTable.is_multi_indexr   z tuple[DataFrame, list[Hashable]])r  rZ   c              
   C  s^   t |jj}z| }W n, tk
rF } ztd|W 5 d}~X Y nX t|tsVt||fS )ze
        validate that we can store the multi-index; reset and return the
        new object
        zBduplicate names/columns in the multi-index when storing as a tableN)	r=  Zfill_missing_namesr   r  Zreset_indexr   rP   r5   r   )r   r  r  Z	reset_objr@  rT   rT   rU   validate_multiindex  s    zTable.validate_multiindexrb   c                 C  s   t dd | jD S )z-based on our axes, compute the expected nrowsc                 S  s   g | ]}|j jd  qS r"  )r  r  rg   r  rT   rT   rU   rj   1  s     z(Table.nrows_expected.<locals>.<listcomp>)rQ   r  r  r   rT   rT   rU   nrows_expected.  s    zTable.nrows_expectedc                 C  s
   d| j kS )zhas this table been createdrt   r  r   rT   rT   rU   r  3  s    zTable.is_existsc                 C  s   t | jdd S Nrt   rg  r   r   rT   rT   rU   rX  8  s    zTable.storablec                 C  s   | j S )z,return the table group (this is my storable))rX  r   rT   rT   rU   rt   <  s    zTable.tablec                 C  s   | j jS r[   )rt   r  r   rT   rT   rU   r  A  s    zTable.dtypec                 C  s   | j jS r[   r  r   rT   rT   rU   r  E  s    zTable.descriptionc                 C  s   t | j| jS r[   )r.  r/  r  r  r   rT   rT   rU   rA  I  s    z
Table.axesc                 C  s   t dd | jD S )z.the number of total columns in the values axesc                 s  s   | ]}t |jV  qd S r[   )rm   rV  rt  rT   rT   rU   rH  P  s     zTable.ncols.<locals>.<genexpr>)sumr  r   rT   rT   rU   r  M  s    zTable.ncolsc                 C  s   dS r  rT   r   rT   rT   rU   is_transposedR  s    zTable.is_transposedztuple[int, ...]c                 C  s(   t tdd | jD dd | jD S )z@return a tuple of my permutated axes, non_indexable at the frontc                 S  s   g | ]}t |d  qS r"  rL  rt  rT   rT   rU   rj   [  s     z*Table.data_orientation.<locals>.<listcomp>c                 S  s   g | ]}t |jqS rT   )rb   r'  rt  rT   rT   rU   rj   \  s     )rl   r.  r/  r#  r  r   rT   rT   rU   data_orientationV  s    zTable.data_orientationzdict[str, Any]c                   sR   ddd dd j D } fddjD }fddjD }t|| | S )z<return a dict of the kinds allowable columns for this objectr   r   r   re   c                 S  s   g | ]}|j |fqS rT   r  rt  rT   rT   rU   rj   f  s     z$Table.queryables.<locals>.<listcomp>c                   s   g | ]\}} | d fqS r[   rT   )rg   r'  rV  )
axis_namesrT   rU   rj   g  s     c                   s&   g | ]}|j t jkr|j|fqS rT   )r`   rM  r   r  r,  r   rT   rU   rj   h  s     )r  r#  r  rC  )r   d1Zd2Zd3rT   )r  r   rU   
queryables`  s    

zTable.queryablesc                 C  s   dd | j D S )zreturn a list of my index colsc                 S  s   g | ]}|j |jfqS rT   )r'  r  r  rT   rT   rU   rj   q  s     z$Table.index_cols.<locals>.<listcomp>r  r   rT   rT   rU   
index_colsn  s    zTable.index_colsr   c                 C  s   dd | j D S )zreturn a list of my values colsc                 S  s   g | ]
}|j qS rT   r  r  rT   rT   rU   rj   u  s     z%Table.values_cols.<locals>.<listcomp>)r  r   rT   rT   rU   values_colss  s    zTable.values_colsr   c                 C  s   | j j}| d| dS )z)return the metadata pathname for this keyz/meta/z/metarT  r  rT   rT   rU   _get_metadata_pathw  s    zTable._get_metadata_pathr  )r   rV  rZ   c                 C  s0   | j j| |t|ddd| j| j| jd dS )z
        Write out a metadata array to the key as a fixed-format Series.

        Parameters
        ----------
        key : str
        values : ndarray
        Fr1  rt   )r   rY   r   r   N)r   r   r  r;   rY   r   r   )r   r   rV  rT   rT   rU   r  |  s    	
zTable.write_metadatar   c                 C  s0   t t | jdd|ddk	r,| j| |S dS )z'return the meta data array for this keyr   N)rg  r   r   r   r  r   rT   rT   rU   r    s    zTable.read_metadatac                 C  sp   t | j| j_|  | j_|  | j_| j| j_| j| j_| j| j_| j| j_| j	| j_	| j
| j_
| j| j_dS )zset our table type & indexablesN)rX   r}  r  r  r  r#  r   r   rY   r   r  rz  r   rT   rT   rU   rV    s    





zTable.set_attrsc                 C  s   t | jddpg | _t | jddp$g | _t | jddp8i | _t | jdd| _tt | jdd| _tt | jdd| _	t | jd	dpg | _
d
d | jD | _dd | jD | _dS )rt  r#  Nr   rz  r   rY   r   rz   r  c                 S  s   g | ]}|j r|qS rT   r  rt  rT   rT   rU   rj     s      z#Table.get_attrs.<locals>.<listcomp>c                 S  s   g | ]}|j s|qS rT   r  rt  rT   rT   rU   rj     s      )rg  r  r#  r   rz  r   r^   rY   rV   r   r  
indexablesr  r  r   rT   rT   rU   rW    s    zTable.get_attrsc                 C  s>   |dk	r:| j r:tddd | jD  }tj|tt d dS )rZ  NrM  c                 S  s   g | ]}t |qS rT   r  r   rT   rT   rU   rj     s     z*Table.validate_version.<locals>.<listcomp>r  )rJ  rp   r  rI  r  r  r"   r&   )r   rn   r  rT   rT   rU   r[    s    zTable.validate_versionc                 C  sR   |dkrdS t |tsdS |  }|D ]&}|dkr4q&||kr&td| dq&dS )z
        validate the min_itemsize doesn't contain items that are not in the
        axes this needs data_columns to be defined
        NrV  zmin_itemsize has the key [z%] which is not an axis or data_column)rP   rC  r  r   )r   r   qr  rT   rT   rU   validate_min_itemsize  s    

zTable.validate_min_itemsizec                   s   g }j jjtjjD ]j\}\}}t|}|}|dk	rJdnd}| d}t|d}	t||||	|j||d}
||
 qt	j
t|  fdd|fddtjjD  |S )	z/create/cache the indexables if they don't existNr  r  )r`   r'  r  ra  r  rt   r   r  c                   s   t |tstt}|krt}t|}t|j}t| dd }t| dd }t|}	|}t| dd }	||||| |  |j
|	||d
}
|
S )Nr  r  r  )
r`   r  rV  ra  r  r  rt   r   r  r  )rP   rX   r   r  r?  rg  _maybe_adjust_namerI  r  r  rt   )r  r  klassr  adj_namerV  r  ra  mdr   r  )base_posr\  descr   table_attrsrT   rU   ru     s0    

zTable.indexables.<locals>.fc                   s   g | ]\}} ||qS rT   rT   )rg   r  r  )ru   rT   rU   rj     s     z$Table.indexables.<locals>.<listcomp>)r  rt   r  r  r  rg  r  r  r   rM  r   rm   rQ  r  )r   _indexablesr  r'  r`   r  r  r   r  ra  	index_colrT   )r  r\  r  ru   r   r  rU   r    s2    




% zTable.indexablesr  c              	   C  sR  |   sdS |dkrdS |dks(|dkr8dd | jD }t|ttfsL|g}i }|dk	r`||d< |dk	rp||d< | j}|D ]}t|j|d}|dk	r|jr|j	}|j
}	|j}
|dk	r|
|kr|  n|
|d< |dk	r|	|kr|  n|	|d< |jsL|jdrtd	|jf | qz|| jd
 d krztd| d| d| dqzdS )aZ  
        Create a pytables index on the specified columns.

        Parameters
        ----------
        columns : None, bool, or listlike[str]
            Indicate which columns to create an index on.

            * False : Do not create any indexes.
            * True : Create indexes on all columns.
            * None : Create indexes on all columns.
            * listlike : Create indexes on the given columns.

        optlevel : int or None, default None
            Optimization level, if None, pytables defaults to 6.
        kind : str or None, default None
            Kind of index, if None, pytables defaults to "medium".

        Raises
        ------
        TypeError if trying to create an index on a complex-type column.

        Notes
        -----
        Cannot index Time64Col or ComplexCol.
        Pytables must be >= 3.0.
        NFTc                 S  s   g | ]}|j r|jqS rT   )r  r  rt  rT   rT   rU   rj   >  s      z&Table.create_index.<locals>.<listcomp>r`  ra  complexzColumns containing complex values can be stored but cannot be indexed when using table format. Either use fixed format, set index=False, or do not include the columns containing complex values to data_columns when initializing the table.r   re   zcolumn z/ is not a data_column.
In order to read column z: you must reload the dataframe 
into HDFStore and include z  with the data_columns argument.)r  rA  rP   rl   rk   rt   rg  rG  rs  r   r`  ra  Zremove_indexr   rn  r   rb  r#  r}   )r   r   r`  ra  kwrt   r  rK  r   Zcur_optlevelZcur_kindrT   rT   rU   rb    sJ    


zTable.create_indexr   z!list[tuple[ArrayLike, ArrayLike]]r`  c           	      C  sZ   t | |||d}| }g }| jD ]2}|| j |j|| j| j| jd}|	| q"|S )a  
        Create the axes sniffed from the table.

        Parameters
        ----------
        where : ???
        start : int or None, default None
        stop : int or None, default None

        Returns
        -------
        List[Tuple[index_values, column_values]]
        r  r3  )
	Selectionr   rA  r  rz  r  r   rY   r   r   )	r   rn   r   r   	selectionrV  r  r   resrT   rT   rU   
_read_axeso  s    
zTable._read_axesrv  c                 C  s   |S )zreturn the data for this objrT   r  r  rv  rT   rT   rU   
get_object  s    zTable.get_objectc                   s   t |sg S |d \} | j|i }|ddkrL|rLtd| d| |dkr^t }n|dkrjg }t|trt|t|}|fdd	|	 D   fd
d	|D S )zd
        take the input data_columns and min_itemize and create a data
        columns spec
        r   r   r8   z"cannot use a multi-index on axis [z] with data_columns TNc                   s    g | ]}|d kr| kr|qS r  rT   r  )existing_data_columnsrT   rU   rj     s    z/Table.validate_data_columns.<locals>.<listcomp>c                   s   g | ]}| kr|qS rT   rT   )rg   r  )axis_labelsrT   rU   rj     s      )
rm   rz  r   r   rk   rP   rC  rM  rQ  r   )r   r   r   r#  r'  rz  rT   )r  r  rU   validate_data_columns  s*    


	zTable.validate_data_columnsr5   )r  rY  c           /        s  t ts,| jj}td| dt d dkr:dg fdd D  |  rzd}d	d | jD  t| j	}| j
}nd
}| j}	| jdkstt | jd krtdg }
|dkrd} 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stt|
dkst|
D ]}t"|d |d q|jdk}| #|||
}| $|% }| &|||
| j'|\}}g }t(t)||D ]\}\}}t*}d}|rt|dkr|d |krt+}|d }|dkst |t,st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	rt8|"j9}&d }' }(})t:|"j5r|"j;})d}'tj|"j<d
d= }(t>|"\}*}+||#|!t||$||%|&|)|'|(|+|*d},|, |	 ||, |d7 }qddd |D }-t| | j?| j| j| j||
||-|	|d
}.t@| drj| jA|._A|.B| |r|r|.C|  |.S )a0  
        Create and return the axes.

        Parameters
        ----------
        axes: list or None
            The names or numbers of the axes to create.
        obj : DataFrame
            The object to create axes on.
        validate: bool, default True
            Whether to validate the obj against an existing object already written.
        nan_rep :
            A value to use for string column nan_rep.
        data_columns : List[str], True, or None, default None
            Specify the columns that we want to create to allow indexing on.

            * True : Use all available columns.
            * None : Use no columns.
            * List[str] : Use the specified columns.

        min_itemsize: Dict[str, int] or None, default None
            The min itemsize for a column in bytes.
        z/cannot properly create the storer for: [group->r  r  Nr   c                   s   g | ]}  |qS rT   )_get_axis_numberrt  )r  rT   rU   rj     s     z&Table._create_axes.<locals>.<listcomp>Tc                 S  s   g | ]
}|j qS rT   rI  rt  rT   rT   rU   rj     s     FrH  re   z<currently only support ndim-1 indexers in an AppendableTablenanc                   s   g | ]}| kr|qS rT   rT   r   )rA  rT   rU   rj     s      r  r  r   r@  zIncompatible appended table [z]with existing table [Zvalues_block_)existing_colr   r   rY   r   r   r  r  r1  )r`   r  rV  r  r  ra  r  r[  r   r  r  ru  c                 S  s   g | ]}|j r|jqS rT   )r  r`   )rg   r  rT   rT   rU   rj     s      )
r   r   rY   r   r  r#  r  r   rz  r   r  )DrP   r5   r   r   r   r   r  r  rk   r   r   rz  rO  r   rm   r   rA  r#  r4   rQ   arrayrS  r  r  r   r   Z_get_axis_namer  rY   r   r'  r  r  r  _reindex_axisr  r  r)  _get_blocks_and_itemsr  r  r0  r  r?  rX   
IndexErrorr   _maybe_convert_for_string_atomrV  r  rI  r  r  r  r`   rg  r  r  r)   r[  r0  r6  r  r   r  r  r  rY  )/r   rA  r  rY  r   r   r   r   table_existsZnew_infonew_non_index_axesr  r   Zappend_axisZindexerZ
exist_axisrz  	axis_nameZ	new_indexZnew_index_axesjrv  r  r  r  Zvaxesr  r  b_itemsr  r`   r  r@  new_namedata_convertedr  r  ra  r  r   r  r[  ru  r  r  ZdcsZ	new_tablerT   )rA  r  rU   _create_axes  s"    


 





      "






zTable._create_axes)r  r  c                 C  s  t | jtr| d} dd }| j}tt|}t|j}||}t|r|d \}	}
t	|

t	|}| j||	dj}tt|}t|j}||}|D ]:}| j|g|	dj}tt|}||j ||| q|rdd t||D }g }g }|D ]}t|j}z&||\}}|| || W q ttfk
rz } z*dd	d
 |D }td| d|W 5 d }~X Y qX q|}|}||fS )Nr  c                   s    fdd j D S )Nc                   s   g | ]} j |jqS rT   )r   rU  r  )rg   r  mgrrT   rU   rj     s     zFTable._get_blocks_and_items.<locals>.get_blk_items.<locals>.<listcomp>)r  r  rT   r  rU   get_blk_items  s    z2Table._get_blocks_and_items.<locals>.get_blk_itemsr   rI  c                 S  s"   i | ]\}}t | ||fqS rT   )rl   tolist)rg   br  rT   rT   rU   rL    s   
 z/Table._get_blocks_and_items.<locals>.<dictcomp>r  c                 S  s   g | ]}t |qS rT   rO  )rg   itemrT   rT   rU   rj     s     z/Table._get_blocks_and_items.<locals>.<listcomp>z+cannot match existing table structure for [z] on appending data)rP   r  rF   r  r   rG   rk   r  rm   r7   rR  rZ  rQ  r0  rl   rV  r3  r   r  r   r  r   )r  r  r  r  r   r  r  r  r  r'  r  Z
new_labelsr  Zby_itemsZ
new_blocksZnew_blk_itemsZear   r  r  r@  ZjitemsrT   rT   rU   r    sR    








zTable._get_blocks_and_itemsr  )r  rZ   c                   s   |dk	rt |}|dk	rNjrNtjt s.tjD ]}||kr4|d| q4jD ]$\}}t |||  fdd}qT|jdk	r|j	 D ]\}}	}
|||
|	 q S )zprocess axes filtersNr   c                   s    j D ]} |} |}|d k	s*t| |krfjrH|tj}|||} j|d|   S | |krt	t
 | j}t	|}t trd| }|||} j|d|   S qtd|  dd S )NrI  re   zcannot find the field [z] for filtering!)Z_AXIS_ORDERSr  	_get_axisr   r  unionr7   r  rY  rE   rg  rV  rP   r5   r   )fieldfiltopr  Zaxis_numberZaxis_valuesZtakersrV  r  r   rT   rU   process_filter  s"    





z*Table.process_axes.<locals>.process_filter)
rk   r  rP   r  r   insertr#  r  filterr   )r   r  r  r   r   r'  labelsr  r  r  r  rT   r  rU   process_axes  s    
 
zTable.process_axes)r   r   rB  rZ   c                 C  s   |dkrt | jd}d|d}dd | jD |d< |rj|dkrH| jpFd}t j|||pZ| jd	}||d
< n| jdk	r~| j|d
< |S )z:create the description of the table from the axes & valuesNi'  rt   )r`   rB  c                 S  s   i | ]}|j |jqS rT   )r  r  rt  rT   rT   rU   rL  .  s      z,Table.create_description.<locals>.<dictcomp>r  	   )r   r   r   r   )maxr  rA  r   r   r   r   r   )r   r   r   r   rB  rD  r   rT   rT   rU   create_description  s     	




zTable.create_descriptionr\  c           
      C  s   |  | |  sdS t| |||d}| }|jdk	r|j D ]D\}}}| j|| | d d}	|||	j	||   |j
 }qBt|S )zf
        select coordinates (row numbers) from a table; return the
        coordinates object
        Fr  Nre   r\  )r[  r  r  select_coordsr  r   r  r  r  ilocrV  r7   )
r   rn   r   r   r  Zcoordsr  r  r  ru  rT   rT   rU   r  >  s    

  
 zTable.read_coordinatesr  c                 C  s   |    |  sdS |dk	r$td| jD ]|}||jkr*|jsNtd| dt| jj	|}|
| j |j||| | j| j| jd}tt|d |j|dd  S q*td| d	dS )
zj
        return a single column from the table, generally only indexables
        are interesting
        FNz4read_column does not currently accept a where clausezcolumn [z=] can not be extracted individually; it is not data indexabler3  re   )r`   rv  z] not found in the table)r[  r  r   rA  r`   r  r   rg  rt   rG  r  rz  r  r   rY   r   r;   r  r  r   )r   r  rn   r   r   r   r  Z
col_valuesrT   rT   rU   r  X  s*    



 zTable.read_column)Nrz   NNNNNN)N)NNN)NN)TNNN)N)NNN)NNN)4r   r  r  r  rC  rD  r  r  r1  r   r  r  r   r   rY  r  r  r  r  rX  rt   r  r  rA  r  r  r  r  r  r  r  r  r  rV  rW  r[  r  r%   r  rb  r  r=  r  r  r  staticmethodr  r  r  r  r  r>  rT   rT   r  rU   r     s   
        &!




	
L     W   "*     iC7         r   c                   @  s4   e Zd ZdZdZddddddZdd	d
dZdS )r  z
    a write-once read-many table: this format DOES NOT ALLOW appending to a
    table. writing is a one-time operation the data are stored in a format
    that allows for searching the data on disk
    r  Nr   r\  c                 C  s   t ddS )z[
        read the indices and the indexing array, calculate offset rows and return
        z!WORMTable needs to implement readNr]  r^  rT   rT   rU   r    s    
zWORMTable.readr   r   c                 K  s   t ddS )z
        write in a format that we can search later on (but cannot append
        to): write out the indices and the values using _write_array
        (e.g. a CArray) create an indexing table so that we can search
        z"WORMTable needs to implement writeNr]  r_  rT   rT   rU   r    s    zWORMTable.write)NNNN)r   r  r  r  r}  r  r  rT   rT   rT   rU   r    s       r  c                   @  sf   e Zd ZdZdZddddddd	d
ZdddddddZddddddddZddddddZdS )r  (support the new appendable table formatsZ
appendableNFTr   r   )r   r   r6  rZ   c                 C  s   |s| j r| j| jd | j||||||d}|jD ]}|  q6|j s~|j||||	d}|  ||d< |jj	|jf| |j
|j_
|jD ]}||| q|j||
d d S )Nrt   )rA  r  rY  r   r   r   )r   r   r   rB  r6  )r   )r  r   r  r   r  rA  r  r  rV  Zcreate_tablerz  r  r  
write_data)r   r  rA  r   r   r   r   r   r   rB  r   r   r   r6  rt   r   optionsrT   rT   rU   r    s4    
	



zAppendableTable.writer   )r   r   rZ   c                   s  | j j}| j}g }|rT| jD ]6}t|jjdd}t|tj	r|
|jddd qt|r|d }|dd D ]}||@ }qp| }nd}dd	 | jD }	t|	}
|
dkst|
d
d	 | jD }dd	 |D }g }t|D ]2\}}|f| j ||
|   j }|
|| q|dkr d}tjt||| j d}|| d }t|D ]x}|| t|d | |  krx q| j| fdd	|	D |dk	r|  nd fdd	|D d qJdS )z`
        we form the data into a 2-d including indexes,values,mask write chunk-by-chunk
        r   rI  u1Fr1  re   Nc                 S  s   g | ]
}|j qS rT   )r  rt  rT   rT   rU   rj     s     z.AppendableTable.write_data.<locals>.<listcomp>c                 S  s   g | ]}|  qS rT   )r  rt  rT   rT   rU   rj     s     c              	   S  s,   g | ]$}| tt|j|jd  qS r  )Z	transposerQ   ZrollarangerO  r,  rT   rT   rU   rj     s     r  r)  c                   s   g | ]}|  qS rT   rT   rt  Zend_iZstart_irT   rU   rj     s     c                   s   g | ]}|  qS rT   rT   r,  r  rT   rU   rj     s     )indexesr<  rV  )r  r  r  r  r>   ru  rE  rP   rQ   r  r   r8  rm   r6  r  r   r  r  reshaper  r  rN  write_data_chunk)r   r   r   r  r  masksr   r<  mr  nindexesrV  bvaluesr  rK  Z	new_shaperowschunksrT   r  rU   r    sL    




zAppendableTable.write_datar  zlist[np.ndarray]znpt.NDArray[np.bool_] | None)r  r  r<  rV  rZ   c                 C  s   |D ]}t |js dS q|d jd }|t|krFt j|| jd}| jj}t|}t|D ]\}	}
|
|||	 < q^t|D ]\}	}||||	|  < q||dk	r| j	t
dd }| s|| }t|r| j| | j  dS )z
        Parameters
        ----------
        rows : an empty memory space where we are putting the chunk
        indexes : an array of the indexes
        mask : an array of the masks
        values : an array of the values
        Nr   r)  Fr1  )rQ   r  r  rm   r  r  r  r  r6  r8  r   rE  rt   r   r   )r   r  r  r<  rV  rK  r  r  r  r  r  r  rT   rT   rU   r    s&    z AppendableTable.write_data_chunkr\  c                 C  sf  |d kst |sf|d kr:|d kr:| j}| jj| jdd n(|d krH| j}| jj||d}| j  |S |  srd S | j}t	| |||d}|
 }t|dd }t |}	|	rb| }
t|
|
dk j}t |sdg}|d |	kr||	 |d dkr|dd | }t|D ]@}|t||}|j||jd  ||jd  d d |}q| j  |	S )	NTr:  r\  Fr1  re   r   r/  )rm   r  r   r  r   rt   Zremove_rowsr   r  r  r  r;   Zsort_valuesdiffrk   r   r   r   r3  reversedrU  rN  )r   rn   r   r   r  rt   r  rV  Zsorted_serieslnr  r   Zpgr   r  rT   rT   rU   r?  J  sF    

 
zAppendableTable.delete)NFNNNNNNFNNT)F)NNN)	r   r  r  r  r}  r  r  r  r?  rT   rT   rT   rU   r    s$               ;;,r  c                   @  s`   e Zd ZU dZdZdZdZeZde	d< e
ddd	d
ZeddddZddddddZdS )r  r
  r~  r  rH  rE  rF  r   r   c                 C  s   | j d jdkS )Nr   re   )r  r'  r   rT   rT   rU   r    s    z"AppendableFrameTable.is_transposedr  c                 C  s   |r
|j }|S )zthese are written transposed)rx  r  rT   rT   rU   r    s    zAppendableFrameTable.get_objectNr   r\  c                   s2    |   sd S  j|||d}t jrH j jd d i ni } fddt jD }t|dkstt	|d }|| d }	g }
t jD ]P\}}| j
krq|| \}}|ddkrt|}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rt|j||dd}n.t|trt|||d}ntj|g||d}|j|jk st	|j|jf|
| qt|
dkr|
d }nt|
dd}t |||d} j |||d}|S )Nr  r   c                   s"   g | ]\}}| j d  kr|qS r"  r  )rg   r  r  r   rT   rU   rj     s      z-AppendableFrameTable.read.<locals>.<listcomp>re   r   r8   r  TZinplacer`   r_   Fr  r  rI  )r  r   )!r[  r  r  rm   r#  rz  r   r  rA  r   r  r7   r8   from_tuples	set_namesr  rg  rx  rO  rP   rQ   r  r  r  r5   Z_from_arraysZdtypesr  rE  r   r=   r  r  )r   rn   r   r   r   rp  rz  Zindsindr   framesr  r   Z
index_valsr  rG  r  rV  Zindex_Zcols_r  r  rT   r   rU   r    sZ    




"
zAppendableFrameTable.read)NNNN)r   r  r  r  rC  r}  rO  r5   rF  r  r  r  r=  r  r  rT   rT   rT   rU   r    s   
    r  c                      sn   e Zd ZdZdZdZdZeZe	ddddZ
edd	d
dZd fdd	Zddddd fddZ  ZS )r  r
  r  r  rH  r   r   c                 C  s   dS r  rT   r   rT   rT   rU   r    s    z#AppendableSeriesTable.is_transposedr  c                 C  s   |S r[   rT   r  rT   rT   rU   r    s    z AppendableSeriesTable.get_objectNc                   s<   t |ts|jpd}||}t jf ||j d|S )+we are going to write this as a frame tablerV  r  r   )rP   r5   r`   Zto_framer  r  r   r  )r   r  r   r   r`   r  rT   rU   r    s    


zAppendableSeriesTable.writer   r;   r`  c                   s   | j }|d k	rB|rBt| jts"t| jD ]}||kr(|d| q(t j||||d}|rj|j| jdd |j	d d df }|j
dkrd |_
|S )Nr   r&  Tr  rV  )r  rP   r  rk   r   r   r  r  	set_indexr  r`   )r   rn   r   r   r   r  r   rS   r  rT   rU   r    s    

zAppendableSeriesTable.read)N)NNNN)r   r  r  r  rC  r}  rO  r;   rF  r  r  r=  r  r  r  r>  rT   rT   r  rU   r    s   	    r  c                      s(   e Zd ZdZdZdZ fddZ  ZS )r  r
  r  r  c                   s^   |j pd}| |\}| _t| jts*tt| j}|| t||_t	 j
f d|i|S )r!  rV  r  )r`   r  r  rP   rk   r   r   r7   r   r  r  )r   r  r   r`   ZnewobjrG  r  rT   rU   r    s    



z AppendableMultiSeriesTable.write)r   r  r  r  rC  r}  r  r>  rT   rT   r  rU   r    s   r  c                   @  sj   e Zd ZU dZdZdZdZeZde	d< e
ddd	d
Ze
dd ZddddZedd Zdd ZdS )r  z:a table that read/writes the generic pytables table formatr~  r  rH  zlist[Hashable]r  rX   r   c                 C  s   | j S r[   )rC  r   rT   rT   rU   rd  2  s    zGenericTable.pandas_typec                 C  s   t | jdd p| jS r  r  r   rT   rT   rU   rX  6  s    zGenericTable.storabler   c                 C  sL   g | _ d| _g | _dd | jD | _dd | jD | _dd | jD | _dS )rt  Nc                 S  s   g | ]}|j r|qS rT   r  rt  rT   rT   rU   rj   @  s      z*GenericTable.get_attrs.<locals>.<listcomp>c                 S  s   g | ]}|j s|qS rT   r  rt  rT   rT   rU   rj   A  s      c                 S  s   g | ]
}|j qS rT   r_   rt  rT   rT   rU   rj   B  s     )r#  r   r  r  r  r  r   r   rT   rT   rU   rW  :  s    zGenericTable.get_attrsc           
   
   C  s   | j }| d}|dk	rdnd}tdd| j||d}|g}t|jD ]^\}}t|tsZtt	||}| |}|dk	rzdnd}t
|||g|| j||d}	||	 qD|S )z0create the indexables from the table descriptionr   Nr  r   )r`   r'  rt   r   r  )r`   r  rV  r  rt   r   r  )r  r  r  rt   r  Z_v_namesrP   rX   r   rg  rA  r   )
r   rD  r  r   r  r  r  r   r  r\  rT   rT   rU   r  D  s6    
    

	zGenericTable.indexablesc                 K  s   t dd S )Nz cannot write on an generic tabler]  r_  rT   rT   rU   r  g  s    zGenericTable.writeN)r   r  r  r  rC  r}  rO  r5   rF  r  r  rd  rX  rW  r%   r  r  rT   rT   rT   rU   r  )  s   



"r  c                      s`   e Zd ZdZdZeZdZe	dZ
eddddZd fd
d	Zdddd fddZ  ZS )r  za frame with a multi-indexr  rH  z^level_\d+$rX   r   c                 C  s   dS )NZappendable_multirT   r   rT   rT   rU   r  s  s    z*AppendableMultiFrameTable.table_type_shortNc                   sx   |d krg }n|dkr |j  }| |\}| _t| jts@t| jD ]}||krF|d| qFt j	f ||d|S )NTr   r"  )
r   r  r  r  rP   rk   r   r   r  r  )r   r  r   r   r   r  rT   rU   r  w  s    

zAppendableMultiFrameTable.writer   r\  c                   sD   t  j||||d}| j}|j fdd|jjD |_|S )Nr&  c                   s    g | ]} j |rd n|qS r[   )
_re_levelssearch)rg   r`   r   rT   rU   rj     s     z2AppendableMultiFrameTable.read.<locals>.<listcomp>)r  r  r#  r  r   r  r  )r   rn   r   r   r   r  r  r   rU   r    s    zAppendableMultiFrameTable.read)N)NNNN)r   r  r  r  r}  r5   rF  rO  recompiler$  r  r  r  r  r>  rT   rT   r  rU   r  k  s   
    r  r5   r   r7   )r  r'  r  rZ   c                 C  s   |  |}t|}|d k	r"t|}|d ks4||rB||rB| S t| }|d k	rlt| j|dd}||std d g| j }|||< | jt| } | S )NF)sort)	r  rE   equalsuniquerX  slicerO  rY  rl   )r  r'  r  r  r  ZslicerrT   rT   rU   r    s    

r  r   zstr | tzinfo)r  rZ   c                 C  s   t | }|S )z+for a tz-aware type, return an encoded zone)r   Zget_timezone)r  zonerT   rT   rU   r    s    
r  znp.ndarray | Indexr6   )rV  r  r&  rZ   c                 C  s   d S r[   rT   rV  r  r&  rT   rT   rU   r    s    r  r  c                 C  s   d S r[   rT   r-  rT   rT   rU   r    s    zstr | tzinfo | Noneznp.ndarray | DatetimeIndexc                 C  s   t | tr"| jdks"| j|ks"t|dk	rtt | trB| j}| j} nd}|  } t|}t| |d} | d	|} n|rt
j| dd} | S )a  
    coerce the values to a DatetimeIndex if tz is set
    preserve the input shape if possible

    Parameters
    ----------
    values : ndarray or Index
    tz : str or tzinfo
    coerce : if we do not have a passed timezone, coerce to M8[ns] ndarray
    Nr_   rl  M8[ns]r)  )rP   r6   r  r   r`   r  r6  rV   rn  ro  rQ   r4  )rV  r  r&  r`   rT   rT   rU   r    s    

)r`   r   rY   r   rZ   c              
   C  s  t | tst|j}t|\}}t|}t|}t |jt	jrHt
|s\t|js\t|jrt| |||t|dd t|dd |dS t |trtdtj|dd}	t	|}
|	dkrt	jdd	 |
D t	jd
}t| |dt  |dS |	dkrt|
||}|jj}t| |dt ||dS |	dkr:t| ||||dS t |t	jrT|jtksXt|dksjt|t  }t| ||||dS d S )Nr  r  )rV  ra  r  r  r  r  zMultiIndex not supported here!Fr  r   c                 S  s   g | ]}|  qS rT   )	toordinalr,  rT   rT   rU   rj     s     z"_convert_index.<locals>.<listcomp>r)  )r  r  )integerZfloating)rV  ra  r  r  r5  )rP   rX   r   r`   r  r  r?  r  r  rQ   r.   r3   r(   r  rg  r8   r   r   r  r4  Zint32r   Z	Time32Col_convert_string_arrayr  r  r  r5  r  )r`   r   rY   r   r  r;  r  ra  r  r  rV  r  rT   rT   rU   r    sr    





    


    
r  )ra  rY   r   rZ   c                 C  s   |dkrt | }n|dkr$t| }n|dkrxztjdd | D td}W q tk
rt   tjdd | D td}Y qX nT|dkrt| }n@|d	krt| d ||d
}n&|dkrt| d }ntd| |S )Nr$  r'  r   c                 S  s   g | ]}t |qS rT   r*  r,  rT   rT   rU   rj   0  s     z$_unconvert_index.<locals>.<listcomp>r)  c                 S  s   g | ]}t |qS rT   r-  r,  rT   rT   rU   rj   2  s     )r0  floatr   r  r3  r5  r   zunrecognized index type )r6   r<   rQ   r4  r5  r   r:  )ru  ra  rY   r   r   rT   rT   rU   r  '  s,    

    r  r   r   )r`   r  r   c                 C  s  |j tkr|S ttj|}|j j}tj|dd}	|	dkr@td|	dkrPtd|	dksd|dksd|S t	|}
|
 }|||
< tj|dd}	|	dkrt|jd	 D ]V}|| }tj|dd}	|	dkrt||kr|| nd
| }td| d|	 dqt||||j}|j}t|tr>t|| p:|dp:d	}t|pHd	|}|d k	rz||}|d k	rz||krz|}|jd| dd}|S )NFr  r   z+[date] is not implemented as a table columnrb  z>too many timezones in this block, create separate data columnsr  r5  r   zNo.zCannot serialize the column [z2]
because its data contents are not [string] but [z] object dtyperV  z|Sr1  )r  r5  r   rQ   r  r`   r   r  r   r>   rv  rN  r  rm   r1  r  r  rP   rC  rb   r   r  r  r8  )r`   r  r  r   r   rY   r   r   r  r  r<  ru  r  r  Zerror_column_labelr  r  ZecirT   rT   rU   r  @  sJ    

 

r  )ru  rY   r   rZ   c                 C  s`   t | r,t|  ddj||j| j} t|  }t	dt
|}tj| d| d} | S )a  
    Take a string-like that is object dtype and coerce to a fixed size string type.

    Parameters
    ----------
    data : np.ndarray[object]
    encoding : str
    errors : str
        Handler for encoding errors.

    Returns
    -------
    np.ndarray[fixed-length-string]
    Fr1  re   Sr)  )rm   r;   r6  rX   encoder9  r  r  r'   r  
libwritersmax_len_string_arrayrQ   r4  )ru  rY   r   ensuredr  rT   rT   rU   r1    s     r1  c                 C  s   | j }tj|  td} t| rztt| }d| }t	| d t
rbt| ddjj||dj} n| j|ddjtdd} |dkrd}t| | | |S )	a*  
    Inverse of _convert_string_array.

    Parameters
    ----------
    data : np.ndarray[fixed-length-string]
    nan_rep : the storage repr of NaN
    encoding : str
    errors : str
        Handler for encoding errors.

    Returns
    -------
    np.ndarray[object]
        Decoded data.
    r)  Ur   Fr1  )r   Nr  )r  rQ   r4  r6  r5  rm   r5  r6  r'   rP   rq  r;   rX   rR   r9  r8  Z!string_array_replace_from_nan_repr  )ru  r   rY   r   r  r  r  rT   rT   rU   r:    s    
r:  )rV  r  rY   r   c                 C  s6   t |tstt|t|r2t|||}|| } | S r[   )rP   rX   r   r   _need_convert_get_converter)rV  r  rY   r   convrT   rT   rU   r    s
    r  ra  rY   r   c                   s8   | dkrdd S | dkr& fddS t d|  d S )Nr$  c                 S  s   t j| ddS )Nr.  r)  )rQ   r4  r!  rT   rT   rU   r         z _get_converter.<locals>.<lambda>r  c                   s   t | d  dS )Nr3  )r:  r=  r  rT   rU   r     s
      zinvalid kind )r   r<  rT   r  rU   r:    s
    r:  r  c                 C  s   | dkrdS dS )N)r$  r  TFrT   r  rT   rT   rU   r9    s    r9  zSequence[int])r`   rI  rZ   c                 C  sl   t |tst|dk rtd|d dkrh|d dkrh|d dkrhtd| }|rh| d }d| } | S )	z
    Prior to 0.10.1, we named values blocks like: values_block_0 an the
    name values_0, adjust the given name if necessary.

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

    Returns
    -------
    str
       z6Version is incorrect, expected sequence of 3 integers.r   re   rG  rH  zvalues_block_(\d+)Zvalues_)rP   rX   rm   r   r&  r%  r   )r`   rI  r  grprT   rT   rU   r    s    $
r  )	dtype_strrZ   c                 C  s   t | } | ds| dr"d}n| dr2d}n| drBd}n| dsV| dr\d}nn| drld}n^| d	r|d
}nN| drd}n>| drd}n.| drd}n| dkrd}ntd|  d|S )zA
    Find the "kind" string describing the given dtype name.
    r  rq  r2  r  rb   r  r0  r$  	timedeltar'  r   r  r  r5  zcannot interpret dtype of [r  )rV   rn  r   )rA  ra  rT   rT   rU   r     s.    






r  r
  c                 C  sb   t | tr| j} | jjdd }| jjdkr@t| 	d} nt | t
rP| j} t| } | |fS )zJ
    Convert the passed data into a storable form and a dtype string.
    rP  r   )r  Mr  )rP   r?   r  r  r`   r  ra  rQ   r4  r  r9   r  )ru  r  rT   rT   rU   r  !  s    


r  c                   @  s>   e Zd ZdZddddddddZd	d
 Zdd Zdd ZdS )r  z
    Carries out a selection operation on a tables.Table object.

    Parameters
    ----------
    table : a Table object
    where : list of Terms (or convertible to)
    start, stop: indices to start and/or stop selection

    Nr   r   r   )rt   r   r   rZ   c              	   C  s@  || _ || _|| _|| _d | _d | _d | _d | _t|rt	t
 tj|dd}|dkrt|}|jtjkr| j| j }}|d krd}|d kr| j j}t||| | _nNt|jjtjr| jd k	r|| jk  s| jd k	r|| jk rt
d|| _W 5 Q R X | jd kr<| || _| jd k	r<| j \| _| _d S )NFr  )r0  booleanr   z3where must have index locations >= start and < stop)rt   rn   r   r   	conditionr  Ztermsr-  r/   r   r   r   r  rQ   r4  r  Zbool_r  r  
issubclassr   r0  r7  generateevaluate)r   rt   rn   r   r   inferredrT   rT   rU   r   C  sD    


zSelection.__init__c              
   C  s   |dkrdS | j  }zt||| j jdW S  tk
rz } z2d| }td| d| d}t||W 5 d}~X Y nX dS )z'where can be a : dict,list,tuple,stringN)r  rY   r  z-                The passed where expression: a*  
                            contains an invalid variable reference
                            all of the variable references must be a reference to
                            an axis (e.g. 'index' or 'columns'), or a data_column
                            The currently defined references are: z
                )	rt   r  rB   rY   	NameErrorr  r   r   r   )r   rn   r  r@  Zqkeysr   rT   rT   rU   rG  p  s    
	zSelection.generatec                 C  sX   | j dk	r(| jjj| j  | j| jdS | jdk	rB| jj| jS | jjj| j| jdS )(
        generate the selection
        Nr\  )	rE  rt   Z
read_wherer   r   r   r-  r  r  r   rT   rT   rU   r     s    
  
zSelection.selectc                 C  s   | j | j }}| jj}|dkr$d}n|dk r4||7 }|dkrB|}n|dk rR||7 }| jdk	rx| jjj| j ||ddS | jdk	r| jS t	||S )rK  Nr   T)r   r   r(  )
r   r   rt   r  rE  Zget_where_listr   r-  rQ   r  )r   r   r   r  rT   rT   rU   r    s(    
   
zSelection.select_coords)NNN)r   r  r  r  r   rG  r   r  rT   rT   rT   rU   r  7  s      -r  )r   NNFNTNNNNrz   rO   )	Nr   rz   NNNNFN)N)F)F)F)r  
__future__r   
contextlibr   rv  rb  r   r   r.  r   r&  textwrapr   typesr   typingr   r	   r
   r   r   r   r   r   r   r   r  ZnumpyrQ   Zpandas._configr   r   Zpandas._libsr   r   r5  Zpandas._libs.tslibsr   Zpandas._typingr   r   r   r   r   r   r   Zpandas.compat._optionalr   Zpandas.compat.pickle_compatr   Zpandas.errorsr    r!   r"   r#   r$   Zpandas.util._decoratorsr%   Zpandas.util._exceptionsr&   Zpandas.core.dtypes.commonr'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   Zpandas.core.dtypes.missingr4   r   r5   r6   r7   r8   r9   r:   r;   r<   r=   r>   Zpandas.core.arraysr?   r@   rA   Zpandas.core.commoncorecommonr=  Z pandas.core.computation.pytablesrB   rC   Zpandas.core.constructionrD   Zpandas.core.indexes.apirE   Zpandas.core.internalsrF   rG   Zpandas.io.commonrH   Zpandas.io.formats.printingrI   rJ   r|   rK   rL   rM   rN   rS  r\   rV   r^   ra   rf   ro   rp   r  rq   rr   r{  rP  rw   rx   Zconfig_prefixZregister_optionZis_boolZis_one_of_factoryr{   r   r   r   r   r   r   r  r  r  r  r?  rA  rB  ra  r  r  r  r   r  r  r  r  r  r  r  r  r  r  r  r  r  r1  r:  r  r:  r9  r  r  r  r  rT   rT   rT   rU   <module>   s0  0$	<0
            ,:                     Qp  &   -  e!^       f dc0B+   &@I&!