Ë
    u™ãjœµ ã                  ó†  — U d Z ddlmZ ddlmZ ddlZddlmZmZ ddl	Z	ddl
Z
ddlZddlmZ ddlmZmZmZmZmZmZmZmZ ddlZddlZddlmZ ddlmc mZ dd	lm Z dd
l!m"Z"m#Z$ ddl%m&Z& ddl'm(Z( ddl)m*Z*m+Z+ ddl,m-Z- ddl.m/Z/ ddl0m1Z1m2Z2m3Z3m4Z4m5Z5 ddl6m7Z7m8Z8 ddl9m:Z: ddl;m<Z<m=Z=m>Z>m?Z?m@Z@mAZA ddlBmCZCmDZDmEZEmFZF ddlGmHZH ddlImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZU ddlVmWZWmXZXmYZY ddlZm[Z[ ddl\m]Z] ddl^m_c m`Za ddlbmcZcmdZdmeZe ddlfmgZhmiZi ddljmkZk ddllmmZm ddlnmoZompZp er4ddlqmrZrmsZsmtZt dd lumvZvmwZw dd!lxmyZymzZzm{Z{ dd"l|m}Z}m~Z~mZm€Z€m�Z�m‚Z‚mƒZƒ dd#l„m…Z… d$Z†dˆd%„Z‡d&„ ZˆedZ‰d'eŠd(<   d‰d)„Z‹d*ZŒd+eŠd,<   d-Z�d+eŠd.<   d/d/d0d0d1œZŽeKdgiZ�d2Z�d+eŠd3<   d4Z‘d+eŠd5<    e�j$                  d6«      5   e�j&                  d7d8e�e�j(                  ¬9«        e�j&                  d:de‘ e�j*                  g d;¢«      ¬9«       ddd«        e�j,                  d<e3d=¬>«       da—d?eŠd@<   d8a˜ e™«       ZšdŠdA„Z›	 	 	 	 	 	 	 	 d‹dB„ZœdC„ Z�dDddd8ddEdde"�j<                  ddFd$f	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dŒdG„ZŸ e8dH«      	 	 	 	 	 	 	 	 	 d�	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dŽdI„«       Z d�dJ„Z¡ e8dH«       G dK„ dL«      «       Z¢ G dM„ dN«      Z£ G dO„ dP«      Z¤ G dQ„ dRe¤«      Z¥ G dS„ dTe¤«      Z¦ G dU„ dVe¦«      Z§ G dW„ dXe§«      Z¨ G dY„ dZ«      Z© G d[„ d\e©«      Zª G d]„ d^eª«      Z« G d_„ d`eª«      Z¬ G da„ dbe¬«      Z­ G dc„ dde©«      Z® G de„ dfe®«      Z¯ G dg„ dhe®«      Z° G di„ dje°«      Z± G dk„ dle±«      Z² G dm„ dne²«      Z³ G do„ dpe±«      Z´ G dq„ dre±«      Zµ	 d�	 	 	 	 	 	 	 d‘ds„Z¶d’dt„Z·	 	 	 	 	 	 	 	 d“du„Z¸	 	 	 	 	 	 	 	 d”dv„Z¹d•d–dw„Zº	 d�	 	 	 	 	 	 	 d—dx„Z»d˜dy„Z¼	 	 	 	 	 	 	 	 d™dz„Z½	 	 dš	 	 	 	 	 	 	 	 	 	 	 	 	 d›d{„Z¾	 d�	 	 	 	 	 	 	 dœd|„Z¿	 	 	 	 	 	 d�d}„ZÀdžd~„ZÁ	 	 	 	 	 	 	 	 džd„ZÂ	 d�	 	 	 	 	 	 	 dŸd€„ZÃd�d d�„ZÄd¡d‚„ZÅd¢dƒ„ZÆd£d„„ZÇd¤d…„ZÈ G d†„ d‡«      ZÉy# 1 sw Y   �Œ@xY w)¥zY
High level interface to PyTables for reading and writing pandas data structures
to disk
é    )Úannotations)ÚsuppressN)ÚdateÚtzinfo)Údedent)ÚTYPE_CHECKINGÚAnyÚFinalÚLiteralÚSelfÚ	TypeAliasÚcastÚoverload)Úusing_string_dtype)Ú_global_config)ÚlibÚwriters)Úis_string_array)Ú	timezones)ÚHAS_PYARROWÚPY312)Úimport_optional_dependency)Úpatch_pickle)ÚAttributeConflictWarningÚClosedFileErrorÚPandas4WarningÚPerformanceWarningÚPossibleDataLossError)Úcache_readonlyÚ
set_module)Úfind_stack_level)Úensure_objectÚis_bool_dtypeÚis_complex_dtypeÚis_list_likeÚis_string_dtypeÚneeds_i8_conversion)ÚCategoricalDtypeÚDatetimeTZDtypeÚExtensionDtypeÚPeriodDtype)Úarray_equivalent)ÚCategoricalIndexÚ	DataFrameÚDatetimeIndexÚIndexÚ
MultiIndexÚPeriodIndexÚ
RangeIndexÚSeriesÚStringDtypeÚTimedeltaIndexÚconcatÚisna)ÚCategoricalÚDatetimeArrayÚPeriodArray)Útz_to_dtype)ÚBaseStringArray)ÚJointConditionBinOpÚPyTablesExprÚmaybe_expression)ÚarrayÚextract_array)Úensure_index)Ústringify_path)ÚadjoinÚpprint_thing)ÚCallableÚHashableÚIterator)Ú
ModuleTypeÚTracebackType)ÚColÚFileÚNode)ÚAnyArrayLikeÚ	ArrayLikeÚAxisIntÚDtypeArgÚFilePathÚTimeUnitÚnpt)ÚBlockúUTF-8c                ó   — | €t         } | S ©N)Ú_default_encoding)Úencodings    ú]/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/pandas/io/pytables.pyÚ_ensure_encodingr]   ˜   s   € àÐÜ$ˆà€Oó    c                ó<   — 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
    )Ú
isinstanceÚstr©Únames    r\   Ú_ensure_strrd       s   € ô �$œÔÜ�4‹yˆØ€Kr^   r   ÚTermc                ó  — |dz   }t        | t        t        f«      r7t        rdnd}| D �cg c]!  }|�t	        |«      rt        |||z   ¬«      n|‘Œ# } }nt	        | «      rt        | |¬«      } | �t        | «      r| S dS c c}w )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)
    é   r   N©Úscope_level)r`   ÚlistÚtupler   r@   re   Úlen)Úwhereri   ÚlevelÚcomp_adjustmentÚterms        r\   Ú_ensure_termrq   ¯   s›   € ð ˜!‰O€EÜ�%œ$¤˜Ô'õ  %™!¨!ˆð
 ö	
ð ØÐô   Ô%ô � 5¨?Ñ#:Õ;àñð
ˆñ 
ô 
˜%Ô	 Ü�U¨Ô.ˆØ�M¤S¨¤Zˆ5Ð9°TÐ9ùò
s   ª&A<zu
the [%s] attribute of the existing index is [%s] which conflicts with the new
[%s], resetting the attribute to None
r
   Ú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)Úfrt   Útru   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.hdfÚdropna_tableF)Ú	validatorÚdefault_format)rt   ru   Nzio.hdf.dropna_tablezVio.hdf.dropna_table option is deprecated. Use DataFrame.dropna before writing instead.)ÚmsgzModuleType | NoneÚ
_table_modc                ó¾   — t        | |t        «      }|t        u rt        | ||«       y	 t        ||k(  «      }|st        | ||«       yy# t        t
        f$ r d}Y Œ$w xY w)u  
    setattr on a PyTables AttributeSet only if the on-disk value differs.

    Re-writing an HDF5 attribute to the same value is expensive â€” pytables
    deletes and re-creates it, hitting the disk per attribute. On wide-table
    appends this dominates runtime (GH#25839).
    NF)ÚgetattrÚ_MISSINGÚsetattrÚboolÚ
ValueErrorÚ	TypeError)Úattrsrc   ÚvalueÚcurrentÚequals        r\   Ú_set_attr_if_changedrŠ   ý   sn   € ô �e˜T¤8Ó,€GØ”(ÑÜ��t˜UÔ#ØðÜ�W Ñ%Ó&ˆñ Ü��t˜UÕ#ð øô œ	Ð"ò ØŠðús   ©A ÁAÁAc                óH   — t        | |«      j                  |«      \  } }}| |fS )a(  
    Resolve ``start``/``stop`` row bounds against a table holding ``nrows`` rows.

    Slice semantics count a negative bound back from the end of the table *and*
    clamp both bounds into ``[0, nrows]``, which is what a plain read does; the
    row-coordinate paths have to agree with it.
    )ÚsliceÚindices)ÚstartÚstopÚnrowsÚ_s       r\   Ú_resolve_row_windowr’     s+   € ô ˜5 $Ó'×/Ñ/°Ó6�N€Eˆ4�Ø�$ˆ;Ðr^   c                 ó¶   — t         €=dd l} | a t        t        «      5  | j                  j
                  dk(  ad d d «       t         S t         S # 1 sw Y   t         S xY w)Nr   Ústrict)r~   Útablesr   ÚAttributeErrorÚfileÚ_FILE_OPEN_POLICYÚ!_table_file_open_policy_is_strict)r•   s    r\   Ú_tablesrš     sX   € ô ÐÛàˆ
ô
 ”nÓ%ñ 	à—‘×-Ñ-°Ñ9ð .÷	ô
 ÐŒ:Ð÷	ô
 Ðús   œA
Á
AÚaTr”   c           
     óö   ‡‡‡‡‡	‡
‡‡‡‡— |rˆˆˆˆˆˆˆˆ	ˆ
ˆf
d„}nˆˆˆˆˆˆˆˆ	ˆ
ˆf
d„}t        | t        «      r	 || «       yt        | «      } t        | |||¬«      5 } ||«       ddd«       y# 1 sw Y   yxY w)z+store this object, close it if we opened itc                ó:   •
— | j                  ‰‰
‰‰‰‰	‰‰‰‰¬«
      S )N)ÚformatÚindexÚmin_itemsizeÚnan_repÚdropnaÚdata_columnsÚerrorsr[   )Úappend©Ústorer£   r¢   r[   r¤   rž   rŸ   Úkeyr    r¡   r‡   s    €€€€€€€€€€r\   ú<lambda>zto_hdf.<locals>.<lambda>H  s3   ø€ ˜%Ÿ,™,ØØØØØ%ØØØ%ØØð 'ó 
€ r^   c                ó<   •
— | j                  ‰‰
‰‰‰‰	‰‰‰‰d¬«      S )NF)	rž   rŸ   r    r¡   r£   r¤   r[   r¢   Útrack_times©Úputr¦   s    €€€€€€€€€€r\   r©   zto_hdf.<locals>.<lambda>V  s6   ø€ ˜%Ÿ)™)ØØØØØ%ØØ%ØØØØð $ó 
€ r^   )ÚmodeÚ	complevelÚcomplibN)r`   ÚHDFStorerD   )Úpath_or_bufr¨   r‡   r®   r¯   r°   r¥   rž   rŸ   r    r¡   r¢   r£   r¤   r[   rv   r§   s    ``    ````````  r\   Úto_hdfr³   5  sn   ÿù€ ñ$ ÷
ô 
‰÷
ô 
ˆô �+œxÔ(Ù	ˆ+�ä$ [Ó1ˆÜØ˜d¨iÀô
ð 	àÙˆeŒH÷	÷ 	ñ 	ús   Á	A/Á/A8Úpandasc
           
     óÀ  — |dvrt        d|› d�«      ‚|�t        |d¬«      }t        | t        «      r| j                  st        d«      ‚| }d}nht        | «      } t        | t        «      st        d	«      ‚	 t        j                  j                  | «      }|st        d
| › d�«      ‚t        | f||dœ|
¤Ž}d}d}	 |€[|j                  «       }t        |«      dk(  rt        d«      ‚|d   }|dd D ]  }t!        ||«      rŒt        d«      ‚ |j"                  }|j%                  |||||||	|¬«      }d}||s:t        | t        «      s)t'        t(        «      5  |j+                  «        ddd«       S S S # t        t         f$ r d}Y Œîw xY w# 1 sw Y   S xY w# |sFt        | t        «      s5t'        t(        «      5  |j+                  «        ddd«       w # 1 sw Y   w xY ww w xY w)a  
    Read from the store, close it if we opened it.

    Retrieve pandas object stored in file, optionally based on where
    criteria. This function requires the
    `PyTables <https://www.pytables.org/>`_ library.

    .. note::

       This function only reads HDF5 files written by pandas (via
       :meth:`DataFrame.to_hdf`, :meth:`Series.to_hdf`, or :class:`HDFStore`),
       which use a pandas-specific layout built on PyTables. Arbitrary HDF5
       files produced by other tools such as ``h5py`` or plain PyTables are
       not supported; use those libraries directly to read such files.

    .. 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 an HDF file from a DataFrame.
    HDFStore : Low-level access to HDF files.

    Notes
    -----
    When ``errors="surrogatepass"``, ``pd.options.future.infer_string`` is true,
    and PyArrow is installed, if a UTF-16 surrogate is encountered when decoding
    to UTF-8, the resulting dtype will be
    ``pd.StringDtype(storage="python", na_value=np.nan)``.

    Examples
    --------
    >>> df = pd.DataFrame([[1, 1.0, "a"]], columns=["x", "y", "z"])  # doctest: +SKIP
    >>> df.to_hdf("./store.h5", key="data")  # doctest: +SKIP
    >>> reread = pd.read_hdf("./store.h5")  # doctest: +SKIP
    )Úrúr+r›   zmode zG is not allowed while performing a read. Allowed modes are r, r+ and a.Nrg   rh   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.)rm   rŽ   r�   ÚcolumnsÚiteratorÚ	chunksizeÚ
auto_close)r„   rq   r`   r±   Úis_openÚOSErrorrD   ra   ÚNotImplementedErrorÚosÚpathÚexistsr…   ÚFileNotFoundErrorÚgroupsrl   Ú_is_metadata_ofÚ_v_pathnameÚselectr   r–   Úclose)r²   r¨   r®   r¤   rm   rŽ   r�   r¸   r¹   rº   Úkwargsr§   r»   rÁ   Úread_succeededrÃ   Úcandidate_only_groupÚgroup_to_checkÚresults                      r\   Úread_hdfrÍ   n  s0  € ð@ Ð#Ñ#ÜØ�D�6ð -ð .ó
ð 	
ð
 ÐÜ˜U°Ô2ˆä�+œxÔ(Ø×"Ò"ÜÐBÓCÐCàˆØ‰
ä$ [Ó1ˆÜ˜+¤sÔ+Ü%ØGóð ð	Ü—W‘W—^‘^ KÓ0ˆFñ Ü# e¨K¨=¸Ð$HÓIÐIä˜ÐI¨4¸ÑIÀ&ÑIˆð ˆ
à€Nð'Øˆ;Ø—\‘\“^ˆFÜ�6‹{˜aÒÜ ðDóð ð $*¨!¡9Ð ð #)¨¨ *ò �Ü& ~Ð7KÕLÜ$ð;óð ðð '×2Ñ2ˆCØ—‘ØØØØØØØØ!ð ó 	
ˆð ˆØñ
 ¤j°¼hÔ&GÜœ.Ó)ñ Ø—‘”÷ð ð 'Hˆ~øôc œ:Ð&ò 	ØŠFð	ú÷dð ûñ ¤j°¼hÔ&GÜœ.Ó)ñ Ø—‘”÷÷ ñ úð 'Hˆ~úsI   Á6E0 Â:AF Ã?4F ÅFÅ0FÆFÆF	Æ"GÆ5GÇ	GÇGÇ	Gc                óÔ   — | j                   |j                   k  ry| }|j                   dkD  r=|j                  }||k(  r|j                  dk(  ry|j                  }|j                   dkD  rŒ=y)zDCheck if a given group is a metadata group for a given parent_group.Frg   ÚmetaT)Ú_v_depthÚ	_v_parentÚ_v_name)ÚgroupÚparent_grouprˆ   Úparents       r\   rÄ   rÄ     sk   € à‡~�~˜×.Ñ.Ò.Øà€GØ
×
Ñ
˜QÒ
Ø×"Ñ"ˆØ�\Ò! g§o¡o¸Ò&?ØØ×#Ñ#ˆð	 ×
Ñ
˜QÓ
ð
 r^   c                  óº  — e Zd ZU dZded<   ded<   	 	 	 	 d5	 	 	 	 	 	 	 d6d„Zd7d	„Zed
„ «       Zed7d„«       Z	d8d„Z
d9d„Zd:d„Zd;d„Zd<d„Zd=d„Zd7d„Zd>d„Z	 	 	 	 	 	 	 	 d?d„Zd@dAd„ZdBd„ZdCd„ZdDdEd„ZdFd„ZedGd„«       ZdHdId„Zd8d„Z	 	 	 	 	 	 	 dJ	 	 	 	 	 	 	 dKd„Z	 	 	 dL	 	 	 	 	 dMd„Z	 	 dN	 	 	 	 	 	 	 dOd„Z	 	 	 	 	 	 	 	 dP	 	 	 	 	 dQd „Zdd!dddddddd"ej@                  ej@                  f	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dRd#„Z!dLd:d$„Z"ddd!d!dddddddej@                  ddd"f	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dSd%„Z#ddej@                  f	 	 	 	 	 dTd&„Z$	 	 	 dL	 	 	 	 	 	 	 dUd'„Z%dVd(„Z&dWdXd)„Z'dYd*„Z(dZd+„Z)	 	 	 	 	 	 	 d[	 	 	 	 	 	 	 	 	 	 	 d\d,„Z*d7d-„Z+dFd.„Z,d]d/„Z-	 	 	 	 d^	 	 	 	 	 	 	 d_d0„Z.	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d`	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dad1„Z/dbd2„Z0dcd3„Z1ddd4„Z2y)er±   aE  
    Dict-like IO interface for storing pandas objects in PyTables.

    Either Fixed or Table format.

    .. note::

       ``HDFStore`` uses a pandas-specific layout on top of PyTables and is
       intended for round-tripping pandas objects. It cannot read arbitrary
       HDF5 files produced by other tools such as ``h5py`` or plain PyTables;
       use those libraries directly for general HDF5 interoperability.

    .. 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. This has no effect
        unless ``complevel`` is set to a value greater than 0; passing
        ``complib`` alone emits a ``UserWarning`` and produces an
        uncompressed store.
        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Ú_handlera   Ú_modeNFc                óê  — d|v rt        d«      ‚t        d«      }|�;||j                  j                  vr#t        d|j                  j                  › d�«      ‚|€|�|j                  j                  }|�*|€(t        j                  d|›d�t        t        «       ¬«       t        |«      | _
        |€d	}|| _        d | _        |r|nd
| _        || _        || _        d | _         | j"                  dd|i|¤Ž y )Nrž   z-format is not a defined argument for HDFStorer•   zcomplib only supports z compression.zcomplib=zw was specified without complevel; no compression will be applied. Pass complevel (an int in 1-9) to enable compression.©Ú
stacklevelr›   r   r®   © )r„   r   ÚfiltersÚall_complibsÚdefault_complibÚwarningsÚwarnÚUserWarningr!   rD   Ú_pathrØ   r×   Ú
_complevelÚ_complibÚ_fletcher32Ú_filtersÚopen)ÚselfrÀ   r®   r¯   r°   Ú
fletcher32rÈ   r•   s           r\   Ú__init__zHDFStore.__init__{  s
  € ð �vÑÜÐLÓMÐMä+¨HÓ5ˆàÐ 7°&·.±.×2MÑ2MÑ#MÜØ(¨¯©×)DÑ)DÐ(EÀ]ÐSóð ð ˆ?˜yÐ4Ø—n‘n×4Ñ4ˆGàÐ 9Ð#4ô �M‰MØ˜7˜+ð &)ð )ô Ü+Ó-õô $ DÓ)ˆŒ
Øˆ<ØˆDØˆŒ
ØˆŒÙ'0™)°aˆŒØˆŒØ%ˆÔØˆŒØˆ�	‰	Ñ&�tÐ&˜vÓ&r^   c                ó   — | j                   S rY   ©rã   ©ré   s    r\   Ú
__fspath__zHDFStore.__fspath__¨  s   € Ø�z‰zÐr^   c                ój   — | j                  «        | j                  €J ‚| j                  j                  S )zreturn the root node)Ú_check_if_openr×   Úrootrî   s    r\   rò   zHDFStore.root«  s0   € ð 	×ÑÔØ�|‰|Ð'Ð'Ð'Ø�|‰|× Ñ Ð r^   c                ó   — | j                   S rY   rí   rî   s    r\   ÚfilenamezHDFStore.filename²  ó   € à�z‰zÐr^   c                ó$   — | j                  |«      S rY   )Úget©ré   r¨   s     r\   Ú__getitem__zHDFStore.__getitem__¶  s   € Ø�x‰x˜‹}Ðr^   c                ó,   — | j                  ||d¬«       y )NF)r«   r¬   )ré   r¨   r‡   s      r\   Ú__setitem__zHDFStore.__setitem__¹  s   € Ø�‰��e¨ˆÕ/r^   c                ó$   — | j                  |«      S rY   )Úremoverø   s     r\   Ú__delitem__zHDFStore.__delitem__¼  s   € Ø�{‰{˜3ÓÐr^   c                óš   — 	 | j                  |«      S # t        t        f$ r Y nw xY wt        dt	        | «      j
                  › d|› d�«      ‚)z$allow attribute access to get storesú'z' object has no attribute ')r÷   ÚKeyErrorr   r–   ÚtypeÚ__name__)ré   rc   s     r\   Ú__getattr__zHDFStore.__getattr__¿  sW   € ð	Ø—8‘8˜D“>Ð!øÜœ/Ð*ò 	Ùð	úäØ”�T“
×#Ñ#Ð$Ð$?À¸vÀQÐGó
ð 	
s   ‚ “%¤%c                óV   — | j                  |«      }|�|j                  }|||dd fv ryy)zx
        check for existence of this key
        can match the exact pathname or the pathnm w/o the leading '/'
        Nrg   TF)Úget_noderÅ   )ré   r¨   Únoderc   s       r\   Ú__contains__zHDFStore.__contains__É  s<   € ð
 �}‰}˜SÓ!ˆØÐØ×#Ñ#ˆDØ�t˜T ! "˜XÐ&Ñ&ØØr^   c                ó4   — t        | j                  «       «      S rY   )rl   rÃ   rî   s    r\   Ú__len__zHDFStore.__len__Õ  s   € Ü�4—;‘;“=Ó!Ð!r^   c                óN   — t        | j                  «      }t        | «      › d|› d�S )Nú
File path: ú
)rF   rã   r  )ré   Úpstrs     r\   Ú__repr__zHDFStore.__repr__Ø  s'   € Ü˜DŸJ™JÓ'ˆÜ�t“*�˜]¨4¨&°Ð3Ð3r^   c                ó   — | S rY   rÜ   rî   s    r\   Ú	__enter__zHDFStore.__enter__Ü  s   € Øˆr^   c                ó$   — | j                  «        y rY   )rÇ   )ré   Úexc_typeÚ	exc_valueÚ	tracebacks       r\   Ú__exit__zHDFStore.__exit__ß  s   € ð 	�
‰
�r^   c                ó  — |dk(  r(| j                  «       D �cg c]  }|j                  ‘Œ c}S |dk(  rC| j                  €J ‚| j                  j                  dd¬«      D �cg c]  }|j                  ‘Œ c}S t	        d|› d�«      ‚c c}w c c}w )a$  
        Return a list of keys corresponding to objects stored in HDFStore.

        The keys are absolute path-names within the HDF5 file hierarchy.
        By default only pandas objects are returned, but native HDF5 table
        objects can be included as well.

        Parameters
        ----------

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

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

        Raises
        ------
        raises ValueError if kind has an illegal value

        See Also
        --------
        HDFStore.info : Prints detailed information on the store.
        HDFStore.get_node : Returns the node with the key.
        HDFStore.get_storer : Returns the storer object for a key.

        Examples
        --------
        >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
        >>> store = pd.HDFStore("store.h5", "w")  # doctest: +SKIP
        >>> store.put("data", df)  # doctest: +SKIP
        >>> store.get("data")  # doctest: +SKIP
        >>> print(store.keys())  # doctest: +SKIP
        ['/data1', '/data2']
        >>> store.close()  # doctest: +SKIP
        r´   Únativeú/ÚTable)Ú	classnamez8`include` should be either 'pandas' or 'native' but is 'r   )rÃ   rÅ   r×   Ú
walk_nodesr„   )ré   ÚincludeÚns      r\   ÚkeyszHDFStore.keysç  s•   € ðP �hÒØ+/¯;©;«=Ö9 a�A—M“MÒ9Ð9à˜Ò Ø—<‘<Ð+Ð+Ð+à'+§|¡|×'>Ñ'>¸sÈgÐ'>Ó'VöØ"#�—“òð ô ØFÀwÀiÈqÐQó
ð 	
ùò :ùòs   ˜BÁ B
c                ó4   — t        | j                  «       «      S rY   )Úiterr  rî   s    r\   Ú__iter__zHDFStore.__iter__  s   € Ü�D—I‘I“KÓ Ð r^   c              #  óV   K  — | j                  «       D ]  }|j                  |f–— Œ y­w)z'
        iterate on key->group
        N)rÃ   rÅ   ©ré   Úgs     r\   ÚitemszHDFStore.items  s,   è ø€ ð —‘“ò 	#ˆAØ—-‘- Ð"Ó"ñ	#ùs   ‚')c                óZ  — t        «       }| j                  |k7  rP| j                  dv r|dv rn6|dv r2| j                  r&t        d| j                  › d| j                  › d�«      ‚|| _        | j                  r| j                  «        | j                  rN| j                  dkD  r?t        «       j                  | j                  | j                  | j                  ¬«      | _
        t        r| j                  rd	}t        |«      ‚ |j                  | j                  | j                  fi |¤Ž| _        y
)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•   r}   s        r\   rè   zHDFStore.open%  s  € ô “ˆà�:‰:˜Òà�z‰z˜ZÑ'¨D°KÑ,?ØØ˜‘à—<’<Ü/Ø/°·
±
¨|¸=ÈÏÉÈð U8ð 8óð ð
 ˆDŒJð �<Š<Ø�J‰JŒLà�?Š?˜tŸ™°Ò2Ü#›I×-Ñ-Ø—‘ §¡¸4×;KÑ;Kð .ó ˆDŒMõ -°·²ð*ð ô ˜S“/Ð!à'�v×'Ñ'¨¯
©
°D·J±JÑIÀ&ÑIˆ�r^   c                ó^   — | j                   �| j                   j                  «        d| _         y)z0
        Close the PyTables file handle
        N)r×   rÇ   rî   s    r\   rÇ   zHDFStore.closeR  s%   € ð �<‰<Ð#Ø�L‰L×ÑÔ Øˆ�r^   c                óZ   — | j                   €yt        | j                   j                  «      S )aÄ  
        Return a boolean indicating whether the file is open.

        ``HDFStore`` instances open the underlying PyTables file in their
        constructor, but the file can be closed and reopened on the same
        instance via :meth:`close` and :meth:`open`.

        See Also
        --------
        HDFStore.open : Open the underlying file in the specified mode.
        HDFStore.close : Close the underlying PyTables file handle.

        Examples
        --------
        >>> store = pd.HDFStore("store.h5", "w")  # doctest: +SKIP
        >>> store.is_open  # doctest: +SKIP
        True
        >>> store.close()  # doctest: +SKIP
        >>> store.is_open  # doctest: +SKIP
        False
        F)r×   rƒ   Úisopenrî   s    r\   r¼   zHDFStore.is_openZ  s&   € ð. �<‰<ÐØÜ�D—L‘L×'Ñ'Ó(Ð(r^   c                óú   — | j                   �c| j                   j                  «        |rFt        t        «      5  t	        j
                  | j                   j                  «       «       ddd«       yyy# 1 sw Y   yxY w)aV  
        Force all buffered modifications to be written to disk.

        Useful when sharing access between processes -- call ``flush`` (with
        ``fsync=True`` if needed) before releasing a write lock so that
        readers see the latest data.

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

        See Also
        --------
        HDFStore.close : Close the underlying PyTables file handle.

        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.

        Examples
        --------
        >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
        >>> store = pd.HDFStore("store.h5", "w")  # doctest: +SKIP
        >>> store.put("data", df)  # doctest: +SKIP
        >>> store.flush(fsync=True)  # doctest: +SKIP
        >>> store.close()  # doctest: +SKIP
        N)r×   Úflushr   r½   r¿   ÚfsyncÚfileno)ré   r0  s     r\   r/  zHDFStore.flushu  sg   € ð@ �<‰<Ð#Ø�L‰L×ÑÔ ÙÜœgÓ&ñ 4Ü—H‘H˜TŸ\™\×0Ñ0Ó2Ô3÷4ð 4ð ð $÷4ð 4ús   ¸.A1Á1A:c                ó¨   — t        «       5  | j                  |«      }|€t        d|› d�«      ‚| j                  |«      cddd«       S # 1 sw Y   yxY w)at  
        Retrieve pandas object stored in file.

        The object is read from the HDF5 file and returned as the
        same type that was stored (e.g., DataFrame, Series).

        Parameters
        ----------
        key : str
            Object to retrieve from file. Raises KeyError if not found.

        Returns
        -------
        object
            Same type as object stored in file.

        See Also
        --------
        HDFStore.get_node : Returns the node with the key.
        HDFStore.get_storer : Returns the storer object for a key.

        Examples
        --------
        >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
        >>> store = pd.HDFStore("store.h5", "w")  # doctest: +SKIP
        >>> store.put("data", df)  # doctest: +SKIP
        >>> store.get("data")  # doctest: +SKIP
        >>> store.close()  # doctest: +SKIP
        NúNo object named ú in the file)r   r  r  Ú_read_group©ré   r¨   rÓ   s      r\   r÷   zHDFStore.get›  sV   € ô< ‹^ñ 	+ð —M‘M #Ó&ˆEØˆ}ÜÐ!1°#°°lÐCÓDÐDØ×#Ñ# EÓ*÷	+÷ 	+ò 	+ús   ‹3AÁAc	                ó  ‡‡— | j                  |«      }	|	€t        d|› d�«      ‚t        |d¬«      }| j                  |	«      Š‰j	                  «        ˆˆfd„}
t        | ‰|
|‰j                  |||||¬«
      }|j                  «       S )aC  
        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.

        See Also
        --------
        HDFStore.select_as_coordinates : Returns the selection as an index.
        HDFStore.select_column : Returns a single column from the table.
        HDFStore.select_as_multiple : Retrieves pandas objects from multiple tables.

        Examples
        --------
        >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
        >>> store = pd.HDFStore("store.h5", "w")  # doctest: +SKIP
        >>> store.put("data", df)  # doctest: +SKIP
        >>> store.get("data")  # doctest: +SKIP
        >>> print(store.keys())  # doctest: +SKIP
        ['/data1', '/data2']
        >>> store.select("/data1")  # doctest: +SKIP
           A  B
        0  1  2
        1  3  4
        >>> store.select("/data1", where="columns == A")  # doctest: +SKIP
           A
        0  1
        1  3
        >>> store.close()  # doctest: +SKIP
        r3  r4  rg   rh   c                ó.   •— ‰j                  | ||‰¬«      S )N)rŽ   r�   rm   r¸   )Úread)Ú_startÚ_stopÚ_wherer¸   Úss      €€r\   ÚfunczHDFStore.select.<locals>.func  s   ø€ Ø—6‘6 ¨U¸&È'�6ÓRÐRr^   ©rm   r�   rŽ   r�   r¹   rº   r»   )r  r  rq   Ú_create_storerÚ
infer_axesÚTableIteratorr�   Ú
get_result)ré   r¨   rm   rŽ   r�   r¸   r¹   rº   r»   rÓ   r>  Úitr=  s        `      @r\   rÆ   zHDFStore.selectÁ  s—   ù€ ðL —‘˜cÓ"ˆØˆ=ÜÐ-¨c¨U°,Ð?Ó@Ð@ô ˜U°Ô2ˆØ×Ñ Ó&ˆØ	�‰Œõ	Sô ØØØØØ—'‘'ØØØØØ!ô
ˆð �}‰}‹Ðr^   c                óœ   — t        |d¬«      }| j                  |«      }t        |t        «      st	        d«      ‚|j                  |||¬«      S )aa  
        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
            Object being retrieved from file.
        where : list of Term (or convertible) objects, optional
            Conditions to apply to the selection. ``start`` and ``stop`` are
            applied to the table before ``where``.
        start : int, optional
            Row number to start selection.
        stop : int, optional
            Row number to stop selection.

        Returns
        -------
        Index
            Integer positions of the matching rows; can be passed as
            ``where`` to a subsequent ``select``.

        See Also
        --------
        HDFStore.select : Retrieve a stored object, optionally filtered by
            ``where``.
        HDFStore.select_as_multiple : Retrieve pandas objects from multiple
            tables.

        Examples
        --------
        >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
        >>> store = pd.HDFStore("store.h5", "w")  # doctest: +SKIP
        >>> store.append(
        ...     "data", df, format="table", data_columns=["A"]
        ... )  # doctest: +SKIP
        >>> store.select_as_coordinates("data", "A>1")  # doctest: +SKIP
        >>> store.close()  # doctest: +SKIP
        rg   rh   z&can only read_coordinates with a table©rm   rŽ   r�   )rq   Ú
get_storerr`   r  r…   Úread_coordinates)ré   r¨   rm   rŽ   r�   Útbls         r\   Úselect_as_coordinateszHDFStore.select_as_coordinates$  sM   € ôj ˜U°Ô2ˆØ�o‰o˜cÓ"ˆÜ˜#œuÔ%ÜÐDÓEÐEØ×#Ñ#¨%°uÀ4Ð#ÓHÐHr^   c                ó‚   — | j                  |«      }t        |t        «      st        d«      ‚|j	                  |||¬«      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
            Object being retrieved from file.
        column : str
            The column of interest.
        start : int or None, default None
            Row number to start selection.
        stop : int or None, default None
            Row number to stop selection.

        Returns
        -------
        Series
            A ``Series`` of the column's values.

        Raises
        ------
        KeyError
            If the column is not found, or ``key`` is not a valid store.
        ValueError
            If the column cannot be extracted individually (not an
            indexable or a data column).

        See Also
        --------
        HDFStore.select : Retrieve a stored object, optionally filtered by
            ``where``.
        HDFStore.select_as_coordinates : Return the matching row coordinates
            as an Index.

        Examples
        --------
        >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
        >>> store = pd.HDFStore("store.h5", "w")  # doctest: +SKIP
        >>> store.append(
        ...     "data", df, format="table", data_columns=["A"]
        ... )  # doctest: +SKIP
        >>> store.select_column("data", "A")  # doctest: +SKIP
        >>> store.close()  # doctest: +SKIP
        z!can only read_column with a table)ÚcolumnrŽ   r�   )rG  r`   r  r…   Úread_column)ré   r¨   rL  rŽ   r�   rI  s         r\   Úselect_columnzHDFStore.select_column_  s>   € ðz �o‰o˜cÓ"ˆÜ˜#œuÔ%ÜÐ?Ó@Ð@Ø�‰ f°EÀˆÓEÐEr^   c
                óÔ  ‡‡‡— t        |d¬«      }t        |t        t        f«      rt	        |«      dk(  r|d   }t        |t
        «      r| j                  ||‰|||||	¬«      S t        |t        t        f«      st        d«      ‚t	        |«      st        d«      ‚|€|d   }|D �
cg c]  }
| j                  |
«      ‘Œ c}
Š| j                  |«      }d}t        j                  ||fgt        ‰|d¬	«      «      D ]d  \  }}
|€t        d
|
› d�«      ‚|j                  st        d|j                  › d�«      ‚|€|j                   }ŒK|j                   |k7  sŒ[t        d«      ‚ ‰D �cg c]  }t        |t"        «      sŒ|‘Œ }}|D �ch c]  }|j$                  d   d   ’Œ c}j'                  «       Šˆˆˆfd„}t)        | |||||||||	¬«
      }|j+                  d¬«      S c c}
w c c}w c c}w )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 : list of str
            Names of the tables to read.
        where : list, optional
            List of Term (or convertible) objects.
        selector : str, optional
            The table to apply the where criteria to. Defaults to ``keys[0]``.
        columns : list, optional
            Columns to return.
        start : int, optional
            Row number to start selection. Applied to each table before
            ``where`` is evaluated.
        stop : int, optional
            Row number to stop selection. Applied to each table before
            ``where`` is evaluated.
        iterator : bool, default False
            Return an iterator.
        chunksize : int, optional
            Number of rows to include in each iteration; implies
            ``iterator=True``.
        auto_close : bool, default False
            Should automatically close the store when finished.

        Returns
        -------
        DataFrame or TableIterator
            Concatenated result from the selected tables. A ``TableIterator``
            is returned instead when ``iterator=True`` or ``chunksize`` is
            given.

        Raises
        ------
        KeyError
            If ``keys`` or ``selector`` is not found, or ``keys`` is empty.
        TypeError
            If ``keys`` is not a list or tuple.
        ValueError
            If the tables do not all have the same number of rows.

        See Also
        --------
        HDFStore.append_to_multiple : Append to multiple tables, splitting a
            single object into a dict of column groups.
        HDFStore.select : Retrieve a single stored object.

        Examples
        --------
        >>> df1 = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
        >>> df2 = pd.DataFrame([[5, 6], [7, 8]], columns=["C", "D"])
        >>> store = pd.HDFStore("store.h5", "w")  # doctest: +SKIP
        >>> store.append("t1", df1, format="table")  # doctest: +SKIP
        >>> store.append("t2", df2, format="table")  # doctest: +SKIP
        >>> store.select_as_multiple(["t1", "t2"])  # doctest: +SKIP
        >>> store.close()  # doctest: +SKIP
        rg   rh   r   )r¨   rm   r¸   rŽ   r�   r¹   rº   r»   zkeys must be a list/tuplez keys must have a non-zero lengthNT©r”   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           	     óŠ   •— ‰D �cg c]  }|j                  |‰| |¬«      ‘Œ }}t        |‰d¬«      j                  «       S c c}w )N©rm   r¸   rŽ   r�   F)ÚaxisÚverify_integrity)r9  r7   Ú_consolidate)r:  r;  r<  rw   ÚobjsrT  r¸   Útblss        €€€r\   r>  z)HDFStore.select_as_multiple.<locals>.func$  sR   ø€ ð
 öàð —‘˜V¨W¸FÈ�ÕOðˆDð ô ˜$ T¸EÔB×OÑOÓQÐQùòs   †A r?  )Úcoordinates)rq   r`   rj   rk   rl   ra   rÆ   r…   r„   rG  Ú	itertoolsÚchainÚzipr  Úis_tableÚpathnamer�   r  Únon_index_axesÚpoprB  rC  )ré   r  rm   Úselectorr¸   rŽ   r�   r¹   rº   r»   Úkr=  r�   rw   ÚxÚ_tblsr>  rD  rT  rX  s       `             @@r\   Úselect_as_multiplezHDFStore.select_as_multiple¡  s  ú€ ô` ˜U°Ô2ˆÜ�dœT¤5˜MÔ*¬s°4«y¸Aª~Ø˜‘7ˆDÜ�dœCÔ Ø—;‘;ØØØØØØ!Ø#Ø%ð ó 	ð 	ô ˜$¤¤u Ô.ÜÐ7Ó8Ð8ä�4ŒyÜÐ?Ó@Ð@àÐØ˜A‘wˆHð -1Ö1 q�—‘ Õ"Ò1ˆØ�O‰O˜HÓ%ˆð ˆÜ—O‘O a¨ ] O´S¸¸tÈDÔ5QÓRò 	Q‰DˆAˆqØˆyÜ °°°1Ð5Ó6Ð6Ø—:’:ÜØ˜qŸz™z˜lð +)ð )óð ð
 ˆ}ØŸ™‘Ø—‘˜EÓ!Ü Ð!OÓPÐPð	Qð  !Ö9�q¤J¨q´%Õ$8’Ð9ˆÐ9ð 16Ö6¨1�× Ñ  Ñ# AÓ&Ò6×:Ñ:Ó<ˆö		Rô ØØØØØØØØØØ!ô
ˆð �}‰}¨ˆ}Ó.Ð.ùòg 2ùò* :ùò 7s   Â%GÅ#G Å9G ÆG%Tr”   c                óp  — |t         j                  ur%t        j                  dt        t        «       ¬«       nd}|€t        d   d   d   xs d}| j                  |«      }|t         j                  u r&t        j                  d	t        t        «       ¬«       d
}| j                  |||||||||	|
||||¬«       y)a—  
        Store object in HDFStore.

        This method writes a pandas DataFrame or Series into an HDF5 file using
        either the fixed or table format. The `table` format allows additional
        operations like incremental appends and queries but may have performance
        trade-offs. The `fixed` format provides faster read/write operations but
        does not support appends or queries.

        Parameters
        ----------
        key : str
            Key of object to store in file.
        value : {Series, DataFrame}
            Value of object to store in file.
        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.
        complib : {'zlib', 'lzo', 'bzip2', 'blosc'}, default None
            Compression library to use, only applied with ``format='table'``.
            None disables compression. See the ``complib`` parameter of
            :class:`HDFStore` for the full list of supported compressors.
        complevel : int, 0-9, default None
            Specifies a compression level for data.
            A value of 0 or None disables compression.
        min_itemsize : int, dict, or None
            Minimum number of bytes reserved for object columns.
            If int, all columns reserve 'min_itemsize' bytes per stored value.
            If dict, specific columns reserve 'min_itemsize' bytes per stored value.
            Strings are stored as encoded bytes. Since some characters require multiple
            bytes, required size may be larger than string length.
        nan_rep : str, optional
            String used on disk to represent missing values in string columns
            (``format="table"`` only).
            By default a sentinel that collides with no value in the column is
            used, so a literal ``"nan"`` round-trips unchanged; when this is
            passed, a value equal to it is read back as a missing value.
        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.
        errors : str, default 'strict'
            The error handling scheme to use for encoding errors.
            The default is 'strict' meaning that encoding errors raise a
            UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and
            'xmlcharrefreplace' as well as any other name registered with
            codecs.register_error that can handle UnicodeEncodeErrors.
        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.

            .. deprecated:: 3.1.0
                The default value of ``track_times`` will change from ``True``
                to ``False`` in a future version. Pass ``track_times=False``
                explicitly to silence this warning and get deterministic
                HDF5 files.
        dropna : bool, default False, optional
            Remove missing values.

            .. deprecated:: 3.1.0
                The ``dropna`` keyword is deprecated and will be removed in a
                future version. Use :meth:`DataFrame.dropna` before writing
                instead.

        See Also
        --------
        HDFStore.info : Prints detailed information on the store.
        HDFStore.get_storer : Returns the storer object for a key.

        Notes
        -----
        Writing an empty ``DataFrame`` or ``Series`` with ``format='table'``
        or ``append=True`` is a no-op: the store is not modified and a
        ``UserWarning`` is emitted. Use ``format='fixed'`` to store an empty
        object.

        Examples
        --------
        >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
        >>> store = pd.HDFStore("store.h5", "w")  # doctest: +SKIP
        >>> store.put("data", df)  # doctest: +SKIP
        zˆThe 'dropna' keyword in HDFStore.put is deprecated and will be removed in a future version. Use DataFrame.dropna before writing instead.rÚ   FNÚioÚhdfr|   rt   zÂThe default value of 'track_times' in HDFStore.put will change from True to False in a future version. Pass track_times=False explicitly to silence this warning and get deterministic HDF5 files.T)rž   rŸ   r¥   r°   r¯   r    r¡   r£   r[   r¤   r«   r¢   )	r   Ú
no_defaultrà   rá   r   r!   ÚconfigÚ_validate_formatÚ_write_to_group)ré   r¨   r‡   rž   rŸ   r¥   r°   r¯   r    r¡   r£   r[   r¤   r«   r¢   s                  r\   r­   zHDFStore.put?  sÎ   € ð` œŸ™Ñ'Ü�M‰Mð*ô Ü+Ó-öð ˆFØˆ>Ü˜D‘\ %Ñ(Ð)9Ñ:ÒE¸gˆFØ×&Ñ& vÓ.ˆØœ#Ÿ.™.Ñ(Ü�M‰Mð0ô Ü+Ó-õð ˆKØ×ÑØØØØØØØØ%ØØ%ØØØ#Øð 	õ 	
r^   c                ó¾  — t        |d¬«      }	 | j                  |«      }t        j                  |||«      rj                  j                  d¬«       yj                  st        d«      ‚|j                  |||¬«      S # t        $ r ‚ t        $ r ‚ t        $ rB}|�t        d«      |‚| j                  |«      }|�|j                  d¬«       Y d}~yY d}~Œ·d}~ww xY w)	an  
        Remove pandas object partially by specifying the where condition.

        If ``where`` is not provided, the entire object stored at ``key``
        (and any of its child nodes) is removed. When ``where`` is given,
        only matching rows are deleted, which requires the object to be in
        ``table`` format.

        Parameters
        ----------
        key : str
            Node to remove or delete rows from.
        where : list of Term (or convertible) objects, optional
            Conditions selecting which rows to remove.
        start : int, optional
            Row number to start selection.
        stop : int, optional
            Row number to stop selection.

        Returns
        -------
        int or None
            Number of rows removed (or ``None`` if the object is not a Table).

        Raises
        ------
        KeyError
            If ``key`` is not a valid store.

        See Also
        --------
        HDFStore.append : Append data to an existing table.
        HDFStore.put : Store an object in the file.

        Examples
        --------
        >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
        >>> store = pd.HDFStore("store.h5", "w")  # doctest: +SKIP
        >>> store.put("data", df)  # doctest: +SKIP
        >>> store.remove("data")  # doctest: +SKIP
        >>> store.close()  # doctest: +SKIP
        rg   rh   Nz5trying to remove a node with a non-None where clause!T©Ú	recursivez7can only remove with where on objects written as tablesrF  )rq   rG  r  ÚAssertionErrorÚ	Exceptionr„   r  Ú	_f_removeÚcomÚall_nonerÓ   r]  Údelete)ré   r¨   rm   rŽ   r�   r=  Úerrr  s           r\   rý   zHDFStore.remove×  sç   € ôV ˜U°Ô2ˆð	Ø—‘ Ó$ˆAô. �<‰<˜˜u dÔ+Ø�G‰G×Ñ¨ÐÔ-Øð �zŠzÜÐVÓWÐWØ�x‰x˜e¨5°tˆxÓ<Ð<øô; ò 	àÜò 	àÜò 	ð Ð Ü ØKóàðð
 —=‘= Ó%ˆDØÐØ—‘¨�Ô.Üô  ûð	ús   �A? Á?CÂ3CÃCc                ó<  — |	�t        d«      ‚|t        j                  ur4t        j                  dt
        t        «       ¬«       |�t        |«      nd}nd}|€t        d   d   d   xs d	}| j                  |«      }| j                  |||||||||
|||||||¬
«       y)aœ  
        Append to Table in file.

        Node must already exist and be Table format.

        Parameters
        ----------
        key : str
            Key of object to append.
        value : {Series, DataFrame}
            Value of object to append.
        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.
        axes : list, default None
            Single-element list selecting the axis to store as the table's
            indexed (appendable) axis: ``[0]`` for the index (the default) or
            ``[1]`` for the columns. Ignored when appending to an existing
            table, which keeps the axes it was created with.
        index : bool, default True
            Write DataFrame index as a column.
        append : bool, default True
            Append the input data to the existing.
        complib : {'zlib', 'lzo', 'bzip2', 'blosc'}, default None
            Compression library to use; None disables compression. See the
            ``complib`` parameter of :class:`HDFStore` for the full list of
            supported compressors.
        complevel : int, 0-9, default None
            Specifies a compression level for data.
            A value of 0 or None disables compression.
        columns : default None
            This parameter is currently not accepted, try data_columns.
        min_itemsize : int, dict, or None
            Minimum number of bytes reserved for object columns.
            If int, all columns reserve 'min_itemsize' bytes per stored value.
            If dict, specific columns reserve 'min_itemsize' bytes per stored value.
            Strings are stored as encoded bytes. Since some characters require multiple
            bytes, required size may be larger than string length.
        nan_rep : str, optional
            String used on disk to represent missing values in string columns.
            By default a sentinel that collides with no value in the column is
            used, so a literal ``"nan"`` round-trips unchanged; when this is
            passed, a value equal to it is read back as a missing value.
            Only used when the table is created; ignored on later appends,
            which reuse whatever the table already stores.
        chunksize : int, default 100000
            Number of rows to write in each chunk.
        expectedrows : int
            Expected TOTAL row size of this table.
        dropna : bool, default False, optional
            Do not write an ALL nan row to the store settable
            by the option 'io.hdf.dropna_table'.

            .. deprecated:: 3.1.0
                The ``dropna`` keyword is deprecated and will be removed in a
                future version. Use :meth:`DataFrame.dropna` before writing
                instead.

        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>`__.
        encoding : default None
            Provide an encoding for str.
        errors : str, default 'strict'
            The error handling scheme to use for encoding errors.
            The default is 'strict' meaning that encoding errors raise a
            UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and
            'xmlcharrefreplace' as well as any other name registered with
            codecs.register_error that can handle UnicodeEncodeErrors.

        See Also
        --------
        HDFStore.append_to_multiple : Append to multiple tables.

        Notes
        -----
        Does *not* check if data being appended overlaps with existing
        data in the table, so be careful

        Appending an empty ``DataFrame`` or ``Series`` is a no-op: the store
        is not modified and a ``UserWarning`` is emitted.

        Examples
        --------
        >>> df1 = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
        >>> store = pd.HDFStore("store.h5", "w")  # doctest: +SKIP
        >>> store.put("data", df1, format="table")  # doctest: +SKIP
        >>> df2 = pd.DataFrame([[5, 6], [7, 8]], columns=["A", "B"])
        >>> store.append("data", df2)  # doctest: +SKIP
        >>> store.close()  # doctest: +SKIP
           A  B
        0  1  2
        1  3  4
        0  5  6
        1  7  8
        Nz>columns is not a supported keyword in append, try data_columnsz‹The 'dropna' keyword in HDFStore.append is deprecated and will be removed in a future version. Use DataFrame.dropna before writing instead.rÚ   Frg  rh  r|   ru   )rž   ÚaxesrŸ   r¥   r°   r¯   r    r¡   rº   Úexpectedrowsr¢   r£   r[   r¤   )r…   r   ri  rà   rá   r   r!   rƒ   rj  rk  rl  )ré   r¨   r‡   rž   rx  rŸ   r¥   r°   r¯   r¸   r    r¡   rº   ry  r¢   r£   r[   r¤   s                     r\   r¥   zHDFStore.append$  sÍ   € ðt ÐÜØPóð ð œŸ™Ñ'Ü�M‰Mð*ô Ü+Ó-õð &,Ð%7”T˜&”\¸U‰FàˆFØˆ>Ü˜D‘\ %Ñ(Ð)9Ñ:ÒE¸gˆFØ×&Ñ& vÓ.ˆØ×ÑØØØØØØØØØ%ØØØ%ØØ%ØØð! 	õ 	
r^   c                óv  ‡— |�t        d«      ‚t        |t        «      st        d«      ‚||vrt        d«      ‚t	        t        t        t        ‰j                  «      «      t        t        t        ‰«         «      z
  «      «      }d}	g }
|j                  «       D ](  \  }}|€|	�t        d«      ‚|}	Œ|
j                  |«       Œ* |	�W‰j                  |   }|j                  t        |
«      «      }t!        |j#                  |«      «      }|j%                  |«      ||	<   |€||   }|t&        j(                  ur%t+        j,                  dt.        t1        «       ¬«       nd}|rKˆfd	„|j3                  «       D «       }t	        |«      }|D ]  }|j5                  |«      }Œ ‰j6                  |   Š|j9                  d
d«      }|j                  «       D ]e  \  }}||k(  r|nd}‰j;                  ||¬«      }|�)|j                  «       D ��ci c]  \  }}||v sŒ||“Œ c}}nd} | j<                  ||f||dœ|¤Ž Œg yc c}}w )a  
        Append to multiple tables.

        Splits ``value`` column-wise according to ``d`` and appends each
        slice to the corresponding table. The ``selector`` table is the one
        you query against; its columns are made data_columns so they can be
        used in ``where`` clauses.

        Parameters
        ----------
        d : dict
            Mapping of table_name to table_columns. ``None`` is acceptable as
            the values for one node (that table will get all the remaining
            columns).
        value : DataFrame or Series
            Pandas object to split across the tables.
        selector : str
            Designates the indexable table; all of its columns will be made
            data_columns unless ``data_columns`` is passed, in which case
            those are used.
        data_columns : list of str or True, optional
            Columns to create as data columns, or ``True`` to use all columns.
        axes : default None
            This parameter is currently not accepted.
        dropna : bool, default False
            If ``True``, drop rows from all tables if any single row in each
            table has all NaN.

            .. deprecated:: 3.1.0
                The ``dropna`` keyword is deprecated and will be removed in a
                future version. Use :meth:`DataFrame.dropna` before writing
                instead.
        **kwargs
            Additional keyword arguments forwarded to :meth:`HDFStore.append`.

        See Also
        --------
        HDFStore.append : Append to a single table.
        HDFStore.select_as_multiple : Read from multiple tables with a
            single ``where``.

        Examples
        --------
        >>> df = pd.DataFrame({"A": [1, 2], "B": [3, 4], "C": [5, 6]})  # doctest: +SKIP
        >>> store = pd.HDFStore("store.h5", "w")  # doctest: +SKIP
        >>> store.append_to_multiple(
        ...     {"t1": ["A", "B"], "t2": None}, df, selector="t1"
        ... )  # doctest: +SKIP
        >>> store.close()  # doctest: +SKIP
        Nztaxes is currently not accepted as a parameter to append_to_multiple; you can create the tables independently insteadzQappend_to_multiple must have a dictionary specified as the way to split the valuez=append_to_multiple requires a selector that is in passed dictz<append_to_multiple can only have one value in d that is Nonez—The 'dropna' keyword in HDFStore.append_to_multiple is deprecated and will be removed in a future version. Use DataFrame.dropna before writing instead.rÚ   Fc              3  ó\   •K  — | ]#  }‰|   j                  d ¬«      j                  –— Œ% y­w)Úall)ÚhowN)r¢   rŸ   )Ú.0Úcolsr‡   s     €r\   ú	<genexpr>z.HDFStore.append_to_multiple.<locals>.<genexpr>6  s)   øè ø€ ÒO¸D�E˜$‘K×&Ñ&¨5Ð&Ó1×7Õ7ÑOùs   ƒ),r    ©rT  )r£   r    )r…   r`   Údictr„   Únextr!  ÚsetÚrangeÚndimÚ	_AXES_MAPr  r&  Úextendrx  Ú
differencer0   ÚsortedÚget_indexerÚtaker   ri  rà   rá   r   r!   ÚvaluesÚintersectionÚlocr`  Úreindexr¥   )ré   Údr‡   ra  r£   rx  r¢   rÈ   rT  Ú
remain_keyÚremain_valuesrb  ÚvÚorderedÚorddÚidxsÚvalid_indexrŸ   r    ÚdcÚvalr¨   Úfiltereds     `                    r\   Úappend_to_multiplezHDFStore.append_to_multipleÄ  sd  ø€ ðx ÐÜðBóð ô
 ˜!œTÔ"Üð)óð ð
 ˜1ÑÜØOóð ô
 ”DœœU 5§:¡:Ó.Ó/´#´iÄÀUÃÑ6LÓ2MÑMÓNÓOˆð ˆ
Ø ˆØ—G‘G“Iò 	(‰DˆAˆqØˆyØÐ)Ü$ØVóð ð ‘
à×$Ñ$ QÕ'ð	(ð Ð!Ø—j‘j Ñ&ˆGØ×%Ñ%¤e¨MÓ&:Ó;ˆDÜ˜'×-Ñ-¨dÓ3Ó4ˆDØ#ŸL™L¨Ó.ˆAˆj‰Mð ÐØ˜X™;ˆLð œŸ™Ñ'Ü�M‰Mð;ô Ü+Ó-öð ˆFÙÛOÀAÇHÁHÃJÔOˆDÜ˜t›*ˆKØò >�Ø)×6Ñ6°uÓ=‘ð>à—I‘I˜kÑ*ˆEà—z‘z .°$Ó7ˆð —G‘G“Iò 	R‰DˆAˆqØ!" h¢‘°DˆBð —-‘- ¨�-Ó-ˆCð  Ð+ð 1=×0BÑ0BÓ0D×Q¡  eÈÈqÊ��e‘ÔQàð ð
 ˆD�K‰K˜˜3ÐQ¨R¸hÑQÈ&ÓQñ	Rùó Rs   ÈH5ÈH5c                óž   — t        «        | j                  |«      }|€yt        |t        «      st	        d«      ‚|j                  |||¬«       y)aÌ  
        Create a pytables index on the table.

        Indexes are automatically created on indexable axes and
        ``data_columns`` during ``append``/``put`` when ``index=True``
        (the default). This method lets you add or rebuild indexes after
        the fact, which is **highly encouraged** because it greatly speeds
        up ``select`` calls that filter on the indexed dimension.

        Parameters
        ----------
        key : str
            Object stored in the file to index.
        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 the node is not a table.

        See Also
        --------
        HDFStore.append : Append data to an existing table; columns are
            indexed automatically by default.
        HDFStore.select : Filter on indexed columns for fast retrieval.

        Examples
        --------
        >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
        >>> store = pd.HDFStore("store.h5", "w")  # doctest: +SKIP
        >>> store.append("data", df, format="table", index=False)  # doctest: +SKIP
        >>> store.create_table_index("data", columns=["A"])  # doctest: +SKIP
        >>> store.close()  # doctest: +SKIP
        Nz1cannot create table index on a Fixed format store)r¸   ÚoptlevelÚkind)rš   rG  r`   r  r…   Úcreate_index)ré   r¨   r¸   rž  rŸ  r=  s         r\   Úcreate_table_indexzHDFStore.create_table_indexL  sH   € ôj 	Œ	Ø�O‰O˜CÓ ˆØˆ9Øä˜!œUÔ#ÜÐOÓPÐPØ	�‰˜w°ÀˆÕEr^   c                ó²  — t        «        | j                  «        | j                  €J ‚t        €J ‚| j                  j	                  «       D �cg c]  }t        |t        j                  j                  «      sYt        |j                  dd«      s@t        |dd«      s3t        |t        j                  j                  «      r|j                  dk7  r|‘Œ� c}S c c}w )aí  
        Return a list of all the top-level nodes.

        Each node returned is not a pandas storage object.

        Returns
        -------
        list
            List of objects.

        See Also
        --------
        HDFStore.get_node : Returns the node with the key.

        Examples
        --------
        >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
        >>> store = pd.HDFStore("store.h5", "w")  # doctest: +SKIP
        >>> store.put("data", df)  # doctest: +SKIP
        >>> print(store.groups())  # doctest: +SKIP
        >>> store.close()  # doctest: +SKIP
        [/data (Group) ''
          children := ['axis0' (Array), 'axis1' (Array), 'block0_values' (Array),
          'block0_items' (Array)]]
        NÚpandas_typeru   )rš   rñ   r×   r~   Úwalk_groupsr`   ÚlinkÚLinkr€   Ú_v_attrsru   r  rÒ   r$  s     r\   rÃ   zHDFStore.groupsŠ  s±   € ô4 	Œ	Ø×ÑÔØ�|‰|Ð'Ð'Ð'ÜÐ%Ð%Ð%ð —\‘\×-Ñ-Ó/ö
àä˜q¤*§/¡/×"6Ñ"6Ô7ä˜AŸJ™J¨°tÔ<Ü˜q '¨4Ô0Ü" 1¤j×&6Ñ&6×&<Ñ&<Ô=À!Ç)Á)ÈwÒBVò ò
ð 	
ùò 
s   ÁBCc              #  óL  K  — t        «        | j                  «        | j                  €J ‚t        €J ‚| j                  j	                  |«      D ]Ò  }t        |j                  dd«      �Œg }g }|j                  j                  «       D ]w  }t        |j                  dd«      }|€At        |t        j                  j                  «      sŒA|j                  |j                  «       Œ]|j                  |j                  «       Œy |j                  j                  d«      ||f–— ŒÔ y­w)aå  
        Walk the pytables group hierarchy for pandas objects.

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

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

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

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

        Yields
        ------
        path : str
            Full path to a group (without trailing '/').
        groups : list
            Names (strings) of the groups contained in `path`.
        leaves : list
            Names (strings) of the pandas objects contained in `path`.

        See Also
        --------
        HDFStore.info : Prints detailed information on the store.

        Examples
        --------
        >>> df1 = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
        >>> store = pd.HDFStore("store.h5", "w")  # doctest: +SKIP
        >>> store.put("data", df1, format="table")  # doctest: +SKIP
        >>> df2 = pd.DataFrame([[5, 6], [7, 8]], columns=["A", "B"])
        >>> store.append("data", df2)  # doctest: +SKIP
        >>> store.close()  # doctest: +SKIP
        >>> for group in store.walk():  # doctest: +SKIP
        ...     print(group)  # doctest: +SKIP
        >>> store.close()  # doctest: +SKIP
        Nr£  r  )rš   rñ   r×   r~   r¤  r€   r§  Ú_v_childrenr�  r`   rÓ   ÚGroupr¥   rÒ   rÅ   Úrstrip)ré   rm   r%  rÃ   ÚleavesÚchildr£  s          r\   ÚwalkzHDFStore.walkµ  sü   è ø€ ôV 	Œ	Ø×ÑÔØ�|‰|Ð'Ð'Ð'ÜÐ%Ð%Ð%à—‘×)Ñ)¨%Ó0ò 	>ˆAÜ�q—z‘z =°$Ó7ÐCØàˆFØˆFØŸ™×-Ñ-Ó/ò 1�Ü% e§n¡n°mÀTÓJ�ØÐ&Ü! %¬×)9Ñ)9×)?Ñ)?Õ@ØŸ™ e§m¡mÕ4à—M‘M %§-¡-Õ0ð1ð —=‘=×'Ñ'¨Ó,¨f°fÐ=Ó=ñ	>ùs   ‚CD$ÃAD$c                óf  — | j                  «        |j                  d«      sd|z   }| j                  €J ‚t        €J ‚	 | j                  j	                  | j
                  |«      }t        |t        j                  «      sJ t        |«      «       ‚|S # t        j                  j                  $ r Y yw xY w)z9return the node with the key or None if it does not existr  N)rñ   Ú
startswithr×   r~   r  rò   Ú
exceptionsÚNoSuchNodeErrorr`   rN   r  )ré   r¨   r  s      r\   r  zHDFStore.get_nodeõ  s¢   € à×ÑÔØ�~‰~˜cÔ"Ø˜‘)ˆCà�|‰|Ð'Ð'Ð'ÜÐ%Ð%Ð%ð	Ø—<‘<×(Ñ(¨¯©°CÓ8ˆDô ˜$¤
§¡Ô0Ð<´$°t³*Ó<Ð0Øˆøô	 ×$Ñ$×4Ñ4ò 	Ùð	ús   ¾&B ÂB0Â/B0c                óŒ   — | j                  |«      }|€t        d|› d�«      ‚| j                  |«      }|j                  «        |S )aÝ  
        Return the storer object for a key.

        The storer is the low-level wrapper around the stored pandas object.
        It exposes implementation details such as ``nrows`` (the row count
        on disk) and ``table`` (the underlying PyTables ``Table``), which
        can be useful for inspecting a store without loading its data.

        Parameters
        ----------
        key : str
            Object stored in the file.

        Returns
        -------
        GenericFixed or Table
            The storer wrapping the stored object. ``Table`` instances expose
            attributes such as ``nrows`` and ``table``.

        Raises
        ------
        KeyError
            If ``key`` is not in the file.

        See Also
        --------
        HDFStore.get : Read the stored object back into pandas.
        HDFStore.info : Print a summary of the store's contents.

        Examples
        --------
        >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
        >>> store = pd.HDFStore("store.h5", "w")  # doctest: +SKIP
        >>> store.append("data", df, format="table")  # doctest: +SKIP
        >>> store.get_storer("data").nrows  # doctest: +SKIP
        >>> store.close()  # doctest: +SKIP
        r3  r4  )r  r  r@  rA  )ré   r¨   rÓ   r=  s       r\   rG  zHDFStore.get_storer  sK   € ðL —‘˜cÓ"ˆØˆ=ÜÐ-¨c¨U°,Ð?Ó@Ð@à×Ñ Ó&ˆØ	�‰ŒØˆr^   c	                ó<  — t        |||||¬«      }	|€t        | j                  «       «      }t        |t        t        f«      s|g}|D ]Í  }
| j                  |
«      }|€Œ|
|	v r|r|	j                  |
«       | j                  |
«      }t        |t        «      r`d}|r0|j                  D �cg c]  }|j                  sŒ|j                  ‘Œ }}|	j                  |
||t        |dd«      |j                  ¬«       Œ¯|	j                  |
||j                  d¬«       ŒÏ |	S c c}w )añ  
        Copy the existing store to a new file, updating in place.

        Each object stored in the current ``HDFStore`` is read and re-written
        to the destination file, which can be useful for repacking (to
        reclaim space after deletes), changing compression options, or
        cloning a subset of keys.

        Parameters
        ----------
        file : str or path-like
            Destination file to write to.
        mode : str, default 'w'
            File mode for the destination, see :class:`HDFStore`.
        propindexes : bool, default True
            Restore indexes in copied file.
        keys : list, optional
            List of keys to include in the copy (defaults to all).
        complib : str, optional
            Compression library, see :class:`HDFStore`.
        complevel : int, optional
            Compression level, see :class:`HDFStore`.
        fletcher32 : bool, default False
            Whether to use the Fletcher32 checksum, see :class:`HDFStore`.
        overwrite : bool, default True
            Whether to overwrite (remove and replace) existing nodes in the
            new store.

        Returns
        -------
        HDFStore
            Open file handle of the new store.

        See Also
        --------
        HDFStore.put : Write an object to the store.
        HDFStore.append : Append to an existing table.

        Examples
        --------
        >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
        >>> store = pd.HDFStore("store.h5", "w")  # doctest: +SKIP
        >>> store.put("data", df)  # doctest: +SKIP
        >>> new_store = store.copy("store_copy.h5")  # doctest: +SKIP
        >>> new_store.close()  # doctest: +SKIP
        >>> store.close()  # doctest: +SKIP
        )r®   r°   r¯   rê   NFr£   )rŸ   r£   r[   )r[   r«   )r±   rj   r  r`   rk   rG  rý   rÆ   r  rx  Ú
is_indexedrc   r¥   r€   r[   r­   )ré   r—   r®   Úpropindexesr  r°   r¯   rê   Ú	overwriteÚ	new_storerb  r=  ÚdatarŸ   r›   s                  r\   ÚcopyzHDFStore.copy3  s  € ôt Ø�t W¸	Èjô
ˆ	ð ˆ<Ü˜Ÿ	™	›Ó$ˆDÜ˜$¤¬ Ô.Ø�6ˆDØò 	SˆAØ—‘ Ó"ˆAØ‰}Ø˜	‘>Ù Ø!×(Ñ(¨Ô+à—{‘{ 1“~�Ü˜a¤Ô'Ø.3�EÙ"Ø12·±Ö H¨A¸1¿<»< §£Ð H˜Ð HØ×$Ñ$ØØØ#Ü%,¨Q°ÀÓ%EØ!"§¡ð %õ ð —M‘M ! T°A·J±JÈE�MÕRð)	Sð, Ðùò !Is   Â(DÂ:Dc                óF  — t        | j                  «      }t        | «      › d|› d�}| j                  r™t	        | j                  «       «      }|rwg }g }|D ]\  }	 | j                  |«      }|�F|j                  t        |j                  xs |«      «       |j                  t        |xs d«      «       Œ^ |t        d||«      z  }|S |dz  }|S |d	z  }|S # t        $ r ‚ t        $ r;}|j                  |«       t        |«      }	|j                  d|	› d�«       Y d}~ŒÇd}~ww xY w)
aq  
        Print detailed information on the store.

        The information includes the file path, class name, and a listing
        of all stored object keys with their types and shapes.

        Returns
        -------
        str
            A String containing the python pandas class name, filepath to the HDF5
            file and all the object keys along with their respective dataframe shapes.

        See Also
        --------
        HDFStore.get_storer : Returns the storer object for a key.

        Examples
        --------
        >>> df1 = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
        >>> df2 = pd.DataFrame([[5, 6], [7, 8]], columns=["C", "D"])
        >>> store = pd.HDFStore("store.h5", "w")  # doctest: +SKIP
        >>> store.put("data1", df1)  # doctest: +SKIP
        >>> store.put("data2", df2)  # doctest: +SKIP
        >>> print(store.info())  # doctest: +SKIP
        >>> store.close()  # doctest: +SKIP
        <class 'pandas.io.pytables.HDFStore'>
        File path: store.h5
        /data1            frame        (shape->[2,2])
        /data2            frame        (shape->[2,2])
        r  r  Nzinvalid_HDFStore nodez[invalid_HDFStore node: rQ  é   ÚEmptyzFile is CLOSED)rF   rã   r  r¼   rŠ  r  rG  r¥   r^  rp  rq  rE   )
ré   rÀ   ÚoutputÚlkeysr  r�  rb  r=  ÚdetailÚdstrs
             r\   ÚinfozHDFStore.infoŒ  s5  € ô> ˜DŸJ™JÓ'ˆÜ˜“J�<˜}¨T¨F°"Ð5ˆà�<Š<Ü˜4Ÿ9™9›;Ó'ˆEÙØ�Ø�àò J�AðJØ ŸO™O¨AÓ.˜Ø˜=Ø ŸK™K¬°Q·Z±Z²_À1Ó(EÔFØ"ŸM™M¬,°qÒ7SÐ<SÓ*TÔUøðJð œ&  T¨6Ó2Ñ2�ð ˆð	 ˜'Ñ!�ð ˆð Ð&Ñ&ˆFàˆøô *ò àÜ$ò JØŸ™ AœÜ+¨FÓ3˜ØŸ™Ð(@ÀÀÀaÐ&H×IÑIûðJús   ÁACÃD Ã%1DÄD c                óL   — | j                   st        | j                  › d�«      ‚y )Nz file is not open!)r¼   r   rã   rî   s    r\   rñ   zHDFStore._check_if_openÍ  s%   € Ø�|Š|Ü! T§Z¡Z LÐ0BÐ"CÓDÐDð r^   c                óx   — 	 t         |j                  «          }|S # t        $ r}t        d|› d�«      |‚d}~ww xY w)zvalidate / deprecate formatsz#invalid HDFStore format specified [rQ  N)Ú_FORMAT_MAPÚlowerr  r…   )ré   rž   rv  s      r\   rk  zHDFStore._validate_formatÑ  sK   € ð	VÜ  §¡£Ñ0ˆFð ˆøô ò 	VÜÐAÀ&ÀÈÐKÓLÐRUÐUûð	Vús   ‚ ›	9¤4´9c           	     óÞ  — |�!t        |t        t        f«      st        d«      ‚t	        |j
                  dd«      }t	        |j
                  dd«      }|€t|€St        «        t        €J ‚t	        |dd«      s$t        |t        j                  j                  «      rd}d}n*t        d«      ‚t        |t        «      rd	}nd
}|dk(  r|dz  }d|vrt        t        dœ}	 ||   }	 |	| |||¬«      S |€q|�o|dk(  r3t	        |dd«      }|�[|j                  dk(  rd}nI|j                  dkD  r:d}n7|dk(  r2t	        |dd«      }|�#|j                  dk(  rd}n|j                  dkD  rd}t        t         t"        t$        t&        t(        dœ}	 ||   }	 |	| |||¬«      S # t        $ r#}
t        d|› dt        |«      › d|› �«      |
‚d}
~
ww xY w# t        $ r#}
t        d|› dt        |«      › d|› �«      |
‚d}
~
ww xY w)z"return a suitable class to operateNz(value must be None, Series, or DataFramer£  Ú
table_typeru   Úframe_tableÚgeneric_tablezKcannot create a storer if the object is not existing nor a value are passedÚseriesÚframeÚ_table)rË  rÌ  z=cannot properly create the storer for: [_STORER_MAP] [group->ú,value->z	,format->©r[   r¤   Úseries_tablerŸ   rg   Úappendable_seriesÚappendable_multiseriesÚappendable_frameÚappendable_multiframe)rÊ  rÑ  rÒ  rÓ  rÔ  Úwormz<cannot properly create the storer for: [_TABLE_MAP] [group->)r`   r4   r.   r…   r€   r§  rš   r~   ru   r  ÚSeriesFixedÚ
FrameFixedr  r  ÚnlevelsÚGenericTableÚAppendableSeriesTableÚAppendableMultiSeriesTableÚAppendableFrameTableÚAppendableMultiFrameTableÚ	WORMTable)ré   rÓ   rž   r‡   r[   r¤   ÚptÚttÚ_STORER_MAPÚclsrv  rŸ   Ú
_TABLE_MAPs                r\   r@  zHDFStore._create_storerÛ  sO  € ð Ð¤Z°¼Ä	Ð7JÔ%KÜÐFÓGÐGä�U—^‘^ ]°DÓ9ˆÜ�U—^‘^ \°4Ó8ˆð ˆ:Øˆ}Ü”	Ü!Ð-Ð-Ð-Ü˜5 '¨4Ô0´JØœ:×+Ñ+×1Ñ1ô5ð '�BØ(‘Bä#ð1óð ô
 ˜e¤VÔ,Ø!‘Bà �Bð ˜WÒ$Ø˜(‘N�Bð ˜"ÑÜ%0¼:ÑFˆKðØ! "‘o�ñ �t˜U¨X¸fÔEÐEð ˆ:àÐ Ø˜Ò'Ü# E¨7°DÓ9�EØÐ(Ø Ÿ=™=¨AÒ-Ø!4™BØ"Ÿ]™]¨QÒ.Ø!9™BØ˜=Ò(Ü# E¨7°DÓ9�EØÐ(Ø Ÿ=™=¨AÒ-Ø!3™BØ"Ÿ]™]¨QÒ.Ø!8˜Bô *Ü!6Ü&@Ü 4Ü%>Üñ
ˆ
ð	Ø˜R‘.ˆCñ �4˜¨¸&ÔAÐAøôU ò ÜØSØ�g˜X¤d¨5£k ]°)¸F¸8ðEóð ðûðûôH ò 	ÜØNØ�'˜¤$ u£+ ¨i¸°xðAóð ðûð	ús0   ÃF Æ G  Æ	F=ÆF8Æ8F=Ç 	G,Ç	G'Ç'G,c                óN  — t        |dd «      r,|dk(  s|r%t        j                  dt        t	        «       ¬«       y | j                  ||«      }| j                  |||||¬«      }|rU|j                  r|j                  r |dk(  r|j                  rt        d|›d�«      ‚|j                  s!|j                  «        n|j                  «        |j                  s|rt        d	«      ‚|j                  ||||||	|
||||||¬
«       t        |t        «      r|r|j                  |¬«       y y y )NÚemptyru   zqWriting an empty DataFrame or Series with format='table' or append=True is a no-op; the HDFStore is not modified.rÚ   rÏ  rt   z-Can only append to Tables; the write for key zƒ uses the 'fixed' format. Pass format='table'; if a 'fixed'-format object already exists at this key, remove or overwrite it first.z0Compression not supported on Fixed format stores)Úobjrx  r¥   r°   r¯   rê   r    rº   ry  r¢   r¡   r£   r«   ©r¸   )r€   rà   rá   râ   r!   Ú_identify_groupr@  r]  Ú	is_existsr„   Úset_object_infoÚwriter`   r  r   )ré   r¨   r‡   rž   rx  rŸ   r¥   r°   r¯   rê   r    rº   ry  r¢   r¡   r£   r[   r¤   r«   rÓ   r=  s                        r\   rl  zHDFStore._write_to_group6	  s9  € ô. �5˜' 4Ô(¨f¸Ò.?Á6Ü�M‰MðKäÜ+Ó-õ	ð à×$Ñ$ S¨&Ó1ˆà×Ñ  v¨u¸xÐPVÐÓWˆÙð —:’: !§*¢*°¸7Ò1BÀqÇ{Â{Ü ØCÀCÀ7ð K-ð -óð ð —;’;Ø×!Ñ!Õ#à×ÑÔà�zŠz™gÜÐOÓPÐPð 	
�‰ØØØØØØ!Ø%ØØ%ØØØ%Ø#ð 	ô 	
ô  �aœÔ¡EØ�N‰N 5ˆNÕ)ð %*Ðr^   c                ód   — | j                  |«      }|j                  «        |j                  «       S rY   )r@  rA  r9  )ré   rÓ   r=  s      r\   r5  zHDFStore._read_group	  s&   € Ø×Ñ Ó&ˆØ	�‰ŒØ�v‰v‹xˆr^   c                ó’  — | j                  |«      }| j                  €J ‚|��|�s	t        €J ‚t        |j                  j                  «       «      }t        |j                  dd«      du}|D �cg c]9  }t        |t        j                  j                  «      r|r|j                  dk(  s|‘Œ; }}|r`|D ]$  }||vsŒ| j                  j                  |d¬«       Œ& |j                  j                  d«      D ]  }t        |j                  |«       Œ n| j                  j                  |d¬«       d}|€| j                  |«      }|S c c}w )z@Identify HDF5 group based on key, delete/create group if needed.Nr£  rÏ   Trn  Úuser)r  r×   r~   rj   r©  r�  r€   r§  r`   rÓ   rª  rÒ   Úremove_nodeÚ_f_listÚdelattrÚ_create_nodes_and_group)	ré   r¨   r¥   rÓ   ÚchildrenÚis_stored_objectr­  Únested_keysÚ	attr_names	            r\   rè  zHDFStore._identify_group„	  sQ  € à—‘˜cÓ"ˆð �|‰|Ð'Ð'Ð'ð Ñ¢VÜÐ)Ð)Ð)Ü˜E×-Ñ-×4Ñ4Ó6Ó7ˆHô  ' u§~¡~°}ÀdÓKÐSWÐWÐð &öàÜ˜e¤Z×%5Ñ%5×%;Ñ%;Ô<Ù)¨e¯m©m¸vÒ.Eò ðˆKð ñ ð
 &ò H�EØ KÒ/ØŸ™×0Ñ0°À$Ð0ÕGðHð "'§¡×!7Ñ!7¸Ó!?ò 7�IÜ˜EŸN™N¨IÕ6ñ7ð —‘×(Ñ(¨¸$Ð(Ô?Ø�àˆ=Ø×0Ñ0°Ó5ˆEàˆùò/s   Á.>Ec                ó
  — | j                   €J ‚|j                  d«      }d}|D ]\  }t        |«      sŒ|}|j                  d«      s|dz  }||z  }| j	                  |«      }|€| j                   j                  ||«      }|}Œ^ S )z,Create nodes from key and return group name.r  )r×   Úsplitrl   Úendswithr  Úcreate_group)ré   r¨   ÚpathsrÀ   ÚpÚnew_pathrÓ   s          r\   rò  z HDFStore._create_nodes_and_group¬	  s—   € ð �|‰|Ð'Ð'Ð'à—	‘	˜#“ˆàˆØò 
	ˆAÜ�q”6ØØˆHØ—=‘= Ô%Ø˜C‘�Ø˜‰MˆHØ—M‘M (Ó+ˆEØˆ}ØŸ™×1Ñ1°$¸Ó:�Ø‰Dð
	ð ˆr^   )r›   NNF)r®   ra   r¯   ú
int | Nonerê   rƒ   ÚreturnÚNone©rÿ  ra   ©r¨   ra   )r¨   ra   rÿ  r   )r¨   ra   rÿ  rþ  )rc   ra   )r¨   ra   rÿ  rƒ   ©rÿ  Úint)rÿ  r   )r  ztype[BaseException] | Noner  zBaseException | Noner  zTracebackType | Nonerÿ  r   )r´   )r  ra   rÿ  ú	list[str])rÿ  zIterator[str])rÿ  zIterator[tuple[str, list]])r›   )r®   ra   rÿ  r   ©rÿ  r   ©rÿ  rƒ   ©F)r0  rƒ   rÿ  r   )NNNNFNF)r¨   ra   r¹   rƒ   rº   rþ  r»   rƒ   ©NNN©r¨   ra   rŽ   rþ  r�   rþ  ©NN)r¨   ra   rL  ra   rŽ   rþ  r�   rþ  )NNNNNFNF)r¹   rƒ   rº   rþ  r»   rƒ   )r¨   ra   r‡   úDataFrame | SeriesrŸ   rƒ   r¥   rƒ   r¯   rþ  r    úint | dict[str, int] | Noner£   ú Literal[True] | list[str] | Noner¤   ra   r«   úbool | lib.NoDefaultr¢   r  rÿ  r   )r¨   ra   r‡   r  rŸ   úbool | list[str]r¥   rƒ   r¯   rþ  r    r  rº   rþ  r¢   úbool | lib.NoDefault | Noner£   r  r¤   ra   rÿ  r   )r‘  r‚  r¢   r  rÿ  r   )r¨   ra   rž  rþ  rŸ  ú
str | Nonerÿ  r   ©rÿ  rj   )r  )rm   ra   rÿ  z*Iterator[tuple[str, list[str], list[str]]])r¨   ra   rÿ  zNode | None)r¨   ra   rÿ  úGenericFixed | Table)r(  TNNNFT)r®   ra   r¶  rƒ   r¯   rþ  rê   rƒ   r·  rƒ   rÿ  r±   )rž   ra   rÿ  ra   )NNrW   r”   )r‡   zDataFrame | Series | Noner[   ra   r¤   ra   rÿ  r  )NTFNNNNNNFNNNr”   T)r¨   ra   r‡   r  rŸ   r  r¥   rƒ   r¯   rþ  r    r  rº   rþ  r¢   rƒ   r¤   ra   r«   rƒ   rÿ  r   )rÓ   rN   )r¨   ra   r¥   rƒ   rÿ  rN   )r¨   ra   rÿ  rN   )3r  Ú
__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Æ   rJ  rN  re  r   ri  r­   rý   r¥   rœ  r¡  rÃ   r®  r  rG  rº  rÂ  rñ   rk  r@  rl  r5  rè  rò  rÜ   r^   r\   r±   r±   +  sk  … ñIðV ÓØƒJð
 Ø $ØØ ð+'ð ð+'ð ð	+'ð ð+'ð 
ó+'óZð ñ!ó ð!ð òó ðóó0ó ó
ó
ó"ó4óðà,ðð (ðð (ð	ð
 
óô2
óh!ó#ô+JóZð ò)ó ð)ô4$4óL$+ðR ØØØØØ $Ø ðaàðað ðað ðað óaðL Ø Øð9Iàð9Ið ð	9Ið
 ó9Ið~ !Øð@Fàð@Fð ð@Fð ð	@Fð
 ó@FðJ ØØØØØØ $Ø ð\/ð ð\/ð ð\/ð ó\/ðD ØØØØ $Ø48ØØ9=ØØØ,/¯N©NØ'*§~¡~ðV
àðV
ð "ðV
ð
 ðV
ð ðV
ð ðV
ð 2ðV
ð 7ðV
ð ðV
ð *ðV
ð %ðV
ð  
ó!V
ôpK=ðb ØØ"&ØØØ $ØØ48ØØ $ØØ.1¯n©nØ9=ØØð%^
àð^
ð "ð^
ð  ð^
ð ð^
ð ð^
ð 2ð^
ð ð^
ð ,ð^
ð  7ð!^
ð$ ð%^
ð& 
ó'^
ðJ ØØ'*§~¡~ðFRàðFRð %ðFRð 
óFRðV Ø#Øð<Fàð<Fð ð	<Fð
 ð<Fð 
ó<Fó|)
ôV>>ó@ó ,ðb Ø ØØØ $Ø ØðWð ðWð ð	Wð ðWð ðWð ðWð 
óWór<óBEóð Ø+/ØØðYBð )ð	YBð
 ðYBð ðYBð 
óYBð@ Ø"&ØØØ $ØØ48Ø $ØØØØØØØ ð'G*àðG*ð "ðG*ð  ðG*ð ðG*ð ðG*ð 2ðG*ð ðG*ð ðG*ð$ ð%G*ð& ð'G*ð( 
ó)G*óRó
&ôPr^   r±   c                  ót   — e Zd ZU dZded<   ded<   ded<   	 	 	 	 	 d	 	 	 	 	 	 	 	 	 	 	 dd	„Zdd
„Zdd„Zddd„Zy)rB  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§   r  r=  Nc                ó2  — || _         || _        || _        || _        | j                  j                  r|€d}t        |||«      \  }}|| _        || _        || _        d | _	        d| _
        |s|	�|	€d}	t        |	«      | _        |
| _        y d | _        |
| _        y )Nr   Fé † )r§   r=  r>  rm   r]  r’   r�   rŽ   r�   rY  Ú_called_get_resultr  rº   r»   )ré   r§   r=  r>  rm   r�   rŽ   r�   r¹   rº   r»   s              r\   rë   zTableIterator.__init__Ú	  s¥   € ð ˆŒ
ØˆŒØˆŒ	ØˆŒ
ð �6‰6�?Š?Øˆ}Ø�Ü-¨e°T¸5ÓA‰KˆE�4àˆŒ
ØˆŒ
ØˆŒ	àˆÔØ"'ˆÔÙ�yÐ,ØÐ Ø"�	Ü  ›^ˆDŒNð %ˆ�ð "ˆDŒNà$ˆ�r^   c              #  óž  K  — | j                   st        d«      ‚| j                  }|| j                  k  r‡t	        || j
                  z   | j                  «      }| j                  €| j                  ||d «      }n | j                  d d | j                  || «      }|}|�t        |«      sŒ‚|–— || j                  k  rŒ‡| j                  «        y ­w)Nz*Cannot iterate until get_result is called.)
r  r„   rŽ   r�   Úminrº   rY  r>  rl   rÇ   )ré   rˆ   r�   r‡   s       r\   r"  zTableIterator.__iter__
  s¹   è ø€ à×&Ò&ÜÐIÓJÐJØ—*‘*ˆØ˜Ÿ	™	Ò!Ü�w §¡Ñ/°·±Ó;ˆDØ×ÑÐ'ð Ÿ	™	 '¨4°Ó6‘àŸ	™	 $¨¨d×.>Ñ.>¸wÀtÐ.LÓM�ØˆGØˆ}¤C¨¤JØàŠKð ˜Ÿ	™	Ó!ð 	�
‰
�ùs   ‚B9CÂ<Cc                óR   — | j                   r| j                  j                  «        y y rY   )r»   r§   rÇ   rî   s    r\   rÇ   zTableIterator.close
  s   € Ø�?Š?Ø�J‰J×ÑÕð r^   c                óN  — d| _         | j                  �^t        | j                  t        «      st        d«      ‚| j                  �+| j                  j                  | j                  ¬«      | _        | S |rn| j                  �bt        | j                  t        «      st        d«      ‚| j                  j                  | j                  | j                  | j                  ¬«      }n| j                  }| j                  | j                  | j                  |«      }| j                  «        |S )NTz0can only use an iterator or chunksize on a table©rm   z$can only read_coordinates on a tablerF  )r  rº   r`   r=  r  r…   rm   rH  rY  rŽ   r�   r>  rÇ   )ré   rY  rm   Úresultss       r\   rC  zTableIterator.get_result
  sæ   € à"&ˆÔØ�>‰>Ð%Ü˜dŸf™f¤eÔ,ÜÐ RÓSÐSà�z‰zÐ%ð $(§6¡6×#:Ñ#:ÀÇÁÐ#:Ó#L�Ô àˆKñ ˜4Ÿ:™:Ð1Ü˜dŸf™f¤eÔ,ÜÐ FÓGÐGØ—F‘F×+Ñ+Ø—j‘j¨¯
©
¸¿¹ð ,ó ‰Eð —J‘JˆEð —)‘)˜DŸJ™J¨¯	©	°5Ó9ˆØ�
‰
ŒØˆr^   )NNFNF)r§   r±   r=  r  r¹   rƒ   rº   rþ  r»   rƒ   rÿ  r   ©rÿ  rI   r  r  )rY  rƒ   )	r  r  r  r  r  rë   r"  rÇ   rC  rÜ   r^   r\   rB  rB  Â	  sz   … ñð& ÓØƒOØÓð ØØØ $Ø ð%%àð%%ð  ð%%ð ð%%ð ð%%ð ð%%ð 
ó%%óNó,õr^   rB  c                  ó¦  — e Zd ZU dZdZded<   dZded<   dZded<   g d¢Z	 	 	 	 	 	 	 	 	 	 	 	 	 	 d%	 	 	 	 	 d&d
„Z	e
d'd„«       Ze
d(d„«       Ze
d(d„«       Ze
d(d„«       Zd)d„Zd(d„Zd*d„Zd+d„Ze
d+d„«       Z	 	 	 	 	 	 	 	 d,d„Zd„ Ze
d„ «       Ze
d„ «       Ze
d„ «       Ze
d„ «       Zd-d„Zd.d/d„Zd/d„Zd0d„Zd.d„Zd1d„Zd/d „Z d/d!„Z!d/d"„Z"d2d#„Z#d2d$„Z$y	)3Ú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_indexableFÚuses_col_nan_rep)ÚfreqÚtzÚ
index_namer•  Nc                óª  — t        |t        «      st        d«      ‚|| _        || _        || _        || _        |xs || _        || _        || _	        || _
        |	| _        |
| _        || _        || _        || _        || _        || _        |�| j%                  |«       t        | j                  t        «      sJ ‚t        | j                  t        «      sJ ‚y )Nz`name` must be a str.)r`   ra   r„   r�  rŸ  Útyprc   ÚcnamerT  Úposr*  r+  r,  r•  ru   rÏ   Úmetadatar¡   Úset_pos)ré   rc   r�  rŸ  r.  r/  rT  r0  r*  r+  r,  r•  ru   rÏ   r1  r¡   s                   r\   rë   zIndexCol.__init__S
  sÄ   € ô$ ˜$¤Ô$ÜÐ4Ó5Ð5àˆŒØˆŒ	ØˆŒØˆŒ	Ø’]˜dˆŒ
ØˆŒ	ØˆŒØˆŒ	ØˆŒØ$ˆŒØˆŒØˆŒ
ØˆŒ	Ø ˆŒð ˆŒàˆ?Ø�L‰L˜Ôô ˜$Ÿ)™)¤SÔ)Ð)Ð)Ü˜$Ÿ*™*¤cÔ*Ð*Ñ*r^   c                ó.   — | j                   j                  S rY   )r.  Úitemsizerî   s    r\   r4  zIndexCol.itemsize‚
  s   € ð �x‰x× Ñ Ð r^   c                ó    — | j                   › d�S )NÚ_kindrb   rî   s    r\   Ú	kind_attrzIndexCol.kind_attr‡
  ó   € à—)‘)�˜EÐ"Ð"r^   c                ó    — | j                   › d�S )NÚ_metarb   rî   s    r\   Ú	meta_attrzIndexCol.meta_attr‹
  r8  r^   c                ó    — | j                   › d�S )NÚ_nan_reprb   rî   s    r\   Únan_rep_attrzIndexCol.nan_rep_attr�
  s   € à—)‘)�˜HÐ%Ð%r^   c                óT   — || _         |�| j                  �|| j                  _        yyy)z,set the position of this column in the TableN)r0  r.  Ú_v_pos)ré   r0  s     r\   r2  zIndexCol.set_pos“
  s)   € àˆŒØˆ?˜tŸx™xÐ3Ø!ˆD�H‰H�Oð  4ˆ?r^   c           
     ó  — t        t        t        | j                  | j                  | j
                  | j                  | j                  f«      «      }dj                  t        g d¢|d¬«      D ��cg c]  \  }}|› d|› �‘Œ c}}«      S c c}}w )Nú,)rc   r/  rT  r0  rŸ  TrP  ú->)
rk   ÚmaprF   rc   r/  rT  r0  rŸ  Újoinr\  ©ré   Útempr¨   r‡   s       r\   r  zIndexCol.__repr__™
  s€   € ÜÜ”˜tŸy™y¨$¯*©*°d·i±iÀÇÁÈ4Ï9É9ÐUÓVó
ˆð �x‰xô #&Ú<¸dÈ4ô#÷á�C˜ð �%�r˜%˜Ò!óó
ð 	
ùóó   Á/B
c                ó0   ‡ ‡— t        ˆˆ fd„dD «       «      S )úcompare 2 col itemsc              3  óT   •K  — | ]  }t        ‰|d «      t        ‰|d «      k(  –— Œ! y ­wrY   ©r€   ©r~  r›   Úotherré   s     €€r\   r€  z"IndexCol.__eq__.<locals>.<genexpr>¨
  ó0   øè ø€ ò 
àô �D˜!˜TÓ"¤g¨e°Q¸Ó&=Õ=ñ
ùó   ƒ%()rc   r/  rT  r0  ©r|  ©ré   rN  s   ``r\   Ú__eq__zIndexCol.__eq__¦
  s   ù€ äô 
à5ô
ó 
ð 	
r^   c                ó&   — | j                  |«       S rY   )rS  rR  s     r\   Ú__ne__zIndexCol.__ne__­
  s   € Ø—;‘;˜uÓ%Ð%Ð%r^   c                ó˜   — t        | j                  d«      syt        | j                  j                  | j                  «      j
                  S )z%return whether I am an indexed columnr  F)Úhasattrru   r€   r  r/  rµ  rî   s    r\   rµ  zIndexCol.is_indexed°
  s4   € ô �t—z‘z 6Ô*àÜ�t—z‘z—‘¨¯
©
Ó3×>Ñ>Ð>r^   c                óø  — t        |t        j                  «      sJ t        |«      «       ‚|j                  j
                  �|| j                     j                  «       }| j                  dk(  �r(| j                  }|j                  «       }|€t        g t        j                  ¬«      }n�t        |«      }|j                  «       r‚t        j                  t!        |«      d|j                  ¬«      }t        j"                  | j%                  «       |j                  ¬«      || <   ||    }t        j&                  |dk  |||   «      }t)        j*                  ||t-        | j.                  «      d¬«      }	t1        j2                  |	| j4                  ¬«      }
|
|
fS | j6                  }t9        ||||| j:                  «      }i }| j4                  |d	<   |d
k(  rt=        «       rd|d<   | j>                  �| j>                  |d<   t        }tA        jB                  |j                  d«      st        |j                  tD        «      rtF        }nV|jI                  d«      r/|dk(  r|jK                  d«      }n|jK                  |«      }tL        }n|j                  dk(  rd|v rd„ }	  ||fi |¤Ž}| j\                  �>t        |tF        «      r.|j_                  d«      ja                  | j\                  «      }||fS |}||fS # tN        $ rb}|dk(  rRt=        «       rHtQ        |«      jS                  d«      r.tT        r(tW        dt        jX                  ¬«      |d<    ||fi |¤Ž}n‚ Y d}~Œ¶d}~wtZ        $ r d|v rd|d<    ||fi |¤Ž}Y ŒÖw xY w)zV
        Convert the data from this selection to the appropriate pandas type.
        NÚcategory©Údtypeéÿÿÿÿr   F©Ú
categoriesr•  Úvalidaterb   rc   Ústringra   r[  r*  ÚMÚtimedelta64úm8[ns]Úi8c                ót   — t        j                  | |j                  dd «      ¬«      j                  |d   «      S )Nr*  )r*  rc   )r2   Úfrom_ordinalsr÷   Ú_rename)rc  Úkwdss     r\   r©   z"IndexCol.convert.<locals>.<lambda>
  s2   € ¬×(AÑ(AØ˜Ÿ™ ¨Ó.ô)ç‰g�d˜6‘lÓ#ð r^   Úsurrogatepassúsurrogates not allowedÚpython©ÚstorageÚna_valueÚUTC)1r`   ÚnpÚndarrayr  r[  Úfieldsr/  rº  rÏ   r1  Úravelr0   Úfloat64r8   ÚanyÚfullrl   ÚarangeÚsumrm   r9   Ú
from_codesrƒ   r•  r-   Ú_simple_newr,  rŸ  Ú_maybe_convertr¡   r   r*  r   Úis_np_dtyper)   r/   r°  Úviewr6   ÚUnicodeEncodeErrorra   rù  r   r5   Únanr„   r+  Útz_localizeÚ
tz_convert)ré   r�  r¡   r[   r¤   r^  ÚcodesÚmaskÚremapÚcatÚ	cat_indexÚval_kindrÈ   ÚfactoryÚnew_pd_indexrv  Úfinal_pd_indexs                    r\   ÚconvertzIndexCol.convert¸
  s  € ô ˜&¤"§*¡*Ô-Ð;¬t°F«|Ó;Ð-ð �<‰<×ÑÐ*ð ˜DŸJ™JÑ'×,Ñ,Ó.ˆFà�9‰9˜
Ó"ð Ÿ™ˆJØ—L‘L“NˆEð Ð!ô # 2¬R¯Z©ZÔ8‘
ä˜JÓ'�Ø—8‘8”:ô ŸG™G¤C¨
£O°R¸u¿{¹{ÔK�EÜ#%§9¡9¨t¨e¯[©[«]À%Ç+Á+Ô#N�E˜4˜%‘LØ!+¨T¨EÑ!2�JÜŸH™H U¨Q¡Y°°u¸U±|ÓD�Eä×(Ñ(ØØ%Ü˜TŸ\™\Ó*Øô	ˆCô )×4Ñ4°S¸t¿¹ÔOˆIØ˜iÐ'Ð'à—9‘9ˆô   ¨°(¸FÀDÇLÁLÓQˆØˆØŸ™ˆˆv‰à�xÒÔ$6Ô$8ð $ˆF�7‰Oà�9‰9Ð Ø!ŸY™YˆF�6‰Nä@EˆÜ�?‰?˜6Ÿ<™<¨Ô-´Ø�L‰Lœ/ô2
ô $‰GØ× Ñ  Ô/ð ˜=Ò(àŸ™ XÓ.‘àŸ™ XÓ.�Ü$‰GØ�\‰\˜TÒ! f°Ñ&6ñ
$ˆGð
	5Ù" 6Ñ4¨VÑ4ˆLð( �7‰7Ð¤:¨l¼MÔ#JØ)×5Ñ5°eÓ<×GÑGÈÏÉÓPˆNð ˜~Ð-Ð-ð *ˆNØ˜~Ð-Ð-øô/ "ò 
	à˜/Ò)Ü&Ô(Ü˜“H×%Ñ%Ð&>Ô?Ýä"-°hÌÏÉÔ"P��w‘Ù& vÑ8°Ñ8‘àô ûô ò 	5ð ˜ÑØ!%��v‘Ù" 6Ñ4¨VÑ4ŠLð	5ús   Ê	K2 Ë2	M9Ë;AMÍM9Í8M9c                ó   — | j                   S )zreturn the values©r�  rî   s    r\   Ú	take_datazIndexCol.take_data*  s   € à�{‰{Ðr^   c                ó.   — | j                   j                  S rY   )ru   r§  rî   s    r\   r†   zIndexCol.attrs.  ó   € à�z‰z×"Ñ"Ð"r^   c                ó.   — | j                   j                  S rY   ©ru   Údescriptionrî   s    r\   r“  zIndexCol.description2  ó   € à�z‰z×%Ñ%Ð%r^   c                óD   — t        | j                  | j                  d«      S )z!return my current col descriptionN)r€   r“  r/  rî   s    r\   ÚcolzIndexCol.col6  s   € ô �t×'Ñ'¨¯©°TÓ:Ð:r^   c                ó   — | j                   S ©zreturn my cython valuesr�  rî   s    r\   ÚcvalueszIndexCol.cvalues;  s   € ð �{‰{Ðr^   c                ó,   — t        | j                  «      S rY   )r!  r�  rî   s    r\   r"  zIndexCol.__iter__@  s   € Ü�D—K‘KÓ Ð r^   c                ó  — | j                   dk(  rst        |t        «      r|j                  | j                  «      }|�E| j
                  j                  |k  r+t        «       j                  || j                  ¬«      | _        yyyy)zŸ
        maybe set a string col itemsize:
            min_itemsize can be an integer or a dict with this columns name
            with an integer size
        r`  N)r4  r0  )
rŸ  r`   r‚  r÷   rc   r.  r4  rš   Ú	StringColr0  )ré   r    s     r\   Úmaybe_set_sizezIndexCol.maybe_set_sizeC  sp   € ð �9‰9˜Ò Ü˜,¬Ô-Ø+×/Ñ/°·	±	Ó:�àÐ'¨D¯H©H×,=Ñ,=ÀÒ,LÜ"›9×.Ñ.¸È$Ï(É(Ð.ÓS�•ð -MÐ'ð	 !r^   c                 ó   — y rY   rÜ   rî   s    r\   Úvalidate_nameszIndexCol.validate_namesP  ó   € Ør^   c                óÌ   — |j                   | _         | j                  «        | j                  |«       | j                  |«       | j	                  |«       | j                  «        y rY   )ru   Úvalidate_colÚvalidate_attrÚvalidate_metadataÚwrite_metadataÚset_attr)ré   Úhandlerr¥   s      r\   Úvalidate_and_setzIndexCol.validate_and_setS  sL   € Ø—]‘]ˆŒ
Ø×ÑÔØ×Ñ˜6Ô"Ø×Ñ˜wÔ'Ø×Ñ˜GÔ$Ø�‰�r^   c           	     óâ   — | j                   dk(  r`| j                  }|�R|€| j                  }|j                  |k  r)t        d|› d| j                  › d|j                  › d�«      ‚|j                  S y)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)rŸ  r–  r4  r„   r/  )ré   r4  Úcs      r\   r¢  zIndexCol.validate_col[  sƒ   € ð �9‰9˜Ò Ø—‘ˆAØˆ}ØÐ#Ø#Ÿ}™}�HØ—:‘: Ò(Ü$Ø=¸h¸Zð HØ ŸJ™J˜<ð (ØŸJ™J˜<ð (<ð<óð ð —z‘zÐ!àr^   c                óR  — |r¥t        | j                  | j                  d «      }|€y || j                  k7  rt	        d|› d| j                  › d�«      ‚t        | j                  | j
                  d «      }|| j                  k7  r%| j                  dk(  rt	        d«      ‚t	        d«      ‚y y )Nzincompatible kind in col [ú - rQ  rY  z<cannot append a categorical index to a non-categorical indexz<cannot append a non-categorical index to a categorical index)r€   r†   r7  rŸ  r…   r;  rÏ   )ré   r¥   Úexisting_kindÚexisting_metas       r\   r£  zIndexCol.validate_attrn  s±   € áÜ# D§J¡J°·±ÀÓEˆMØÐ$àØ §	¡	Ò)ÜØ0°°¸sÀ4Ç9Á9À+ÈQÐOóð ô $ D§J¡J°·±ÀÓEˆMØ §	¡	Ò)ð —9‘9 
Ò*Ü#ØVóð ô  ØRóð ð *ð r^   c                ó–  — | j                   D ]º  }t        | |d«      }|j                  | j                  i «      }|j	                  |«      }||v rp|�n||k7  ri|dv rCt
        |||fz  }t        j                  |t        t        «       ¬«       d||<   t        | |d«       Œ�t        d| j                  › d|› d|› d|› d�	«      ‚|€|€Œ¶|||<   Œ¼ y)	z
        set/update the info for this indexable with the key/value
        if there is a conflict raise/warn as needed
        N)r*  r,  rÚ   zinvalid info for [z] for [z], existing_value [z] conflicts with new value [rQ  )Ú_info_fieldsr€   Ú
setdefaultrc   r÷   rr   rà   rá   r   r!   r‚   r„   )ré   rÂ  r¨   r‡   ÚidxÚexisting_valueÚwss          r\   Úupdate_infozIndexCol.update_info†  s÷   € ð
 ×$Ñ$ò 	!ˆCÜ˜D # tÓ,ˆEØ—/‘/ $§)¡)¨RÓ0ˆCà ŸW™W S›\ˆNØ�c‰z˜eÐ/°NÀeÒ4KàÐ0Ñ0Ü/°3¸ÈÐ2NÑN�BÜ—M‘MØÔ4ÔAQÓASõð
  $�C˜‘HÜ˜D # tÕ,ô %Ø,¨T¯Y©Y¨K°w¸s¸eð D+Ø+9Ð*:ð ;&Ø&+ W¨Að/óð ð
 Ð" nÑ&@Ø ��C’ñ1	!r^   c                óv   — |j                  | j                  «      }|�| j                  j                  |«       yy)z!set my state from the passed infoN)r÷   rc   Ú__dict__Úupdate)ré   rÂ  r²  s      r\   Úset_infozIndexCol.set_info¥  s0   € à�h‰h�t—y‘yÓ!ˆØˆ?Ø�M‰M× Ñ  Õ%ð r^   c                óF  — t        | j                  | j                  | j                  «       | j                  �+t        | j                  | j
                  | j                  «       | j                  dk(  r0t        | j                  | j                  | j                  xs d«       yy)zset the kind for this columnNr`  Ú )rŠ   r†   r7  rŸ  rÏ   r;  r>  r¡   rî   s    r\   r¦  zIndexCol.set_attr«  sq   € ä˜TŸZ™Z¨¯©¸¿¹ÔCØ�9‰9Ð ô ! §¡¨T¯^©^¸T¿Y¹YÔGØ�9‰9˜Ò ô ! §¡¨T×->Ñ->ÀÇÁÒ@RÐPRÕSð	 !r^   c                ó²   — | j                   dk(  rH| j                  }|j                  | j                  «      }|�|�t	        ||dd¬«      st        d«      ‚yyyy)z:validate that kind=category does not change the categoriesrY  NT©Ú
strict_nanÚdtype_equalz®cannot append a categorical with different categories to the existing; align with `cat.set_categories(...)` or pre-merge with `pd.api.types.union_categoricals` before writing)rÏ   r1  Úread_metadatar/  r,   r„   )ré   r§  Únew_metadataÚcur_metadatas       r\   r¤  zIndexCol.validate_metadata¹  sp   € à�9‰9˜
Ò"ØŸ=™=ˆLØ"×0Ñ0°·±Ó<ˆLàÐ(Ø Ð,Ü(Ø  ,¸4ÈTõô !ð%óð ð	ð -ð )ð	 #r^   c                ój   — | j                   �'|j                  | j                  | j                   «       yy)zset the meta dataN)r1  r¥  r/  )ré   r§  s     r\   r¥  zIndexCol.write_metadataÌ  s)   € à�=‰=Ð$Ø×"Ñ" 4§:¡:¨t¯}©}Õ=ð %r^   )NNNNNNNNNNNNNN)rc   ra   r/  r  rÿ  r   r  r  )r0  r  rÿ  r   ©rN  Úobjectrÿ  rƒ   r  )r�  ú
np.ndarrayr[   ra   r¤   ra   rÿ  z3tuple[np.ndarray, np.ndarray] | tuple[Index, Index]r$  rY   r  )r§  ÚAppendableTabler¥   rƒ   rÿ  r   )r¥   rƒ   rÿ  r   )r§  rÇ  rÿ  r   )%r  r  r  r  r'  r  r(  r)  r°  rë   r  r4  r7  r;  r>  r2  r  rS  rU  rµ  r‹  rŽ  r†   r“  r–  r™  r"  r�  rŸ  r¨  r¢  r£  rµ  r¹  r¦  r¤  r¥  rÜ   r^   r\   r&  r&  =
  s¯  … ñð !€O�TÓ Ø"Ð�tÓ"ð #Ð�dÓ"Ú:€Lð
 ØØØ ØØØØØØØØØØð!-+àð-+ð ð-+ð" 
ó#-+ð^ ò!ó ð!ð ò#ó ð#ð ò#ó ð#ð ò&ó ð&ó"ó
ó
ó&ð ò?ó ð?ðp.Ø ðp.Ø58ðp.ØBEðp.à	<óp.òdð ñ#ó ð#ð ñ&ó ð&ð ñ;ó ð;ð ñó ðó!ôTóóóó&ó0!ó>&óTóô&>r^   r&  c                  óB   — e Zd ZdZedd„«       Z	 	 	 	 	 	 	 	 dd„Zdd„Zy)	ÚGenericIndexColz:an index which is not represented in the data of the tablec                 ó   — y©NFrÜ   rî   s    r\   rµ  zGenericIndexCol.is_indexedÕ  ó   € àr^   c                ó†   — t        |t        j                  «      sJ t        |«      «       ‚t	        t        |«      «      }||fS )zÛ
        Convert the data from this selection to the appropriate pandas type.

        Parameters
        ----------
        values : np.ndarray
        nan_rep : str
        encoding : str
        errors : str
        )r`   rp  rq  r  r3   rl   )ré   r�  r¡   r[   r¤   rŸ   s         r\   r‹  zGenericIndexCol.convertÙ  s9   € ô ˜&¤"§*¡*Ô-Ð;¬t°F«|Ó;Ð-äœ3˜v›;Ó'ˆØ�eˆ|Ðr^   c                 ó   — y rY   rÜ   rî   s    r\   r¦  zGenericIndexCol.set_attrë  r   r^   Nr  )r�  rÆ  r[   ra   r¤   ra   rÿ  ztuple[Index, Index]r  )r  r  r  r  r  rµ  r‹  r¦  rÜ   r^   r\   rÉ  rÉ  Ò  sA   „ ÙDàòó ððØ ðØ58ðØBEðà	óô$r^   rÉ  c                  ó*  ‡ — e Zd ZdZdZdZddgZ	 	 	 	 	 	 	 	 	 	 	 	 d	 	 	 	 	 	 	 dˆ fd„Zedd„«       Z	dd„Z
dd„Zdd	„Zd
„ Zedd„«       Zed„ «       Zedd„«       Zedd„«       Zed„ «       Zed„ «       Zed„ «       Zed„ «       Zdd„Zdd„Zdd„Zˆ x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•  c                óV   •— t         ‰| �  |||||||||	|
|¬«       || _        || _        y )N)rc   r�  rŸ  r.  r0  r/  r+  r•  ru   rÏ   r1  )Úsuperrë   r[  r¹  )ré   rc   r�  rŸ  r.  r/  r0  r+  r•  ru   rÏ   r1  r[  r¹  Ú	__class__s                 €r\   rë   zDataCol.__init__   sH   ø€ ô  	‰ÑØØØØØØØØØØØð 	ô 	
ð ˆŒ
Øˆ�	r^   c                ó    — | j                   › d�S )NÚ_dtyperb   rî   s    r\   Ú
dtype_attrzDataCol.dtype_attr   s   € à—)‘)�˜FÐ#Ð#r^   c           
     ó  — t        t        t        | j                  | j                  | j
                  | j                  | j                  f«      «      }dj                  t        g d¢|d¬«      D ��cg c]  \  }}|› d|› �‘Œ c}}«      S c c}}w )NrB  )rc   r/  r[  rŸ  ÚshapeTrP  rC  )
rk   rD  rF   rc   r/  r[  rŸ  rØ  rE  r\  rF  s       r\   r  zDataCol.__repr__$  sƒ   € ÜÜÜ˜tŸy™y¨$¯*©*°d·j±jÀ$Ç)Á)ÈTÏZÉZÐXóó
ˆð
 �x‰xô #&Ú?ÀÈdô#÷á�C˜ð �%�r˜%˜Ò!óó
ð 	
ùórH  c                ó0   ‡ ‡— t        ˆˆ fd„dD «       «      S )rJ  c              3  óT   •K  — | ]  }t        ‰|d «      t        ‰|d «      k(  –— Œ! y ­wrY   rL  rM  s     €€r\   r€  z!DataCol.__eq__.<locals>.<genexpr>5  rO  rP  )rc   r/  r[  r0  rQ  rR  s   ``r\   rS  zDataCol.__eq__3  s   ù€ äô 
à6ô
ó 
ð 	
r^   c                ó€   — |€J ‚| j                   �J ‚t        |«      \  }}|| _        || _         t        |«      | _        y rY   )r[  Ú_get_data_and_dtype_namer¹  Ú_dtype_to_kindrŸ  )ré   r¹  Ú
dtype_names      r\   Úset_datazDataCol.set_data:  sG   € ØÐÐÐØ�z‰zÐ!Ð!Ð!ä3°DÓ9ÑˆˆjàˆŒ	ØˆŒ
Ü" :Ó.ˆ�	r^   c                ó   — | j                   S )zreturn the data©r¹  rî   s    r\   rŽ  zDataCol.take_dataD  s   € à�y‰yÐr^   c                ó  — |j                   }t        |t        «      r*t        |t        t        t
        f«      st        d|› d�«      ‚|j                  }|j                  }|j                  dk(  rd|j                  f}t        |t        «      r5|j                  }| j                  ||j                   j                  ¬«      }|S t        j                   |d«      st        |t        «      r| j#                  |«      }|S t        j                   |d«      r| j%                  |«      }|S t'        |«      r t)        «       j+                  ||d   ¬«      }|S t-        |«      r| j/                  ||«      }|S | j                  ||j                  ¬«      }|S )	zW
        Get an appropriately typed and shaped pytables.Col object for values.
        ú!Cannot store a column with dtype út in an HDF5 file. HDFStore supports NumPy dtypes, datetime64 with timezone, categorical, and string extension types.rg   ©rŸ  ra  Úmr   ©r4  rØ  )r[  r`   r*   r(   r)   r+   r¾   r4  rØ  r†  Úsizer9   r‚  Úget_atom_datarc   r   r|  Úget_atom_datetime64Úget_atom_timedelta64r$   rš   Ú
ComplexColr&   Úget_atom_string)râ  r�  r[  r4  rØ  r‚  Úatoms          r\   Ú	_get_atomzDataCol._get_atomH  s|  € ð
 —‘ˆô �eœ^Ô,´ZØÔ$¤o´{ÐCô6
ô &Ø3°E°7ð ;;ð ;óð ð
 —>‘>ˆà—‘ˆØ�;‰;˜!Òð ˜Ÿ™Ð$ˆEä�fœkÔ*Ø—L‘LˆEØ×$Ñ$ U°·±×1AÑ1AÐ$ÓBˆDð ˆô �_‰_˜U CÔ(¬J°u¼oÔ,NØ×*Ñ*¨5Ó1ˆDð ˆô �_‰_˜U CÔ(Ø×+Ñ+¨EÓ2ˆDð ˆô ˜eÔ$Ü“9×'Ñ'°ÀÀqÁÐ'ÓJˆDð ˆô ˜UÔ#Ø×&Ñ& u¨hÓ7ˆDð ˆð ×$Ñ$ U°·±Ð$Ó<ˆDàˆr^   c                ó>   — t        «       j                  ||d   ¬«      S )Nr   rç  ©rš   rœ  ©râ  rØ  r4  s      r\   rí  zDataCol.get_atom_stringp  s   € ä‹y×"Ñ"¨H¸EÀ!¹HÐ"ÓEÐEr^   c                ó¶   — |j                  d«      r|dd }d|› d�}n)|j                  d«      rd}n|j                  «       }|› d�}t        t        «       |«      S )z0return the PyTables column class for this columnÚuinté   NÚUIntrL   ÚperiodÚInt64Col)r°  Ú
capitalizer€   rš   )râ  rŸ  Úk4Úcol_nameÚkcaps        r\   Úget_atom_coltypezDataCol.get_atom_coltypet  s_   € ð �?‰?˜6Ô"Ø�a�b�ˆBØ˜b˜T �~‰HØ�_‰_˜XÔ&à!‰Hà—?‘?Ó$ˆDØ˜˜s�|ˆHä”w“y (Ó+Ð+r^   c                ó:   —  | j                  |¬«      |d   ¬«      S )Nrå  r   ©rØ  ©rý  ©râ  rØ  rŸ  s      r\   ré  zDataCol.get_atom_dataƒ  s!   € à.ˆs×#Ñ#¨Ð#Ó.°U¸1±XÔ>Ð>r^   c                ó<   — t        «       j                  |d   ¬«      S ©Nr   rÿ  ©rš   rø  ©râ  rØ  s     r\   rê  zDataCol.get_atom_datetime64‡  ó   € ä‹y×!Ñ!¨¨a©Ð!Ó1Ð1r^   c                ó<   — t        «       j                  |d   ¬«      S r  r  r  s     r\   rë  zDataCol.get_atom_timedelta64‹  r  r^   c                ó0   — t        | j                  dd «      S ©NrØ  )r€   r¹  rî   s    r\   rØ  zDataCol.shape�  s   € ä�t—y‘y '¨4Ó0Ð0r^   c                ó   — | j                   S r˜  rá  rî   s    r\   r™  zDataCol.cvalues“  s   € ð �y‰yÐr^   c                ó  — |r…t        | j                  | j                  d«      }|�#|t        | j                  «      k7  rt        d«      ‚t        | j                  | j                  d«      }|�|| j                  k7  rt        d«      ‚yyy)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!)r€   r†   r7  rj   r�  r„   rÖ  r[  )ré   r¥   Úexisting_fieldsÚexisting_dtypes       r\   r£  zDataCol.validate_attr˜  s‚   € áÜ% d§j¡j°$·.±.À$ÓGˆOØÐ*¨Ä$ÀtÇ{Á{ÓBSÒ/SÜ Ð!WÓXÐXä$ T§Z¡Z°·±À$ÓGˆNØÐ)¨nÀÇ
Á
Ò.JÜ ØVóð ð /KÐ)ð r^   c           	     óº  — t        |t        j                  «      sJ t        |«      «       ‚|j                  j
                  �.|| j                     }|j                  d   s|j                  «       }| j                  €J ‚| j                  €t        |«      \  }}t        |«      }n|}| j                  }| j                  }t        |t        j                  «      sJ ‚| j                  }| j                  }	| j                  }
| j                   }|€J ‚|}|j#                  d«      r|dk(  rd}t%        |||«      }�nî|j#                  d«      r7|dk(  rt        j&                  |d¬«      }�n¿t        j&                  ||¬«      }�n¦|j#                  d«      rQt)        j*                  |«      }t-        j.                  t        j&                  |d¬«      j1                  «       |¬«      }�nD|d	k(  r?	 t        j&                  |D �cg c]  }t3        j4                  |«      ‘Œ c}t6        ¬«      }�n |d
k(  rç|	}|j1                  «       }|€t=        g t        j>                  ¬«      }n�tA        |«      }|jC                  «       r‚t        jD                  tG        |«      d|j                  ¬«      }t        jH                  | jK                  «       |j                  ¬«      || <   ||    }t        jL                  |dk  |||   «      }tO        jP                  |||
d¬«      }n	 |jS                  |d¬«      }|dk(  r.| jV                  r| jX                  }n|�|nd}t[        ||||¬«      }| j\                  |fS c c}w # t8        $ rE t        j&                  |D �cg c]  }t3        j:                  |«      ‘Œ nc c}w c}t6        ¬«      }Y Œ“w xY w# tT        $ r |jS                  dd¬«      }Y Œµw xY w)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
        ÚALIGNEDÚ
datetime64údatetime64[ns]rb  rc  rZ  r÷  rd  r   rY  r\  r   Fr]  ©rº  ÚOr`  r  ©r¡   r[   r¤   )/r`   rp  rq  r  r[  rr  r/  Úflagsrº  r.  rÜ  rÝ  rŸ  rÏ   r1  r•  r+  r°  Ú_set_tzÚasarrayr+   Úconstruct_from_stringr;   rz  rs  r   ÚfromordinalrÅ  r„   Úfromtimestampr0   rt  r8   ru  rv  rl   rw  rx  rm   r9   ry  Úastyper…   r)  r¡   Ú_unconvert_string_arrayr�  )ré   r�  r¡   r[   r¤   Ú	convertedrÞ  rŸ  rÏ   r1  r•  r+  r[  Úpdtyper”  r^  r‚  rƒ  r„  Úcol_nan_reps                       r\   r‹  zDataCol.convert¥  sk  € ô  ˜&¤"§*¡*Ô-Ð;¬t°F«|Ó;Ð-ð �<‰<×ÑÐ*Ø˜DŸJ™JÑ'ˆFØ—<‘< 	Ò*ð  Ÿ™›�à�x‰xÐ#Ð#Ð#Ø�:‰:Ðô %=¸VÓ$DÑ!ˆI�zÜ! *Ó-‰DàˆIØŸ™ˆJØ—9‘9ˆDä˜)¤R§Z¡ZÔ0Ð0Ð0ð �y‰yˆØ—=‘=ˆØ—,‘,ˆØ�W‰WˆàÐ%Ð%Ð%àˆð ×Ñ˜LÔ)à˜Ò$Ø(�Ü 	¨2¨uÓ5ŠIà×Ñ˜mÔ,Ø˜Ò%äŸJ™J y¸ÔA’	äŸJ™J y¸Ô>’	Ø×Ñ˜hÔ'ô !×6Ñ6°uÓ=ˆFÜ#×/Ñ/Ü—
‘
˜9¨DÔ1×7Ñ7Ó9ÀôŠIð �fŠ_ðÜŸJ™JØ2;Ö<¨Q”T×%Ñ% aÕ(Ò<ÄFô’	ð �ZÒà!ˆJØ—O‘OÓ%ˆEð
 Ð!ô
 # 2¬R¯Z©ZÔ8‘
ä˜JÓ'�Ø—8‘8”:ô ŸG™G¤C¨
£O°R¸u¿{¹{ÔK�EÜ#%§9¡9¨t¨e¯[©[«]À%Ç+Á+Ô#N�E˜4˜%‘LØ!+¨T¨EÑ!2�JÜŸH™H U¨Q¡Y°°u¸U±|ÓD�Eä#×.Ñ.Ø *°gÈô‰Ið
>Ø%×,Ñ,¨U¸Ð,Ó?�	ð
 �8ÒØ×$Ò$ð #Ÿl™l‘ð *1Ð)<™gÀ%�Ü/ØØ#Ø!Øô	ˆIð �{‰{˜IÐ%Ð%ùòu =øäò ÜŸJ™JØ4=Ö>¨q”T×'Ñ'¨Õ*Ñ>ùÔ>Äfô’	ðûôJ ò >Ø%×,Ñ,¨S°uÐ,Ó=’	ð>úsB   Ç&M* Ç9M%ÈM* ÌN; Í%M* Í*N8ÎN#
Î"N8Î7N8Î;OÏOc                ó’  — t        | j                  | j                  | j                  «       t        | j                  | j                  | j
                  «       | j                  €J ‚t        | j                  | j                  | j                  «       | j                  �,t        | j                  | j                  | j                  «       yy)zset the data for this columnN)
rŠ   r†   r7  r�  r;  rÏ   r[  rÖ  r¡   r>  rî   s    r\   r¦  zDataCol.set_attr)  sƒ   € ä˜TŸZ™Z¨¯©¸¿¹ÔEÜ˜TŸZ™Z¨¯©¸¿¹ÔCØ�z‰zÐ%Ð%Ð%Ü˜TŸZ™Z¨¯©¸$¿*¹*ÔEØ�<‰<Ð#ä  §¡¨T×->Ñ->ÀÇÁÕMð $r^   )NNNNNNNNNNNN)rc   ra   r/  r  r[  zDtypeArg | Nonerÿ  r   r  rÄ  )r¹  rP   rÿ  r   )r�  rP   rÿ  rL   )rŸ  ra   rÿ  z	type[Col]©rŸ  ra   rÿ  rL   r  )r�  rÆ  r[   ra   r¤   ra   )r  r  r  r  r'  r(  r°  rë   r  rÖ  r  rS  rß  rŽ  Úclassmethodrï  rí  rý  ré  rê  rë  rØ  r™  r£  r‹  r¦  Ú__classcell__©rÓ  s   @r\   rÐ  rÐ  ï  sN  ø„ ñ
ð €OØÐØ˜)Ð$€Lð
 ØØØ ØØØØØØØ!%Øðàðð ðð ðð 
õð@ ò$ó ð$ó
ó
ó/òð ò%ó ð%ðN ñFó ðFð ò,ó ð,ð ò?ó ð?ð ñ2ó ð2ð ñ2ó ð2ð ñ1ó ð1ð ñó ðóóB&÷HNr^   rÐ  c                  ó^   — e Zd ZdZdZd	d„Zed„ «       Zed
d„«       Zed„ «       Z	ed„ «       Z
y)ÚDataIndexableColz+represent a data column that can be indexedTc                ój   — t        t        | j                  «      j                  «      st	        d«      ‚y )Nú-cannot have non-object label DataIndexableCol)r&   r0   r�  r[  r„   rî   s    r\   rŸ  zDataIndexableCol.validate_names9  s*   € Üœu T§[¡[Ó1×7Ñ7Ô8äÐLÓMÐMð 9r^   c                ó6   — t        «       j                  |¬«      S )N)r4  rñ  rò  s      r\   rí  z DataIndexableCol.get_atom_string>  s   € ä‹y×"Ñ"¨HÐ"Ó5Ð5r^   c                ó0   —  | j                  |¬«      «       S )Nrå  r   r  s      r\   ré  zDataIndexableCol.get_atom_dataB  s   € à.ˆs×#Ñ#¨Ð#Ó.Ó0Ð0r^   c                ó2   — t        «       j                  «       S rY   r  r  s     r\   rê  z$DataIndexableCol.get_atom_datetime64F  ó   € ä‹y×!Ñ!Ó#Ð#r^   c                ó2   — t        «       j                  «       S rY   r  r  s     r\   rë  z%DataIndexableCol.get_atom_timedelta64J  r,  r^   Nr  r!  )r  r  r  r  r(  rŸ  r"  rí  ré  rê  rë  rÜ   r^   r\   r&  r&  4  sa   „ Ù5àÐóNð
 ñ6ó ð6ð ò1ó ð1ð ñ$ó ð$ð ñ$ó ñ$r^   r&  c                  ó   — e Zd ZdZy)ÚGenericDataIndexableColz(represent a generic pytables data columnN)r  r  r  r  rÜ   r^   r\   r/  r/  O  s   „ Ú2r^   r/  c                  óž  — 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<   	 	 d&	 	 	 	 	 	 	 	 	 d'd„Zed„ «       Z	d(d„Z
d)d„Zd*d„Zed„ «       Zed„ «       Zed„ «       Zed„ «       Zed+d„«       Zed,d„«       Zed„ «       Zd)d„Zd)d„Zed„ «       Zed,d„«       Zed„ «       Zd-d „Zd,d!„Z	 	 	 	 d.	 	 	 	 	 d/d#„Zd)d$„Z	 d0	 	 	 	 	 d1d%„Zy")2Ú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.
    ra   Úpandas_kindrt   Úformat_typeútype[DataFrame | Series]Úobj_typer  r†  r±   rÕ   Frƒ   r]  c                óò   — t        |t        «      sJ t        |«      «       ‚t        €J ‚t        |t        j                  «      sJ t        |«      «       ‚|| _        || _        t        |«      | _        || _	        y rY   )
r`   r±   r  r~   rN   rÕ   rÓ   r]   r[   r¤   )ré   rÕ   rÓ   r[   r¤   s        r\   rë   zFixed.__init__g  sg   € ô ˜&¤(Ô+Ð9¬T°&«\Ó9Ð+ÜÐ%Ð%Ð%Ü˜%¤§¡Ô1Ð>´4¸³;Ó>Ð1ØˆŒØˆŒ
Ü(¨Ó2ˆŒØˆ�r^   c                óD   — t        | j                  j                  dd «      S )Nr£  )r€   rÓ   r§  rî   s    r\   r£  zFixed.pandas_typev  s   € ä�t—z‘z×*Ñ*¨M¸4Ó@Ð@r^   c                ó  — | j                  «        | j                  }|�Wt        |t        t        f«      r.dj                  |D �cg c]  }t        |«      ‘Œ c}«      }d|› d�}| j                  d›d|› d�S | j                  S c c}w )ú(return a pretty representation of myselfrB  ú[rQ  ú12.12z	 (shape->ú))rA  rØ  r`   rj   rk   rE  rF   r£  )ré   r=  rc  Újshapes       r\   r  zFixed.__repr__z  s   € à�‰ÔØ�J‰JˆØˆ=Ü˜!œd¤E˜]Ô+ØŸ™¸AÖ">°q¤<°¥?Ò">Ó?�Ø˜�x˜q�M�Ø×&Ñ& uÐ-¨Y°q°c¸Ð;Ð;Ø×ÑÐùò #?s   ÁBc                óL   — t        | j                  «      | j                  _        y)zset my pandas typeN)ra   r2  r†   r£  rî   s    r\   rê  zFixed.set_object_info…  s   € ä!$ T×%5Ñ%5Ó!6ˆ�
‰
Õr^   c                ó0   — t        j                   | «      }|S rY   r  )ré   Únew_selfs     r\   rº  z
Fixed.copy‰  s   € Ü—9‘9˜T“?ˆØˆr^   c                ó   — | j                   S rY   )r�   rî   s    r\   rØ  zFixed.shape�  rõ   r^   c                ó.   — | j                   j                  S rY   ©rÓ   rÅ   rî   s    r\   r^  zFixed.pathname‘  r”  r^   c                ó.   — | j                   j                  S rY   )rÕ   r×   rî   s    r\   r×   zFixed._handle•  s   € à�{‰{×"Ñ"Ð"r^   c                ó.   — | j                   j                  S rY   )rÕ   rç   rî   s    r\   rç   zFixed._filters™  s   € à�{‰{×#Ñ#Ð#r^   c                ó.   — | j                   j                  S rY   )rÕ   rä   rî   s    r\   rä   zFixed._complevel�  s   € à�{‰{×%Ñ%Ð%r^   c                ó.   — | j                   j                  S rY   )rÕ   ræ   rî   s    r\   ræ   zFixed._fletcher32¡  s   € à�{‰{×&Ñ&Ð&r^   c                ó.   — | j                   j                  S rY   )rÓ   r§  rî   s    r\   r†   zFixed.attrs¥  r�  r^   c                 ó   — y©zset our object attributesNrÜ   rî   s    r\   Ú	set_attrszFixed.set_attrs©  ó   � r^   c                 ó   — y)zget our object attributesNrÜ   rî   s    r\   Ú	get_attrszFixed.get_attrs¬  rL  r^   c                ó   — | j                   S )zreturn my storable©rÓ   rî   s    r\   ÚstorablezFixed.storable¯  s   € ð �z‰zÐr^   c                 ó   — yrË  rÜ   rî   s    r\   ré  zFixed.is_exists´  rÌ  r^   c                ó0   — t        | j                  dd «      S )Nr�   )r€   rQ  rî   s    r\   r�   zFixed.nrows¸  s   € ä�t—}‘} g¨tÓ4Ð4r^   c                ó
   — |€yy)z%validate against an existing storableNTrÜ   rR  s     r\   r_  zFixed.validate¼  s   € àˆ=ØØr^   c                óB   — | j                   }|€y| j                  «        y)zr
        infer the axes of my storer
        return a boolean indicating if we have a valid storer or not
        FT)rQ  rN  )ré   r=  s     r\   rA  zFixed.infer_axesÂ  s"   € ð
 �M‰MˆØˆ9ØØ�‰ÔØr^   Nc                ó   — t        d«      ‚)Nz>cannot read on an abstract storer: subclasses should implement©r¾   ©ré   rm   r¸   rŽ   r�   s        r\   r9  z
Fixed.readÍ  s   € ô "ØLó
ð 	
r^   c                ó   — t        d«      ‚)Nz?cannot write on an abstract storer: subclasses should implementrW  ©ré   ræ  rÈ   s      r\   rë  zFixed.writeØ  s   € Ü!ØMó
ð 	
r^   c                ó–   — t        j                  |||«      r(| j                  j                  | j                  d¬«       yt        d«      ‚)zs
        support fully deleting the node in its entirety (only) - where
        specification must be None
        Trn  Nz#cannot delete on an abstract storer)rs  rt  r×   rï  rÓ   r…   )ré   rm   rŽ   r�   s       r\   ru  zFixed.deleteÝ  s>   € ô �<‰<˜˜u dÔ+Ø�L‰L×$Ñ$ T§Z¡Z¸4Ð$Ô@ØäÐ=Ó>Ð>r^   )rW   r”   )
rÕ   r±   rÓ   rN   r[   r  r¤   ra   rÿ  r   r  r  )rÿ  r1  r  r  )rÿ  zLiteral[True] | None©NNNN)rŽ   rþ  r�   rþ  rÿ  zSeries | DataFramer	  ©rŽ   rþ  r�   rþ  rÿ  rþ  )r  r  r  r  r  r3  r]  rë   r  r£  r  rê  rº  rØ  r^  r×   rç   rä   ræ   r†   rK  rN  rQ  ré  r�   r_  rA  r9  rë  ru  rÜ   r^   r\   r1  r1  S  sÌ  … ñ
ð ÓØ€K�ÓØ&Ó&Ø
ƒIØÓØ€HˆdÓð  'Øðàðð ðð ð	ð
 ðð 
óð ñAó ðAó	 ó7óð ñó ðð ñ&ó ð&ð ñ#ó ð#ð ñ$ó ð$ð ò&ó ð&ð ò'ó ð'ð ñ#ó ð#ó(ó(ð ñó ðð òó ðð ñ5ó ð5óó	ð ØØ Øð	
ð ð		
ð
 ð	
ð 
ó	
ó
ð HLð?Ø!+ð?Ø:Dð?à	ô?r^   r1  c                  óV  — e Zd ZU dZedediZej                  «       D � ��ci c]  \  }}||“Œ
 c}}} Zg Z	de
d<   dd„Zd„ Zd„ Zdd	„Zedd
„«       Zdd„Zdd„Zdd„Zddd„Z	 d	 	 	 	 	 	 	 dd„Zdd„Zdd„Z	 d	 	 	 	 	 	 	 dd„Z	 d	 	 	 	 	 	 	 d d„Zd!d„Z	 d"	 	 	 	 	 	 	 d#d„Zyc c}}} w )$ÚGenericFixedza generified fixed versionÚdatetimer÷  r  Ú
attributesc                ó:   — | j                   j                  |d«      S )Nr»  )Ú_index_type_mapr÷   )ré   râ  s     r\   Ú_class_to_aliaszGenericFixed._class_to_aliasó  s   € Ø×#Ñ#×'Ñ'¨¨RÓ0Ð0r^   c                óf   — t        |t        «      r|S | j                  j                  |t        «      S rY   )r`   r  Ú_reverse_index_mapr÷   r0   )ré   Úaliass     r\   Ú_alias_to_classzGenericFixed._alias_to_classö  s*   € Ü�eœTÔ"àˆLØ×&Ñ&×*Ñ*¨5´%Ó8Ð8r^   c                ód  — | j                  t        |dd«      «      }i }|t        k(  rdd„}|}n|t        k(  rdd„}|}n|}d|d<   d|v rN|d   �I|d   }t	        |t
        «      r!t        j                  dt        «       ¬	«       d }||d<   |t        u rt        }d
|v r|d
   |d
<   |t        u sJ ‚||fS )NÚindex_classr»  c                óÜ   — t        j                  | j                  | j                  ¬«      }t	        j                  |d ¬«      }||_        |� |j                  d«      j                  |«      }|S )NrZ  rb   ro  )r:   rz  r�  r[  r/   Ú_freqr€  r�  )r�  r*  r+  ÚdtarÌ   s        r\   rv   z*GenericFixed._get_index_factory.<locals>.f  sZ   € ä#×/Ñ/°·±ÀVÇ\Á\ÔR�Ü&×2Ñ2°3¸TÔB�Ø#�”Ø�>Ø#×/Ñ/°Ó6×AÑAÀ"ÓE�FØ�r^   c                ót   — t        |«      }t        j                  | |¬«      }t        j                  |d ¬«      S )NrZ  rb   )r+   r;   rz  r2   )r�  r*  r+  r[  Úparrs        r\   rv   z*GenericFixed._get_index_factory.<locals>.f  s1   € Ü# DÓ)�Ü"×.Ñ.¨v¸UÔC�Ü"×.Ñ.¨t¸$Ô?Ð?r^   Frº  r*  z{Could not decode freq attribute on stored index; the file was likely written by an older pandas version. Setting freq=None.rÚ   r+  r  )rh  r€   r/   r2   r`   Úbytesrà   rá   r!   r0   r6   )ré   r†   rj  rÈ   rv   rˆ  Ú	freq_attrs          r\   Ú_get_index_factoryzGenericFixed._get_index_factoryü  sâ   € Ø×*Ñ*¬7°5¸-ÈÓ+LÓMˆð ˆØœ-Ò'óð ‰GØœKÒ'ó@ð
 ‰Gà!ˆGØ"ˆF�6‰Nà�U‰?˜u V™}Ð8ð ˜f™ˆIÜ˜)¤UÔ+ô —‘ð2ô  0Ó1õ	ð !�	Ø&ˆF�6‰NØœeÑ#ä(�à�5‰=Ø  ™;ˆF�4‰LØ¤-Ñ/Ð/Ð/à˜ˆÐr^   c                ó8   — |�t        d«      ‚|�t        d«      ‚y)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¸   rm   s      r\   Úvalidate_readzGenericFixed.validate_read8  s=   € ð ÐÜðTóð ð ÐÜðYóð ð r^   c                 ó   — y)NTrÜ   rî   s    r\   ré  zGenericFixed.is_existsG  s   € àr^   c                óp   — | j                   | j                  _         | j                  | j                  _        yrJ  )r[   r†   r¤   rî   s    r\   rK  zGenericFixed.set_attrsK  s"   € à"Ÿm™mˆ�
‰
ÔØ ŸK™Kˆ�
‰
Õr^   c           
     óì   — t        t        | j                  dd«      «      | _        t        | j                  dd«      | _        | j
                  D ]$  }t        | |t        | j                  |d«      «       Œ& y)úretrieve our attributesr[   Nr¤   r”   )r]   r€   r†   r[   r¤   ra  r‚   )ré   r  s     r\   rN  zGenericFixed.get_attrsP  s[   € ä(¬°·±¸ZÈÓ)NÓOˆŒÜ˜dŸj™j¨(°HÓ=ˆŒØ—‘ò 	;ˆAÜ�D˜!œW T§Z¡Z°°DÓ9Õ:ñ	;r^   c                ó$   — | j                  «        y rY   )rK  rZ  s      r\   rë  zGenericFixed.writeW  s   € Ø�‰Õr^   Nc                ó  — ddl }t        | j                  |«      }|j                  }t        |dd«      }t	        ||j
                  «      r'|d   || }t        |dd«      }	|	��t        ||	¬«      }�n
t        |dd«      }	t        |dd«      }
|
�t        j                  |
|	¬«      }n||| }|	r3|	j                  d«      r"|	dk(  rd	}	t        |d
d«      }t        |||	«      }nœ|	rF|	j                  d«      r5|	dk(  rt        j                  |d¬«      }nlt        j                  ||	¬«      }nT|	rR|	j                  d«      rAt        j                  |	«      }t        j                  t        j                  |d¬«      |¬«      }|r|j                   S |S )z2read an array for the specified node (off of groupr   NÚ
transposedFÚ
value_typerZ  rØ  r  r  r+  rb  rc  r÷  rd  )r•   r€   rÓ   r§  r`   ÚVLArrayÚpd_arrayrp  rå  r°  r  r  r+   r  r;   rz  ÚT)ré   r¨   rŽ   r�   r•   r  r†   r|  Úretr[  rØ  r+  r  s                r\   Ú
read_arrayzGenericFixed.read_arrayZ  sj  € ãä�t—z‘z 3Ó'ˆØ—‘ˆä˜U L°%Ó8ˆ
ä�d˜FŸN™NÔ+Ø�q‘'˜% Ð%ˆCÜ˜E <°Ó6ˆEØÑ Ü˜s¨%Ô0’ä˜E <°Ó6ˆEÜ˜E 7¨DÓ1ˆEàÐ ä—h‘h˜u¨EÔ2‘à˜5 Ð&�á˜×)Ñ)¨,Ô7à˜LÒ(Ø,�EÜ˜U D¨$Ó/�Ü˜c 2 uÓ-‘á˜5×+Ñ+¨MÔ:Ø˜MÒ)ô Ÿ*™* S°Ô9‘CäŸ*™* S°Ô6‘Cá˜5×+Ñ+¨HÔ5Ü$×:Ñ:¸5ÓA�Ü!×-Ñ-¬b¯j©j¸ÀDÔ.IÐQWÔX�áØ—5‘5ˆLàˆJr^   c                óä   — t        | j                  |› d�«      }|dk(  r| j                  |||¬«      S |dk(  r,t        | j                  |«      }| j	                  |||¬«      }|S t        d|› �«      ‚)NÚ_varietyÚmulti©rŽ   r�   Úregularzunrecognized index variety: )r€   r†   Úread_multi_indexrÓ   Úread_index_noder…   )ré   r¨   rŽ   r�   Úvarietyr  rŸ   s          r\   Ú
read_indexzGenericFixed.read_indexŠ  s‚   € ô ˜$Ÿ*™*¨¨¨XÐ&6Ó7ˆà�gÒØ×(Ñ(¨°EÀÐ(ÓEÐEØ˜	Ò!Ü˜4Ÿ:™: sÓ+ˆDØ×(Ñ(¨°UÀÐ(ÓFˆEØˆLäÐ:¸7¸)ÐDÓEÐEr^   c                óx  — t        |t        «      r-t        | j                  |› d�d«       | j	                  ||«       y t        |t
        «      rät        | j                  |› d�d«       |j                  }| j                  |t        j                  |j                  «      «       | j                  |› d�t        |j                  «      «       t        | j                  |«      }d|j                   _        |j$                  |j                   _        t'        |j(                  «      |j                   _        y t        | j                  |› d�d«       t+        d|| j,                  | j.                  «      }| j                  ||j0                  «       t        | j                  |«      }|j"                  |j                   _        |j$                  |j                   _        |j"                  dk(  r|j2                  xs d|j                   _        t        |t4        t6        f«      r)| j9                  t;        |«      «      |j                   _        t        |t4        t6        t>        f«      r|j@                  |j                   _         t        |t4        «      r2|jB                  �%tE        |jB                  «      |j                   _!        y y y )	Nr„  r…  r‡  Ú_categoriesrY  rŸ   r`  r»  )#r`   r1   r‚   r†   Úwrite_multi_indexr-   Ú_valuesÚwrite_arrayrp  r  r‚  Úwrite_indexr0   r^  r€   rÓ   r§  rŸ  rc   rƒ   r•  Ú_convert_indexr[   r¤   r�  r¡   r/   r2   rd  r  rj  r6   r*  r+  Ú_get_tz)ré   r¨   rŸ   r…  r  r  s         r\   r‘  zGenericFixed.write_index˜  sò  € Ü�eœZÔ(Ü�D—J‘J 3 % xÐ 0°'Ô:Ø×"Ñ" 3¨Õ.Ü˜Ô/Ô0ô
 �D—J‘J 3 % xÐ 0°)Ô<Ø—-‘-ˆCØ×Ñ˜S¤"§*¡*¨S¯Y©YÓ"7Ô8Ø×Ñ ˜u KÐ0´%¸¿¹Ó2GÔHÜ˜4Ÿ:™: sÓ+ˆDØ!+ˆD�M‰MÔØ!&§¡ˆD�M‰MÔÜ$(¨¯©Ó$5ˆD�M‰MÕ!ä�D—J‘J 3 % xÐ 0°)Ô<Ü& w°°t·}±}ÀdÇkÁkÓRˆIà×Ñ˜S )×"2Ñ"2Ô3ä˜4Ÿ:™: sÓ+ˆDØ!*§¡ˆD�M‰MÔØ!&§¡ˆD�M‰MÔà�~‰~ Ò)à(1×(9Ñ(9Ò(?¸R�—‘Ô%ä˜%¤-´Ð!=Ô>Ø,0×,@Ñ,@ÄÀeÃÓ,M�—‘Ô)ä˜%¤-´¼nÐ!MÔNØ%*§Z¡Z�—‘Ô"ä˜%¤Ô/°E·H±HÐ4HÜ#*¨5¯8©8Ó#4�—‘Õ ð 5IÐ/r^   c                ó&  — t        | j                  |› d�|j                  «       t        t	        |j
                  |j                  |j                  d¬«      «      D �]3  \  }\  }}}t        |j                  t        «      r%t        |j                  t        «      st        d«      ‚|› d|› �}t        ||| j                  | j                  «      }| j!                  ||j"                  «       t%        | j&                  |«      }	|j(                  |	j*                  _        ||	j*                  _        |j(                  dk(  r|j.                  xs d|	j*                  _        t        |	j*                  |› d|› �|«       |› d	|› �}
| j!                  |
|«       �Œ6 y )
NÚ_nlevelsTrP  z=Saving a MultiIndex with an extension dtype is not supported.Ú_levelr`  r»  Ú_nameÚ_label)r‚   r†   rØ  Ú	enumerater\  Úlevelsr‚  Únamesr`   r[  r*   r5   r¾   r’  r[   r¤   r�  r�  r€   rÓ   rŸ  r§  rc   r¡   )ré   r¨   rŸ   ÚiÚlevÚlevel_codesrc   Ú	level_keyÚ
conv_levelr  Ú	label_keys              r\   rŽ  zGenericFixed.write_multi_indexÀ  sW  € Ü�—
‘
˜s˜e 8Ð,¨e¯m©mÔ<ä+4Ü�—‘˜eŸk™k¨5¯;©;¸tÔDó,
ó 	5Ñ'ˆAÑ'��[ $ô ˜#Ÿ)™)¤^Ô4¼ZØ—	‘	œ;ô>ô *ØSóð ð ˜%˜v a SÐ)ˆIÜ'¨	°3¸¿¹ÀtÇ{Á{ÓSˆJØ×Ñ˜Y¨
×(9Ñ(9Ô:Ü˜4Ÿ:™: yÓ1ˆDØ!+§¡ˆD�M‰MÔØ!%ˆD�M‰MÔà�‰ (Ò*à(2×(:Ñ(:Ò(@¸b�—‘Ô%ô �D—M‘M c U¨%°¨vÐ#6¸Ô=ð ˜%˜v a SÐ)ˆIØ×Ñ˜Y¨Ö4ñ5	5r^   c                óŠ  — t        | j                  |› d�«      }g }g }g }t        |«      D ]ˆ  }|› d|› �}	t        | j                  |	«      }
| j	                  |
«      }|j                  |«       |j                  |j                  «       |› d|› �}| j                  |||¬«      }|j                  |«       ŒŠ t        |||d¬«      S )Nr•  r–  r˜  r†  T)rš  r‚  r›  rU  )	r€   r†   r…  rÓ   r‰  r¥   rc   r‚  r1   )ré   r¨   rŽ   r�   rØ  rš  r‚  r›  rœ  rŸ  r  r�  r¡  rž  s                 r\   rˆ  zGenericFixed.read_multi_indexß  sÓ   € ô ˜$Ÿ*™*¨¨¨XÐ&6Ó7ˆàˆØˆØ "ˆÜ�w“ò 	&ˆAØ˜%˜v a SÐ)ˆIÜ˜4Ÿ:™: yÓ1ˆDð ×&Ñ& tÓ,ˆCØ�M‰M˜#ÔØ�L‰L˜Ÿ™Ô"à˜%˜v a SÐ)ˆIØŸ/™/¨)¸5Àt˜/ÓLˆKØ�L‰L˜Õ%ð	&ô Ø ¨eÀdô
ð 	
r^   c           
     ó  — ||| }d|j                   v rkt        j                  |j                   j                  «      dk(  r?t        j                  |j                   j                  |j                   j
                  ¬«      }|j                   j                  }d }d|j                   v rt        |j                   j                  «      }|dk(  rn| j                  |j                  › d�«      }t        t        |j                   dd«      «      }t        j                  |||d¬	«      }	t        j                   |	|¬
«      S |j                   }
| j#                  |
«      \  }}|dk(  rt%        |
«      nd }|dk(  rt'        «       rd|d<   |dv r1 |t)        ||| j*                  | j,                  ¬«      fdt.        i|¤Ž}n,	  |t)        ||| j*                  | j,                  |¬«      fi |¤Ž}||_        |S # t0        $ rŽ}| j,                  dk(  rtt'        «       rjt3        |«      j5                  d«      rPt6        rJt9        dt        j:                  ¬«      |d<    |t)        ||| j*                  | j,                  |¬«      fi |¤Ž}n‚ Y d }~Œ›d }~ww xY w)NrØ  r   rZ  rc   rY  r�  r•  Fr]  rb   r`  ra   r[  )r   rÅ  rÏ  )r[   r¤   r¡   ri  rj  rk  rl  )r§  rp  ÚprodrØ  rå  r}  rŸ  rd   rc   r‹  rÒ   rƒ   r€   r9   ry  r-   rz  rr  Ú_read_index_nan_repr   Ú_unconvert_indexr[   r¤   rÅ  r~  ra   rù  r   r5   r  )ré   r  rŽ   r�   r¹  rŸ  rc   r^  r•  r…  r†   rˆ  rÈ   r¡   rŸ   rv  s                   r\   r‰  zGenericFixed.read_index_nodeø  sS  € ð �E˜$Ðˆð �d—m‘mÑ#¬¯©°·±×0CÑ0CÓ(DÈÒ(IÜ—8‘8˜DŸM™M×/Ñ/°t·}±}×7OÑ7OÔPˆDØ�}‰}×!Ñ!ˆØˆà�T—]‘]Ñ"Ü˜tŸ}™}×1Ñ1Ó2ˆDà�:Òð Ÿ™¨D¯L©L¨>¸Ð)EÓFˆJÜœ7 4§=¡=°)¸UÓCÓDˆGÜ×(Ñ(Ø °WÀuôˆCô $×/Ñ/°¸$Ô?Ð?à—‘ˆØ×1Ñ1°%Ó8‰ˆ�à04¸Ò0@Ô% eÔ,Àdˆà�8ÒÔ 2Ô 4ð
 $ˆF�7‰OàÐ%Ñ%ÙÜ Ø˜$¨¯©¸t¿{¹{ôñô ð	ð
 ñ‰EðÙÜ$ØØØ!%§¡Ø#Ÿ{™{Ø 'ôñ	ð ñ	�ð> ˆŒ
àˆøô/ &ò à—K‘K ?Ò2Ü*Ô,Ü˜C›×)Ñ)Ð*BÔCÝ#ä&1¸(ÌRÏVÉVÔ&T�F˜7‘OÙ#Ü(Ø Ø Ø%)§]¡]Ø#'§;¡;Ø$+ôñ	ð !ñ	‘Eð ô ûðús   Æ3+G' Ç'	I>Ç0BI9É9I>c                ó@  — t        j                  d|j                  z  «      }| j                  j	                  | j
                  ||«       t        | j
                  |«      }t        |j                  «      |j                  _
        |j                  |j                  _        y)zwrite a 0-len array)rg   N)rp  rå  r†  r×   Úcreate_arrayrÓ   r€   ra   r[  r§  r}  rØ  )ré   r¨   r‡   Úarrr  s        r\   Úwrite_array_emptyzGenericFixed.write_array_emptyI  sj   € ô �h‰h�t˜eŸj™jÑ(Ó)ˆØ�‰×!Ñ! $§*¡*¨c°3Ô7Ü�t—z‘z 3Ó'ˆÜ#& u§{¡{Ó#3ˆ�‰Ô Ø#Ÿk™kˆ�‰Õr^   c                ó¦  — t        |d¬«      }|| j                  v r&| j                  j                  | j                  |«       |j                  dk(  }d}t        |j                  t        «      rt        d«      ‚|st        |d«      r|j                  }d}t        |t        «      r¤| j                  j                  | j                  |t        «       j                  «       | j                  ¬«      }|j!                  |j#                  «       «       t%        | j                  |«      }t'        |j                  «      |j(                  _        �nÓd }	| j                  �Et-        t.        «      5  t        «       j0                  j3                  |j                  «      }	d d d «       |	�[|sE| j                  j5                  | j                  ||	|j6                  | j                  ¬«      }
||
d d  �n7| j9                  ||«       �n#|j                  j:                  t<        j>                  k(  �rtA        jB                  |d¬«      }|rn¦|d	k(  rn tD        d
   d   r”|jF                  dk(  rU|�StI        d|«      }tK        |j6                  d   «      D �cg c]!  }tA        jL                  |d d …|f   d¬«       ‘Œ# }}||   }tN        |||fz  }tQ        jR                  |tT        tW        «       ¬«       | j                  j                  | j                  |t        «       j                  «       | j                  ¬«      }|j!                  |«       �nßtA        jX                  |j                  d«      rp| j                  j[                  | j                  ||j]                  d«      «       t'        |j                  «      t%        | j                  |«      j(                  _        �nOt        |j                  t^        «      r–| j                  j[                  | j                  ||j`                  «       t%        | j                  |«      }tc        |jd                  «      |j(                  _2        d|j                  jf                  › d�|j(                  _        �nŸtA        jX                  |j                  d«      rp| j                  j[                  | j                  ||j]                  d«      «       t'        |j                  «      t%        | j                  |«      j(                  _        �nt        |j                  th        «      rl| j                  j[                  | j                  ||j`                  «       t%        | j                  |«      }t'        |j                  «      |j(                  _        n‰|r| j9                  ||«       ntt        |j                  tj        «      r3t        |j                  th        «      st        d|j                  › d�«      ‚| j                  j[                  | j                  ||«       |t%        | j                  |«      j(                  _6        y # 1 sw Y   �Œ°xY wc c}w )NT)Úextract_numpyr   Fz^Cannot store a category dtype in an HDF5 dataset that uses format="fixed". Use format="table".r€  )rÝ   ©Úskipnar`  r®   Úperformance_warningsé   rÆ  rg   rÚ   ra  rd  údatetime64[rQ  ræ  rã  zˆ in an HDF5 file with format="fixed". HDFStore supports NumPy dtypes, datetime64 with timezone, categorical, and string extension types.)7rB   rÓ   r×   rï  rè  r`   r[  r(   r¾   rW  r€  r=   Úcreate_vlarrayrš   Ú
ObjectAtomrç   r¥   Úto_numpyr€   ra   r§  r}  r   r„   ÚAtomÚ
from_dtypeÚcreate_carrayrØ  rª  r  rp  Úobject_r   Úinfer_dtyperj  r†  r   r…  r   rs   rà   rá   r   r!   r|  r¨  r}  r)   Úasi8r“  r+  Úunitr+   r*   r|  )ré   r¨   ræ  r&  r‡   Úempty_arrayr|  Úvlarrr  rî  ÚcaÚinferred_typeÚblockÚjrƒ  r´  s                   r\   r�  zGenericFixed.write_arrayR  sÙ  € ô ˜c°Ô6ˆà�$—*‘*ÑØ�L‰L×$Ñ$ T§Z¡Z°Ô5ð —j‘j A‘oˆØˆ
ä�e—k‘kÔ#3Ô4Ü%ð/óð ñ Ü�u˜cÔ"àŸ™�Ø!�
ä�eœ_Ô-ð —L‘L×/Ñ/Ø—
‘
˜C¤£×!5Ñ!5Ó!7ÀÇÁð 0ó ˆEð �L‰L˜Ÿ™Ó)Ô*Ü˜4Ÿ:™: sÓ+ˆDÜ'*¨5¯;©;Ó'7ˆD�M‰MÖ$ð ˆDØ�}‰}Ð(ÜœjÓ)ñ Bä"›9Ÿ>™>×4Ñ4°U·[±[ÓA�D÷Bð Ðñ
 #ØŸ™×3Ñ3ØŸ
™
 C¨¨u¯{©{ÀDÇMÁMð 4ó �Bð "�B‘q’Eð ×*Ñ*¨3°Ö6à—‘×!Ñ!¤R§Z¡ZÓ/ô !$§¡°¸eÔ D�ÙØØ" hÒ.ØÜ˜F‘^Ð$:Ò;ð —z‘z Q’¨5Ð+<Ü $ \°5Ó 9˜ô &+¨5¯;©;°q©>Ó%:ö à !ô !$× 3Ñ 3°Eº!¸Q¸$±KÈÔ NÒNð ˜ð  ð !& d¡˜Ü(¨M¸3ÀÐ+FÑF�BÜ—M‘M "Ô&8ÔEUÓEWÕXàŸ™×3Ñ3Ø—J‘J ¤W£Y×%9Ñ%9Ó%;ÀTÇ]Á]ð 4ó �ð —‘˜UÖ#ä—‘ §¡¨cÔ2Ø—‘×)Ñ)¨$¯*©*°c¸5¿:¹:ÀdÓ;KÔLÜ?BÀ5Ç;Á;Ó?O”˜Ÿ
™
 CÓ(×1Ñ1Ö<Ü˜EŸK™K¬Ô9ð
 —‘×)Ñ)Ø—J‘JØØ—J‘Jôô ˜tŸz™z¨3Ó/�ä#*¨5¯8©8Ó#4�—‘Ô Ø-8¸¿¹×9IÑ9IÐ8JÈ!Ð+L�—‘Ö(Ü—‘ §¡¨cÔ2Ø—‘×)Ñ)¨$¯*©*°c¸5¿:¹:ÀdÓ;KÔLÜ?BÀ5Ç;Á;Ó?O”˜Ÿ
™
 CÓ(×1Ñ1Ö<Ü˜EŸK™K¬Ô5ð —‘×)Ñ)Ø—J‘JØØ—J‘Jôô
 ˜tŸz™z¨3Ó/�Ü+.¨u¯{©{Ó+;�—‘Õ(ÙØ×&Ñ& s¨EÕ2ô ˜eŸk™k¬>Ô:Ä:Ø—K‘K¤ôDô .Ø;¸E¿K¹K¸=ð I6ð 6óð ð —‘×)Ñ)¨$¯*©*°c¸5ÔAà7AŒ�—
‘
˜CÓ ×)Ñ)Õ4÷yBñ Büò@ s   Å%.YÊ&YÙYr  r  r  r  r
  )r¨   ra   rŽ   rþ  r�   rþ  rÿ  r0   )r¨   ra   rŸ   r0   rÿ  r   )r¨   ra   rŸ   r1   rÿ  r   )r¨   ra   rŽ   rþ  r�   rþ  rÿ  r1   )r  rN   rŽ   rþ  r�   rþ  rÿ  r0   )r¨   ra   r‡   rP   rÿ  r   rY   )r¨   ra   ræ  rO   r&  zIndex | Nonerÿ  r   )r  r  r  r  r/   r2   rc  r&  rf  ra  r  rd  rh  rr  ru  r  ré  rK  rN  rë  r‚  r‹  r‘  rŽ  rˆ  r‰  rª  r�  )r~  rb  r”  s   000r\   r_  r_  ë  s]  … Ù$à$ j°+¸xÐH€OØ+:×+@Ñ+@Ó+B×CÐC¡4 1 a˜!˜Q™$ÔCÐØ€J�	Óó1ò9ò:óxð òó ðó(ó
;óô.ðb FJðFØðFØ)ðFØ8BðFà	óFó&5óP5ð@ FJð
Øð
Ø)ð
Ø8Bð
à	ó
ð4 HLðOØðOØ!+ðOØ:DðOà	óOób*ð BFð@BØð@BØ)ð@BØ2>ð@Bà	ô@BùôG Ds   ¢B$r_  c                  ód   ‡ — e Zd ZU dZdgZded<   edd„«       Z	 	 	 	 d	 	 	 	 	 d	d„Zd
ˆ fd„Z	ˆ xZ
S )rÖ  rË  rc   rH   c                óÌ   — 	 | j                   j                  }d|j                  v rt        |j                  j                  «      S t        |«      fS # t        t        f$ r Y y w xY wr	  )rÓ   r�  r§  rk   rØ  rl   r…   r–   )ré   r  s     r\   rØ  zSeriesFixed.shapeÛ  s\   € ð	Ø—:‘:×$Ñ$ˆDØ˜$Ÿ-™-Ñ'ô ˜TŸ]™]×0Ñ0Ó1Ð1Ü˜“I�<ÐøÜœ>Ð*ò 	Ùð	ús   ‚AA ÁA ÁA#Á"A#c                ó¸  — | j                  ||«       | j                  d||¬«      }| j                  d||¬«      }	 t        ||| j                  d¬«      }|S # t
        $ ry}| j                  dk(  r^t        «       rTt        |«      j                  d«      r:t        r4t        ||| j                  dt        dt        j                  ¬	«      ¬
«      }n‚ Y d }~|S d }~ww xY w)NrŸ   r†  r�  F)rŸ   rc   rº  ri  rj  rk  rl  )rŸ   rc   rº  r[  )ru  r‹  r‚  r4   rc   r~  r¤   r   ra   rù  r   r5   rp  r  )	ré   rm   r¸   rŽ   r�   rŸ   r�  rÌ   rv  s	            r\   r9  zSeriesFixed.readç  sÏ   € ð 	×Ñ˜7 EÔ*Ø—‘ ¨u¸4�Ó@ˆØ—‘ °¸T�ÓBˆð	Ü˜F¨%°d·i±iÀeÔLˆFð" ˆøô! "ò 	à—‘˜Ò.Ü&Ô(Ü˜“H×%Ñ%Ð&>Ô?ÝäØØØŸ™ØÜ%¨hÄÇÁÔHô‘ð ó ð ˆûð!	ús   ¼A Á	CÁ A.CÃCc                ó¸   •— t        ‰| �  |fi |¤Ž | j                  d|j                  «       | j	                  d|«       |j
                  | j                  _        y )NrŸ   r�  )rÒ  rë  r‘  rŸ   r�  rc   r†   )ré   ræ  rÈ   rÓ  s      €r\   rë  zSeriesFixed.write  sG   ø€ Ü‰‰�cÑ$˜VÒ$Ø×Ñ˜ #§)¡)Ô,Ø×Ñ˜ 3Ô'ØŸ(™(ˆ�
‰
�r^   )rÿ  ztuple[int] | Noner\  ©rŽ   rþ  r�   rþ  rÿ  r4   r  )r  r  r  r2  ra  r  r  rØ  r9  rë  r#  r$  s   @r\   rÖ  rÖ  Õ  sa   ø… Ø€KØ�€Jà
ƒNàò	ó ð	ð ØØ Øðð ð	ð
 ðð 
ó÷<#ñ #r^   rÖ  c                  ób   ‡ — e Zd ZU ddgZded<   edd„«       Z	 	 	 	 d	 	 	 	 	 d	d„Zd
ˆ fd„Zˆ xZ	S )ÚBlockManagerFixedr†  Únblocksr  c                óÜ  — 	 | j                   }d}t        | j                  «      D ]4  }t        | j                  d|› d�«      }t        |dd «      }|€Œ-||d   z  }Œ6 | j                  j
                  }d|j                  v r)t        t        |j                  j                  «      «      }nt        |dd «      }|�t        |d|dz
   «      }ng }|j                  |«       |S # t        $ r Y y w xY w)Nr   rÀ  Ú_itemsrØ  rg   )r†  r…  rÉ  r€   rÓ   Úblock0_valuesr§  rk   ÚreversedrØ  rj   r¥   r–   )ré   r†  r&  rœ  r  rØ  Ú
data_shapes          r\   rØ  zBlockManagerFixed.shape  só   € ð	Ø—9‘9ˆDð ˆEÜ˜4Ÿ<™<Ó(ò &�Ü˜tŸz™z¨U°1°#°VÐ+<Ó=�Ü  g¨tÓ4�ØÑ$Ø˜U 1™XÑ%‘Eð	&ð —:‘:×+Ñ+ˆDà˜$Ÿ-™-Ñ'ô
 #¤8¨D¯M©M×,?Ñ,?Ó#@ÓA‘
ä$ T¨7°DÓ9�
ØÐ%Ü˜Z¨¨T°A©XÐ7Ó8‘à�à�L‰L˜ÔàˆLøÜò 	Ùð	ús   ‚AC ÁBC Ã	C+Ã*C+c                ó¼  — | j                  ||«       | j                  «       j                  d«      }g }t        | j                  «      D ]8  }||k(  r||fnd\  }}	| j                  d|› �||	¬«      }
|j                  |
«       Œ: |d   }g }t        | j                  «      D ]û  }| j                  d|› d�«      }| j                  d|› d�	¬«      }||j                  |«         }|j                  }t        |t        j                  «      rt        j                  |«      }t        |||d   d	¬
«      }t!        «       rPt        |t        j                  «      r6t#        |d¬«      r)|j%                  t'        t        j(                  ¬«      «      }|j                  |«       Œý t+        |«      dkD  rt-        |d¬«      }|j/                  |¬«      S t        |d   |d   ¬«      S )Nr   r  rT  r†  rÀ  rË  r�  rg   F©r¸   rŸ   rº  Tr­  )rn  r�  rç  ©r¸   rŸ   )ru  r5  Ú_get_block_manager_axisr…  r†  r‹  r¥   rÉ  r‚  r‹  r€  r`   rp  rq  Úasfortranarrayr.   r   r   r  r5   r  rl   r7   r�  )ré   rm   r¸   rŽ   r�   Úselect_axisrx  rœ  r:  r;  Úaxr&  ÚdfsÚ	blk_itemsr�  r©  ÚdfÚouts                     r\   r9  zBlockManagerFixed.read4  s¯  € ð 	×Ñ˜7 EÔ*Ø—m‘m“o×=Ñ=¸aÓ@ˆàˆÜ�t—y‘yÓ!ò 	ˆAØ-.°+Ò-=˜U D™MÀ<‰MˆF�EØ—‘ 4¨ s °6À�ÓFˆBØ�K‰K˜�Oð	ð
 �Q‘ˆØˆä�t—|‘|Ó$ò 	ˆAØŸ™¨%°¨s°&Ð(9Ó:ˆIØ—_‘_ u¨Q¨C¨wÐ%7¸vÈE�_ÓRˆFà˜E×-Ñ-¨iÓ8Ñ9ˆGØ—(‘(ˆCÜ˜#œrŸz™zÔ*ô ×'Ñ'¨Ó,�Ü˜3¨°t¸A±wÀUÔKˆBä"Ô$Ü˜v¤r§z¡zÔ2Ü# F°4Õ8à—Y‘Yœ{´B·F±FÔ;Ó<�Ø�J‰J�r�Nð%	ô( ˆs‹8�aŠ<Ü˜ 1Ô%ˆCØ—;‘; u�;Ó-Ð-ä  a¡°°Q±Ô8Ð8r^   c                óŒ  •— t        ‰| �  |fi |¤Ž |j                  }|j                  «       s|j	                  «       }|j
                  | j                  _        t        |j                  «      D ]6  \  }}|dk(  r|j                  st        d«      ‚| j                  d|› �|«       Œ8 t        |j                  «      | j                  _        t        |j                  «      D ]b  \  }}|j                  j!                  |j"                  «      }| j%                  d|› d�|j&                  |¬«       | j                  d|› d�|«       Œd y )Nr   z/Columns index has to be unique for fixed formatrT  rÀ  r�  )r&  rË  )rÒ  rë  Ú_mgrÚis_consolidatedÚconsolidater†  r†   r™  rx  Ú	is_uniquer„   r‘  rl   ÚblocksrÉ  r&  rŒ  Úmgr_locsr�  r�  )	ré   ræ  rÈ   r¹  rœ  rÕ  Úblkr×  rÓ  s	           €r\   rë  zBlockManagerFixed.writeb  s  ø€ Ü‰‰�cÑ$˜VÒ$à�x‰xˆØ×#Ñ#Ô%Ø×#Ñ#Ó%ˆDàŸ)™)ˆ�
‰
ŒÜ˜tŸy™yÓ)ò 	-‰EˆAˆrØ�AŠv˜rŸ|š|Ü Ð!RÓSÐSØ×Ñ˜t A 3˜Z¨Õ,ð	-ô ! §¡Ó-ˆ�
‰
ÔÜ §¡Ó,ò 	;‰FˆAˆsàŸ
™
Ÿ™¨¯©Ó5ˆIØ×Ñ˜u Q C wÐ/°·±À9ÐÔMØ×Ñ˜u Q C vÐ.°	Õ:ñ		;r^   )rÿ  zlist[int] | Noner\  ©rŽ   rþ  r�   rþ  rÿ  r.   r  )
r  r  r  ra  r  r  rØ  r9  rë  r#  r$  s   @r\   rÈ  rÈ    sa   ø… Ø˜)Ð$€JàƒLàò ó ð ðH ØØ Øð,9ð ð	,9ð
 ð,9ð 
ó,9÷\;ñ ;r^   rÈ  c                  ó   — e Zd ZdZeZy)r×  rÌ  N)r  r  r  r2  r.   r5  rÜ   r^   r\   r×  r×  x  s   „ Ø€KØ�Hr^   r×  c                  ó¶  ‡ — 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<   	 	 	 	 	 	 	 	 d3	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d4ˆ fd„Z	e
d5d„«       Zd5d„Zd6d„Zd7d„Ze
d8d„«       Z	 	 	 	 d9d„Ze
d:d„«       Ze
d8d„«       Ze
d„ «       Ze
d„ «       Ze
d„ «       Ze
d„ «       Ze
d;d„«       Ze
d:d„«       Ze
d8d„«       Ze
d<d„«       Zd=d„Zd>d„Zd?d „Zd@d!„ZdAd"„ZdBd#„Z d7d$„Z!d7d%„Z"d7d&„Z#e$d'„ «       Z%	 dC	 	 	 dDd(„Z&	 dE	 	 	 	 	 dFd)„Z'e(dGd*„«       Z)	 dH	 dId+„Z*	 	 	 	 dJ	 	 	 dKd,„Z+e,	 	 	 	 dLd-„«       Z-dMdNd.„Z.	 	 	 	 	 	 	 	 dOd/„Z/	 dC	 	 	 dPd0„Z0d8d1„Z1	 	 	 dC	 	 	 	 	 dQd2„Z2ˆ xZ3S )Rr  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
    Ú
wide_tableru   ra   r3  rÈ  rg   zint | list[Hashable]rš  Trj   r1  c                ó¨   •— t         ‰| �  ||||¬«       |xs g | _        |xs g | _        |xs g | _        |xs g | _        |	xs i | _        |
| _        y )NrÏ  )rÒ  rë   Ú
index_axesr_  Úvalues_axesr£   rÂ  r¡   )ré   rÕ   rÓ   r[   r¤   rç  r_  rè  r£   rÂ  r¡   rÓ  s              €r\   rë   zTable.__init__�  s`   ø€ ô 	‰Ñ˜ °À&ÐÔIØ$Ò*¨ˆŒØ,Ò2°ˆÔØ&Ò,¨"ˆÔØ(Ò.¨BˆÔØ’J˜BˆŒ	Øˆ�r^   c                ó>   — | j                   j                  d«      d   S )Nr‘   r   )rÈ  rø  rî   s    r\   Útable_type_shortzTable.table_type_short²  s   € à�‰×$Ñ$ SÓ)¨!Ñ,Ð,r^   c                ó|  — | j                  «        t        | j                  «      rdj                  | j                  «      nd}d|› d�}dj                  | j                  D �cg c]  }|j
                  ‘Œ c}«      }| j                  d›d| j                  › d| j                  › d| j                  › d	|› d|› d
�S c c}w )r9  rB  r»  z,dc->[rQ  r;  z (typ->z,nrows->z,ncols->z,indexers->[r<  )
rA  rl   r£   rE  rç  rc   r£  rê  r�   Úncols)ré   Újdcr™  r›   Újindex_axess        r\   r  zTable.__repr__¶  s´   € à�‰ÔÜ-0°×1BÑ1BÔ-Cˆc�h‰h�t×(Ñ(Ô)ÈˆØ�c�U˜!ˆ_ˆà—h‘h°·±Ö@¨1 §£Ò@ÓAˆà×Ñ Ð&ð 'Ø×*Ñ*Ð+¨8°D·J±J°<ð @Ø—j‘j�\ ¨k¨]¸!¸B¸4¸qðBð	
ùò  As   Á"B9c                óL   — | j                   D ]  }||j                  k(  sŒ|c S  y)zreturn the axis for cN)rx  rc   )ré   rª  r›   s      r\   rù   zTable.__getitem__Ã  s*   € à—‘ò 	ˆAØ�A—F‘F‹{Ø’ð	ð r^   c                ó
  — |€y|j                   | j                   k7  r&t        d|j                   › d| j                   › d�«      ‚dD ]¼  }t        | |d«      }t        ||d«      }||k7  sŒ#t        |«      D ]x  \  }}||   }||k7  sŒ|dk(  rO|j                  |j                  k7  r6t        d|j                  d   › d	|j                  › d
|j                  › d�«      ‚t        d|› d|› d|› d�«      ‚ t        d|› d|› d|› d�«      ‚ y)z"validate against an existing tableNz'incompatible table_type with existing [r¬  rQ  )rç  r_  rè  rè  úCannot serialize the column [r   z%] because its data contents are not [z] but [ú] object dtypezinvalid combination of [z] on appending data [z] vs current table [)rÈ  r…   r€   r™  rŸ  r„   r�  rq  )ré   rN  rª  ÚsvÚovrœ  ÚsaxÚoaxs           r\   r_  zTable.validateÊ  sb  € àˆ=Øà×Ñ˜tŸ™Ò.ÜðØ×$Ñ$Ð% S¨¯©Ð(9¸ð<óð ð
 Aò 	ˆAÜ˜˜q $Ó'ˆBÜ˜  4Ó(ˆBØ�R‹xô (¨›mò ‘F�A�sà˜Q™%�CØ˜c“zØ Ò-°#·(±(¸c¿h¹hÒ2FÜ",Ø"?ÀÇ
Á
È1Á¸ð OFØFIÇhÁhÀZð P(Ø(+¯© z°ð!Aó#ð ô
 )Ø6°q°cð : Ø #˜uÐ$8¸¸¸Qð@óð ðô   Ø.¨q¨cÐ1FÀrÀdð K&Ø&( T¨ð,óð ñ/	r^   c                ó6   — t        | j                  t        «      S )z@the levels attribute is 1 or a list in the case of a multi-index)r`   rš  rj   rî   s    r\   Úis_multi_indexzTable.is_multi_indexñ  s   € ô ˜$Ÿ+™+¤tÓ,Ð,r^   c                óú   — t        j                  |j                  j                  «      }d|v rt	        d«      ‚	 |j                  «       }t        |t        «      sJ ‚||fS # t        $ r}t	        d«      |‚d}~ww xY w)ze
        validate that we can store the multi-index; reset and return the
        new object
        rŸ   zocannot store a MultiIndex with a level named 'index' as a table; 'index' is reserved for the implicit row indexzBduplicate names/columns in the multi-index when storing as a tableN)rs  Úfill_missing_namesrŸ   r›  r„   Úreset_indexr`   r.   )ré   ræ  rš  Ú	reset_objrv  s        r\   Úvalidate_multiindexzTable.validate_multiindexö  sŒ   € ô ×'Ñ'¨¯	©	¯©Ó8ˆØ�fÑô ðHóð ð	ØŸ™Ó)ˆIô
 ˜)¤YÔ/Ð/Ð/Ø˜&Ð Ð øô ò 	ÜØTóàðûð	ús   ºA  Á 	A:Á)A5Á5A:c                ó”   — t        j                  | j                  D �cg c]  }|j                  j                  d   ‘Œ c}«      S c c}w )z-based on our axes, compute the expected nrowsr   )rp  r¤  rç  r™  rØ  ©ré   rœ  s     r\   Únrows_expectedzTable.nrows_expected  s2   € ô �w‰w°D·O±OÖD¨q˜Ÿ	™	Ÿ™¨Ó*ÒDÓEÐEùÒDs   ž Ac                ó   — d| j                   v S )zhas this table been createdru   rP  rî   s    r\   ré  zTable.is_exists  s   € ð ˜$Ÿ*™*Ð$Ð$r^   c                ó0   — t        | j                  dd «      S ©Nru   ©r€   rÓ   rî   s    r\   rQ  zTable.storable  s   € ä�t—z‘z 7¨DÓ1Ð1r^   c                ó   — | j                   S )z,return the table group (this is my storable))rQ  rî   s    r\   ru   zTable.table  s   € ð �}‰}Ðr^   c                ó.   — | j                   j                  S rY   )ru   r[  rî   s    r\   r[  zTable.dtype!  s   € à�z‰z×ÑÐr^   c                ó.   — | j                   j                  S rY   r’  rî   s    r\   r“  zTable.description%  r”  r^   c                óV   — t        j                  | j                  | j                  «      S rY   )rZ  r[  rç  rè  rî   s    r\   rx  z
Table.axes)  s   € ä�‰˜tŸ™°×0@Ñ0@ÓAÐAr^   c                ó:   — t        d„ | j                  D «       «      S )z.the number of total columns in the values axesc              3  óF   K  — | ]  }t        |j                  «      –— Œ y ­wrY   )rl   r�  )r~  r›   s     r\   r€  zTable.ncols.<locals>.<genexpr>0  s   è ø€ Ò; Q”3�q—x‘x—=Ñ;ùs   ‚!)rx  rè  rî   s    r\   rì  zTable.ncols-  s   € ô Ñ;¨$×*:Ñ*:Ô;Ó;Ð;r^   c                 ó   — yrË  rÜ   rî   s    r\   Úis_transposedzTable.is_transposed2  rÌ  r^   c                óò   — t        t        j                  | j                  D �cg c]  }t	        |d   «      ‘Œ c}| j
                  D �cg c]  }t	        |j                  «      ‘Œ c}«      «      S c c}w c c}w )z@return a tuple of my permutated axes, non_indexable at the frontr   )rk   rZ  r[  r_  r  rç  rT  ©ré   r›   s     r\   Údata_orientationzTable.data_orientation6  sY   € ô Ü�O‰OØ$(×$7Ñ$7Ö8˜q”�Q�q‘T•Ò8Ø&*§o¡oÖ6 ”�Q—V‘V•Ò6óó
ð 	
ùâ8ùÚ6s   £A/ÁA4c                ól  — dddœ}| j                   D �cg c]  }|j                  |f‘Œ }}| j                  D ��cg c]  \  }}||   df‘Œ }}}| j                  D �cg c]2  }|j                  t        | j                  «      v sŒ%|j                  |f‘Œ4 }}t        ||z   |z   «      S c c}w c c}}w c c}w )z<return a dict of the kinds allowable columns for this objectrŸ   r¸   ©r   rg   N)rç  r/  r_  rè  rc   r„  r£   r‚  )	ré   Ú
axis_namesr›   Úd1rT  r�  Úd2r”  Úd3s	            r\   Ú
queryableszTable.queryables@  s¶   € ð ! YÑ/ˆ
ð %)§O¡OÖ4˜qˆq�w‰w˜ŠlÐ4ˆÐ4Ø;?×;NÑ;N×O©<¨4°ˆz˜$Ñ Ò&ÐOˆÑOà"&×"2Ñ"2ö
Ø°a·f±fÄÀD×DUÑDUÓ@VÒ6VˆQ�W‰W�aŠLð
ˆð 
ô �B˜‘G˜b‘LÓ!Ð!ùò 5ùÛOùò
s   ”B&ºB+Á&B1ÂB1c                ól   — | j                   D �cg c]  }|j                  |j                  f‘Œ c}S c c}w )zreturn a list of my index cols)rç  rT  r/  rÿ  s     r\   Ú
index_colszTable.index_colsN  s)   € ð ,0¯?©?Ö; a�—‘˜Ÿ™Ò!Ò;Ð;ùÒ;s   �1c                óT   — | j                   D �cg c]  }|j                  ‘Œ c}S c c}w )zreturn a list of my values cols)rè  r/  rÿ  s     r\   Úvalues_colszTable.values_colsS  s    € à!%×!1Ñ!1Ö2˜A�—“Ò2Ð2ùÒ2s   �%c                ó>   — | j                   j                  }|› d|› d�S )z)return the metadata pathname for this keyz/meta/z/metarC  r6  s      r\   Ú_get_metadata_pathzTable._get_metadata_pathW  s$   € à—
‘
×&Ñ&ˆØ�˜˜s˜e 5Ð)Ð)r^   c           	     óÖ   — t        |«      dk(  ry| j                  j                  | j                  |«      t	        |d¬«      d| j
                  | j                  | j                  d¬«       y)z£
        Write out a metadata array to the key as a fixed-format Series.

        Parameters
        ----------
        key : str
        values : ndarray
        r   NFr  ru   )rž   r[   r¤   r¡   r«   )rl   rÕ   r­   r  r4   r[   r¤   r¡   )ré   r¨   r�  s      r\   r¥  zTable.write_metadata\  s]   € ô ˆv‹;˜!Òð Ø�‰�‰Ø×#Ñ# CÓ(Ü�6 Ô&ØØ—]‘]Ø—;‘;Ø—L‘LØð 	õ 	
r^   c                óœ   — t        t        | j                  dd«      |d«      �*| j                  j                  | j	                  |«      «      S y)z'return the meta data array for this keyrÏ   N)r€   rÓ   rÕ   rÆ   r  rø   s     r\   rÀ  zTable.read_metadatat  sA   € ä”7˜4Ÿ:™: v¨tÓ4°c¸4Ó@ÐLØ—;‘;×%Ñ% d×&=Ñ&=¸cÓ&BÓCÐCØr^   c                óÎ  — t        | j                  «      | j                  _        | j                  «       | j                  _        | j	                  «       | j                  _        | j
                  | j                  _        | j                  | j                  _        | j                  | j                  _        | j                  | j                  _        | j                  | j                  _	        | j                  | j                  _
        t        | j                  t        «      | j                  _        | j                  du | j                  _        | j                  | j                  _        y)zset our table type & indexablesN)ra   rÈ  r†   r  r  r_  r£   r¡   r[   r¤   rš  r`   rj   Úmi_level_nan_repÚdata_col_nan_reprÂ  rî   s    r\   rK  zTable.set_attrsz  sâ   € ä # D§O¡OÓ 4ˆ�
‰
ÔØ $§¡Ó 1ˆ�
‰
ÔØ!%×!1Ñ!1Ó!3ˆ�
‰
ÔØ$(×$7Ñ$7ˆ�
‰
Ô!Ø"&×"3Ñ"3ˆ�
‰
ÔØ!Ÿ\™\ˆ�
‰
ÔØ"Ÿm™mˆ�
‰
ÔØ ŸK™Kˆ�
‰
ÔØ ŸK™Kˆ�
‰
Ôô '1°·±¼dÓ&Cˆ�
‰
Ô#ð '+§l¡l°dÐ&:ˆ�
‰
Ô#ØŸ)™)ˆ�
‰
�r^   c                ó‚  — t        | j                  dd«      xs g | _        t        | j                  dd«      xs g | _        t        | j                  dd«      xs i | _        t        | j                  dd«      | _        t        t        | j                  dd«      «      | _        t        | j                  dd«      | _        t        | j                  d	d«      xs g | _	        | j                  D �cg c]  }|j                  sŒ|‘Œ c}| _        | j                  D �cg c]  }|j                  rŒ|‘Œ c}| _        yc c}w c c}w )
ry  r_  Nr£   rÂ  r¡   r[   r¤   r”   rš  )r€   r†   r_  r£   rÂ  r¡   r]   r[   r¤   rš  Ú
indexablesr'  rç  rè  r  s     r\   rN  zTable.get_attrs�  sð   € ä% d§j¡jÐ2BÀDÓIÒOÈRˆÔÜ# D§J¡J°ÀÓEÒKÈˆÔÜ˜DŸJ™J¨°Ó5Ò;¸ˆŒ	Ü˜tŸz™z¨9°dÓ;ˆŒÜ(¬°·±¸ZÈÓ)NÓOˆŒÜ˜dŸj™j¨(°HÓ=ˆŒÜ&-¨d¯j©j¸(ÀDÓ&IÒ&OÈRˆŒØ&*§o¡oÖK ¸×9JÓ9Jš1ÒKˆŒØ'+§¡ÖP !¸a×>OÓ>OšAÒPˆÕùò LùÚPs   Ã,D7Ã>D7ÄD<Ä*D<c                óŒ   — |€yt        |t        «      sy| j                  «       }|D ]  }|dk(  rŒ	||vsŒt        d|› d�«      ‚ y)zˆ
        validate the min_itemsize doesn't contain items that are not in the
        axes this needs data_columns to be defined
        Nr�  zmin_itemsize has the key [z%] which is not an axis or data_column)r`   r‚  r  r„   )ré   r    Úqrb  s       r\   Úvalidate_min_itemsizezTable.validate_min_itemsize›  sd   € ð
 ÐØÜ˜,¬Ô-Øà�O‰OÓˆØò 	ˆAà�HŠ}ØØ˜ŠzÜ Ø0°°ð 4"ð "óð ñ	r^   c                óÂ  ‡ ‡‡‡‡‡‡‡— g }‰ j                   Š‰ j                  j                  Št        ‰ j                  dd«      }t	        |t
        «      r|ng Št        ‰ j                  dd«      Št        ‰ j                  dd«      Št        ‰ j                  j                  «      D ]¼  \  }\  }}t        ‰|«      }‰ j                  |«      }t        ‰|› d�d«      }|€|�d}|› d�}	t        ‰|	d«      }
|
d	k(  rt        ‰|› d
�«      nd}t        ||||
|‰ j                  |||‰ j                  j                  |i «      j                  d«      ¬«
      }|j                  |«       Œ¾ t        ‰ j                  «      Št!        |«      Šdˆˆˆˆˆˆˆ ˆfd„}|j#                  t        ‰ j                  j$                  «      D ��cg c]  \  }} |||«      ‘Œ c}}«       |S c c}}w )z/create/cache the indexables if they don't existrš  Nr   Fr!  r:  rY  r6  r`  r=  r•  )
rc   rT  r0  rŸ  r.  ru   rÏ   r1  r¡   r•  c                óê  •— t        |t        «      sJ ‚t        }|‰v rt        }t	        ‰|«      }t	        ‰|› d�d «      }t	        ‰|› d�d «      }t        |«      }‰j                  |«      }t	        ‰|› d�d «      }‰xs |‰v xr ‰}	|	rt	        ‰|› d�d «      nd }
 |||||‰| z   |‰j                  |||‰j                  j                  |i «      j                  d«      ¬«      }|	|_
        |
|_        |S )Nr6  rÕ  r:  r=  r•  )rc   r/  r�  rŸ  r0  r.  ru   rÏ   r1  r[  r•  )r`   ra   rÐ  r&  r€   rÝ  rÀ  ru   rÂ  r÷   r)  r¡   )rœ  rª  Úklassrî  r�  r[  rŸ  ÚmdrÏ   r)  r¡   ræ  Úbase_posÚdata_col_markerr™  Údescrš  Úmi_level_markerré   Útable_attrss               €€€€€€€€r\   rv   zTable.indexables.<locals>.fæ  s#  ø€ Ü˜a¤Ô%Ð%Ð%ÜˆEØ�B‰wÜ(�ä˜4 Ó#ˆDô ˜[¨Q¨C¨u¨+°tÓ<ˆFÜ˜K¨A¨3¨f¨°tÓ<ˆEô " %Ó(ˆDà×#Ñ# AÓ&ˆBô ˜;¨1¨#¨U¨°TÓ:ˆDð
  /ÒS°1¸°;Ò3RÀ?Ðá>N”˜¨ s¨( ^°TÔ:ÐTXð ñ ØØØØØ˜q‘LØØ—j‘jØØØØŸ	™	Ÿ™ a¨Ó,×0Ñ0°Ó;ôˆCð $4ˆCÔ Ø!ˆCŒKØˆJr^   )rª  ra   rÿ  rÐ  )r“  ru   r†   r€   r`   rj   r™  r  rÀ  r¥  r&  rÂ  r÷   r¥   r„  r£   rl   rˆ  r  )ré   Ú_indexablesÚlevels_attrrœ  rT  rc   rî  r*  rÏ   r7  rŸ  r¡   Ú	index_colrv   rª  r+  r,  r™  r-  rš  r.  r/  s   `              @@@@@@@r\   r#  zTable.indexables°  sÔ  ÿ€ ð ˆà×ÑˆØ—j‘j×&Ñ&ˆô ˜dŸj™j¨(°DÓ9ˆÜ *¨;¼Ô =‘À2ˆÜ! $§*¡*Ð.@À%ÓHˆÜ! $§*¡*Ð.@À%ÓHˆô
  )¨¯©×)>Ñ)>Ó?ò 	*‰OˆA‰|��dÜ˜4 Ó&ˆDØ×#Ñ# DÓ)ˆBô
 ˜;¨4¨&°¨¸Ó=ˆDØˆ|  Ø!�à˜& ˜ˆIÜ˜;¨	°4Ó8ˆDð ˜8Ò#ô $ K°D°6¸Ð1BÔCàð ô !ØØØØØØ—j‘jØØØØŸ	™	Ÿ™ d¨BÓ/×3Ñ3°IÓ>ôˆIð ×Ñ˜yÕ)ð?	*ôD �×"Ñ"Ó#ˆÜ�{Ó#ˆ÷+	ô +	ð^ 	×Ñ´	¸$¿*¹*×:PÑ:PÓ0Q×R©¨¨1™A˜a �GÓRÔSàÐùó Ss   Æ>G
c           
     ó  — | j                  «       sy|du ry|�|du r0| j                  D �cg c]  }|j                  sŒ|j                  ‘Œ }}t	        |t
        t        f«      s|g}i }|�||d<   |�||d<   | j                  }|D ]ô  }t        |j                  |d«      }|�°|j                  r^|j                  }	|	j                  }
|	j                  }|�||k7  r|j                  «        n||d<   |�|
|k7  r|j                  «        n|
|d<   |j                  rŒ“|j                  j!                  d«      rt#        d«      ‚ |j$                  di |¤Ž ŒÌ|| j&                  d   d	   v sŒát)        d
|› d|› d|› d�«      ‚ yc c}w )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.
        NFTrž  rŸ  ÚcomplexzíColumns containing complex values can be stored but cannot be indexed when using table format. Either use fixed format, set index=False, or do not include the columns containing complex values to data_columns when initializing the table.r   rg   zcolumn z/ is not a data_column.
In order to read column z: you must reload the dataframe 
into HDFStore and include z  with the data_columns argument.rÜ   )rA  rx  r(  r/  r`   rk   rj   ru   r€   r  rµ  rŸ   rž  rŸ  Úremove_indexr  r°  r…   r   r_  r–   )ré   r¸   rž  rŸ  r›   Úkwru   rª  r”  rŸ   Úcur_optlevelÚcur_kinds               r\   r   zTable.create_index  s¦  € ð< �‰Ô ØØ�eÑØð ˆ?˜g¨™oØ(,¯	©	ÖI 1°Q×5HÓ5H�q—w“wÐIˆGÐIÜ˜'¤E¬4 =Ô1Ø�iˆGàˆØÐØ%ˆBˆz‰NØÐØˆBˆv‰Jà—
‘
ˆØò $	ˆAÜ˜Ÿ
™
 A tÓ,ˆAØˆ}à—<’<ØŸG™G�EØ#(§>¡>�LØ$Ÿz™z�HàÐ'¨H¸Ò,<ØŸ™Õ(à%-˜˜6™
àÐ+°ÀÒ0HØŸ™Õ(à)5˜˜:™ð —|“|Ø—v‘v×(Ñ(¨Ô3Ü'ðHóð ð #�A—N‘NÑ( RÓ(Ø�d×)Ñ)¨!Ñ,¨QÑ/Ò/ä$Ø˜a˜Sð !/Ø/0¨cð 21Ø12°Ð3SðUóð ñA$	ùò Js
   «E<½E<c                ó(  — t        | |||¬«      }|j                  «       }g }| j                  D ]a  }|j                  | j                  «       |j                  || j                  | j                  | j                  ¬«      }|j                  |«       Œc |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]]
        rF  r  )
Ú	SelectionrÆ   rx  r¹  rÂ  r‹  r¡   r[   r¤   r¥   )	ré   rm   rŽ   r�   Ú	selectionr�  r#  r›   Úress	            r\   Ú
_read_axeszTable._read_axeso  sŠ   € ô" ˜d¨%°uÀ4ÔHˆ	Ø×!Ñ!Ó#ˆàˆà—‘ò 	 ˆAØ�J‰J�t—y‘yÔ!Ø—)‘)ØØŸ™ØŸ™Ø—{‘{ð	 ó ˆCð �N‰N˜3Õð	 ð ˆr^   c                ó   — |S )zreturn the data for this objrÜ   ©râ  ræ  r|  s      r\   Ú
get_objectzTable.get_object‘  s	   € ð ˆ
r^   c                óT  — t        |«      sg S |d   \  }}| j                  j                  |i «      }|j                  d«      dk(  rP|rt        d|› d|› �«      ‚t	        |t
        «      r-dh|£}|D �	cg c]	  }	|	|vsŒ|	‘Œ }
}	|
rt        d|
› d|› d	�«      ‚|d
u rt        |«      }n|€g }t	        |t
        «      rLt        |«      }t        |«      }|j                  |j                  «       D �	cg c]  }	|	dk7  r|	|vr|	‘Œ c}	«       |D �cg c]	  }||v sŒ|‘Œ c}S c c}	w c c}	w c c}w )zd
        take the input data_columns and min_itemize and create a data
        columns spec
        r   r  r1   z"cannot use a multi-index on axis [z] with data_columns r�  zcannot use min_itemsize keys z
 on axis [zÍ] with a MultiIndex; per-column min_itemsize requires data_columns, which are not supported with MultiIndex columns. Use min_itemsize={'values': N} to apply a single min_itemsize across all string columns.T)
rl   rÂ  r÷   r„   r`   r‚  rj   r„  rˆ  r  )ré   r£   r    r_  Úindex_cnamesrT  Úaxis_labelsrÂ  Úallowedrb  Úmi_keysÚexisting_data_columnsrª  s                r\   Úvalidate_data_columnszTable.validate_data_columns–  sv  € ô �>Ô"ØˆIà*¨1Ñ-ÑˆˆkØ�y‰y�}‰}˜T 2Ó&ˆØ�8‰8�FÓ˜|Ò+ÙÜ Ø8¸¸ð ?$Ø$0 >ð3óð ô ˜,¬Ô-ð $Ð3 lÐ3�Ø&2ÖG °a¸wÒ6Fš1ÐG�ÐGÙÜ$Ø7¸°yð AØ ˜6ð "BðBóð ð ˜4ÑÜ Ó,‰LØÐ!ØˆLô �l¤DÔ)Ü$'¨Ó$5Ð!Ü Ó-ˆLØ×Ñð *×.Ñ.Ó0öàØ˜H’}¨Ð2GÑ)Gò òôð (Ö<�a¨1°Ò+;’Ò<Ð<ùò? Hùò.ùò =s   Á2	DÁ<DÃ-D Ä
	D%ÄD%c                óL  ‡— t        |t        «      s1| j                  j                  }t	        d|› dt        |«      › d�«      ‚‰€dgŠ‰D �cg c]  }|j                  |«      ‘Œ c}Š|}	| j                  «       rJd}
| j                  D �cg c]  }|j                  ‘Œ c}Št        | j                  «      }| j                  x}}	nd}
| j                  }| j                  dk(  sJ ‚t        ‰«      | j                  d	z
  k7  rt!        d
«      ‚g }|€d}t#        ˆfd„dD «       «      }|j$                  |   }t        |«      }|
r›t        |«      }| j&                  |   d	   }t)        t+        j,                  |«      t+        j,                  |«      dd¬«      sIt)        t+        j,                  t/        |«      «      t+        j,                  t/        |«      «      dd¬«      r|}|j1                  |i «      }t        |j2                  «      |d<   t        |«      j4                  |d<   |j7                  ||f«       ‰d   }|j$                  |   }|j9                  |«      }d}d}|
�r'| j                  d   }|j                  }|j:                  dk(  r…t=        | j>                  j@                  |jB                  «      s[tE        | j>                  jF                  |jH                  «      dd }||jK                  | jL                  «      k(  jO                  «       sd}|€v|j:                  dk(  rgt+        jP                  |jS                  «       «      jO                  «       r6tU        | j>                  |jH                  | jL                  | jV                  «      }tY        ||| jL                  | jV                  ||¬«      }||_	        |j[                  d«       |
rÿ|j:                  j:                  cxk(  rdk(  ràn nÝ|j]                  |j^                  i «      j]                  d«      }||j`                  k7  r£|€t	        d«      ‚|j`                  €t	        d«      ‚tc        jd                  «       5  tc        jf                  ddth        ¬«       tk        |«      jl                  }tk        |j`                  «      jl                  }ddd«       t	        d› d› d�«      ‚|
rc|j:                  j:                  k(  rJto        |j^                  |j]                  |j^                  i «      j]                  d«      |jp                  «       |js                  |«       |ju                  |«       |g}t        |«      }|d	k(  sJ ‚t        |«      d	k(  sJ ‚|D ]  }tw        ||d   |d	   «      }Œ |j                  d	k(  }| jy                  ||||jH                  f«      }|jH                  |v r&t!        d|jH                  ›d|jH                  ›d�«      ‚| j{                  ||«      j}                  «       }| j                  ||
|| j€                  |«      \  }} g }!tƒ        t…        || d¬ «      «      D �]â  \  }"\  }#}$t†        }%d}&|r=t        |$«      d	k(  r/|$d   |v r(tˆ        }%|$d   }&|&�t        |&tŠ        «      st!        d!«      ‚|
r|r	 | j€                  |"   }'nd}'|&xs d$|"› �})t        | j�                  t        «      r| j�                  ng }*|&duxr |&|*v }+|
rGt“        tE        | j@                  d%d«      «      xs$ |+xr  t“        tE        | j@                  d&d«      «      },n|	du xs |+},d}-|,r8t•        |#j–                  |$|'| j>                  | jL                  | jV                  «      }-|-�|-n|}.t™        |)|#j–                  |'||.| jL                  | jV                  |$¬'«      }/|%j›                  |/«      }0t�        |/jž                  j^                  «      }1d}2tE        |/dd«      �t¡        |/jp                  «      }2dx}3x}4}5t        |/jž                  t¢        «      r<|/j¤                  }5d(}3t+        jP                  |/j¦                  «      j©                  «       }4n/t        |#jž                  tª        «      rt‹        |#jž                  «      }3t­        |/«      \  }6}7|'�;|'jž                  |7k(  r,to        |)|j]                  |)i «      j]                  d«      |2«        |%|)|)t        |$«      |0||1|2|5|3|4|7|6¬)«      }8|,|8_W        |-|8_        |8js                  |«       |!j7                  |8«       |d	z  }�Œå |!D �8cg c]  }8|8j°                  sŒ|8j^                  ‘Œ }9}8 t        | «      | j²                  | j                  | jL                  | jV                  |||!|9||	¬*«
      }:t=        | d+«      r| j�                  |:_H        |:jµ                  |«       |r|
r|:j·                  | «       |:S c c}w c c}w # 1 sw Y   �Œ=xY w# tŒ        tŽ        f$ r"}(t!        d"|› d#| j€                  › d�«      |(‚d}(~(ww xY wc c}8w ),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Î  rQ  Nr   TFr°  rg   z<currently only support ndim-1 indexers in an AppendableTabler  c              3  ó,   •K  — | ]  }|‰vsŒ|–— Œ y ­wrY   rÜ   )r~  rc  rx  s     €r\   r€  z%Table._create_axes.<locals>.<genexpr>  s   øè ø€ Ò6˜¨°ª”1Ñ6ùs   ƒ	�r  r½  r›  r  r`  )Úexisting_nan_repÚexisting_valuesÚintegerr*  z2cannot append a period index to a non-period indexz2cannot append a non-period index to a period indexÚignorezPeriodDtype\[B\] is deprecated)rY  zincompatible freq in col [r¬  r+  zcannot use a column named z as a data_column; z' is reserved for the implicit row indexrP  r(  zIncompatible appended table [z]with existing table [Úvalues_block_r!  r   )Úexisting_colr    r¡   r[   r¤   r¸   rY  )rc   r/  r�  r.  r0  rŸ  r+  r•  rÏ   r1  r[  r¹  )
rÕ   rÓ   r[   r¤   rç  r_  rè  r£   rÂ  r¡   rš  )\r`   r.   rÓ   rÒ   r…   r  Ú_get_axis_numberrA  rç  rT  rj   r£   r¡   rÂ  r†  rl   r„   rƒ  rx  r_  r,   rp  rA   rŠ  r±  r›  r  r¥   Ú_get_axis_namerŸ  rW  ru   r†   r>  r€   r  r/  Úencoder[   ru  r  r8   Ú_read_stored_column_valuesr¤   r’  r2  r÷   rc   r*  rà   Úcatch_warningsÚfilterwarningsÚFutureWarningr+   Ú_freqstrÚ_check_tz_conflictr+  rµ  r�  Ú_reindex_axisrG  r@  rV  Ú_get_blocks_and_itemsrè  r™  r\  rÐ  r&  ra   Ú
IndexErrorr  rš  rƒ   Ú_make_data_col_nan_repr�  Ú_maybe_convert_for_string_atomrï  rÝ  r[  r“  r(   r•  r^  rs  r5   rÜ  r)  r(  rÕ   r&  r_  );ré   rx  ræ  r_  r¡   r£   r    rÓ   r›   Úuser_nan_repÚtable_existsÚnew_infoÚnew_non_index_axesr²  Úappend_axisÚindexerÚ
exist_axisrÂ  Ú	axis_namerJ  rK  Úexisting_index_colÚstoredÚ	new_indexÚexisting_freqÚexisting_strÚnew_strÚnew_index_axesrÁ  r|  rÌ  rß  r×  Úvaxesrœ  rá  Úb_itemsr)  rc   rO  rv  Únew_nameÚlevel_namesÚis_levelr)  r  Úblock_nan_repÚdata_convertedr.  rŸ  r+  rÏ   r1  r•  r¹  rÞ  r–  ÚdcsÚ	new_tables;    `                                                         r\   Ú_create_axeszTable._create_axesÎ  sÛ	  ø€ ô@ ˜#œyÔ)Ø—J‘J×&Ñ&ˆEÜØAÀ%Àð IÜ˜s›)˜ Að'óð ð ˆ<Ø�3ˆDð 26Ö6¨A�×$Ñ$ QÕ'Ò6ˆð ˆð �?‰?ÔØˆLØ$(§O¡OÖ4˜q�A—F“FÒ4ˆDÜ × 1Ñ 1Ó2ˆLà%)§\¡\Ð1ˆG‘lð !ˆLà—9‘9ˆà�y‰y˜AŠ~Ðˆ~äˆt‹9˜Ÿ	™	 A™Ò%ÜØNóð ð
 $&Ðð ˆ?ØˆGô Ó6˜fÔ6Ó6ˆà�H‰H�S‰Mˆä˜1“gˆÙÜÐ,Ó-ˆGØ×,Ñ,¨WÑ5°aÑ8ˆJÜ#Ü—‘˜Ó%Ü—‘˜Ó$ØØ õ	ô $Ü—H‘HœV KÓ0Ó1Ü—H‘HœV JÓ/Ó0Ø#Ø $õ	ð #-�Kð ×"Ñ" 3¨Ó+ˆÜ˜QŸW™W›ˆˆW‰Ü˜A“w×'Ñ'ˆˆV‰à×!Ñ! 3¨Ð"4Ô5ð �1‰gˆØ�H‰H�S‰MˆØ×&Ñ& sÓ+ˆ	ð
  ÐØˆÚØ!%§¡°Ñ!3ÐØ1×9Ñ9ÐØ!×&Ñ&¨(Ò2¼7Ø—
‘
× Ñ Ð"4×"AÑ"Aô<ô ! §¡§¡Ð2D×2JÑ2JÓKÉAÐN�ØÐ"2×"9Ñ"9¸$¿-¹-Ó"HÑH×MÑMÔOØ'+Ð$à Ð(Ø&×+Ñ+¨xÒ7Ü—J‘J˜qŸv™v›xÓ(×,Ñ,Ô.ä"<Ø—J‘JÐ 2× 8Ñ 8¸$¿-¹-ÈÏÉó#�ô #ØØØ�M‰MØ�K‰KØ-Ø+ô
ˆ	ð ˆ	Œð 	×Ñ˜!Ôá˜IŸN™NÐ.@×.EÑ.EÔRÈÕRð
 %ŸL™L¨¯©¸Ó<×@Ñ@ÀÓHˆMØ 	§¡Ò.Ø Ð(Ü#ØLóð ð —>‘>Ð)Ü#ØLóð ô ×,Ñ,Ó.ñ CÜ×+Ñ+Ø Ø9Ü!.õô
 $/¨}Ó#=×#FÑ#F�LÜ)¨)¯.©.Ó9×BÑB�G÷Cô  Ø0°°¸cÀ'ÀÈ!ÐLóð ñ ˜IŸN™NÐ.@×.EÑ.EÒEÜØ—‘Ø—‘˜YŸ^™^¨RÓ0×4Ñ4°TÓ:Ø—‘ôð 	×Ñ˜hÔ'Ø× Ñ  Ô.à#˜ˆÜ�ÓˆØ�AŠvˆˆvô Ð%Ó&¨!Ò+Ð+Ð+Ø#ò 	1ˆAÜ  Q q¡T¨1¨Q©4Ó0‰Cð	1ð —^‘^ qÑ(ˆ
ð ×1Ñ1Ø˜,Ð(:¸Y¿_¹_Ð<Nó
ˆð �?‰?˜lÑ*ô Ø,¨Y¯_©_Ð,?ð @ Ø )§¡Ð2ð 3%ð%óð ð —‘  ZÓ0×=Ñ=Ó?ˆà ×6Ñ6Ø�<Ð!3°T×5EÑ5EÀ|ó
Ñˆ�	ð
 ˆÜ!*¬3¨v°yÈÔ+NÓ!Oó n	ÑˆA‰~��WäˆEØˆDñ ¤ G£°Ò 1°g¸a±jÀLÑ6PÜ(�Ø˜q‘z�Ø˜¬
°4¼Ô(=ä$Ð%TÓUÐUñ ¡ðØ#'×#3Ñ#3°AÑ#6‘Lð  $�àÒ2 ¨q¨cÐ2ˆHô *4°D·K±KÄÔ)F˜$Ÿ+š+ÈBˆKØ 4Ð'Ò?¨D°KÐ,?ˆHÙÜ#'Ü˜DŸJ™JÐ(:¸EÓBó$ò $YàÒW¤4¬°·
±
Ð<NÐPUÓ(VÓ#Wñ !ð $0°4Ð#7Ò#C¸8Ð ØˆKÙÜ4Ø—J‘JØØ Ø—J‘JØ—M‘MØ—K‘Kó�ð ,7Ð+B™KÈˆMä;ØØ—
‘
Ø)Ø)Ø%ØŸ™Ø—{‘{Øô	ˆNð —/‘/ .Ó1ˆCÜ! .×"6Ñ"6×";Ñ";Ó<ˆDØˆBÜ�~ t¨TÓ2Ð>Ü˜^×.Ñ.Ó/�à(,Ð,ˆDÐ,�8˜gÜ˜.×.Ñ.Ô0@ÔAØ(×0Ñ0�Ø!�ÜŸ:™: n×&?Ñ&?Ó@×FÑFÓH‘Ü˜CŸI™I¤{Ô3Ü˜3Ÿ9™9“~�ä7¸ÓGÑˆD�*ð Ð'¨L×,>Ñ,>À*Ò,LÜ" 8¨X¯\©\¸(ÀBÓ-G×-KÑ-KÈDÓ-QÐSUÔVáØØÜ˜G“}ØØØØØØØ!Ø ØôˆCð $4ˆCÔ Ø%ˆCŒKØ�O‰O˜HÔ%à�L‰L˜Ôà�‰FŠAð]n	ð` $)ÖB˜C¨C×,AÓ,Aˆs�x‹xÐBˆÐBà”D˜“JØ—;‘;Ø—*‘*Ø—]‘]Ø—;‘;Ø%Ø-ØØØØ ô
ˆ	ô �4˜Ô"à#Ÿ{™{ˆIÔà×'Ñ'¨Ô5á™Ø×Ñ˜tÔ$àÐùòG
 7ùò 5÷nCñ Cûô\ #¤HÐ-ò Ü$Ø7¸°xð @0Ø04×0@Ñ0@Ð/AÀðDóð ðûðüòx Cs=   ÁgÂ	gÑAg Úg-ä,h!ä>h!ç g*ç-hç<hèhc           
     óÔ  — d„ }| j                   }t        |j                  «      } ||«      }t        |«      r¼|d   \  }	}
t	        |
«      j                  t	        |«      «      }| j                  ||	¬«      j                   }t        |j                  «      } ||«      }|D ]R  }| j                  |g|	¬«      j                   }|j                  |j                  «       |j                   ||«      «       ŒT |r•t        ||d¬«      D ��ci c]!  \  }}t        |j                  «       «      ||f“Œ# }}}g }g }|D ]N  }t        |j                  «      }	 |j                  |«      \  }}|j                  |«       |j                  |«       ŒP |}|}||fS c c}}w # t        t        f$ rC}dj!                  |D �cg c]  }t#        |«      ‘Œ nc c}w c}«      }t%        d|› d�«      |‚d }~ww xY w)	Nc                ó†   — | j                   D �cg c]'  }| j                  j                  |j                  «      ‘Œ) c}S c c}w rY   )rß  r&  rŒ  rà  )Úmgrrá  s     r\   Úget_blk_itemsz2Table._get_blocks_and_items.<locals>.get_blk_itemsH  s+   € Ø<?¿J¹JÖG°S�C—I‘I—N‘N 3§<¡<Õ0ÒGÐGùÒGs   �,>r   r�  TrP  rB  z+cannot match existing table structure for [z] on appending data)rÛ  rj   rß  rl   r0   r‰  r�  rˆ  r\  rk   Útolistr�  r`  r¥   r[  r  rE  rF   r„   )rÌ  r_  ra  rè  r£   rz  ry  rß  r×  rT  rC  Ú
new_labelsrª  Úbrn  Úby_itemsÚ
new_blocksÚnew_blk_itemsÚear&  rv  ÚitemÚjitemss                          r\   rZ  zTable._get_blocks_and_items?  sö  € ò	Hð �j‰jˆÜ" 3§:¡:Ó.ˆÙ!.¨sÓ!3ˆ	äˆ|Ôð
 !3°1Ñ 5ÑˆD�+Ü˜{Ó+×6Ñ6´u¸\Ó7JÓKˆJØ—-‘- 
°�-Ó6×;Ñ;ˆCä˜#Ÿ*™*Ó%ˆFÙ% cÓ*ˆIØ!ò 5�ð —m‘m Q C¨d�mÓ3×8Ñ8�Ø—‘˜cŸj™jÔ)Ø× Ñ ¡¨sÓ!3Õ4ð5ñ ô #& f¨iÀÔ"E÷á�A�wô �g—n‘nÓ&Ó'¨!¨W¨Ñ5ðˆHñ ð ')ˆJØˆMØ!ò �Ü˜bŸi™iÓ(�ð	Ø!)§¡¨eÓ!4‘J�A�wØ×%Ñ% aÔ(Ø!×(Ñ(¨Õ1ðð  ˆFØ%ˆIà�yÐ Ð ùó+øô #¤HÐ-ò Ø ŸX™XÀeÖ&L¸d¤|°DÕ'9Ñ&LùÔ&LÓM�FÜ$ØEÀfÀXð N,ð ,óð ðûðús*   Ä&FÅ6FÆG'Æ$G"Æ3GÇG"Ç"G'c                óŠ  ‡ ‡— |�t        |«      }|�P‰ j                  rDt        ‰ j                  t         «      sJ ‚‰ j                  D ]  }||vsŒ|j	                  d|«       Œ ‰ j
                  D ]  \  }}t        ‰|||«      Šˆˆ fd„}Œ |j                  �-|j                  j                  «       D ]  \  }}	}
 ||
|	«      ŠŒ ‰S )zprocess axes filtersr   c                óÌ  •— ‰j                   D ]Æ  }‰j                  |«      }‰j                  |«      }|€J ‚| |k(  rP‰	j                  r$|j	                  t        ‰	j                  «      «      } |||«      }‰j                  |¬«      |   c S | |v sŒƒ‰|    }t        |«      }t        ‰t        «      rd|z
  } |||«      }‰j                  |¬«      |   c S  t        d| › d�«      ‚)Nr�  rg   zcannot find the field [z] for filtering!)Ú_AXIS_ORDERSrP  Ú	_get_axisrø  Úunionr0   rš  r�  rC   r`   r.   r„   )
ÚfieldÚfiltÚopre  Úaxis_numberÚaxis_valuesÚtakersr�  ræ  ré   s
           €€r\   Úprocess_filterz*Table.process_axes.<locals>.process_filterŒ  s  ø€ Ø!$×!1Ñ!1ò A�IØ"%×"6Ñ"6°yÓ"A�KØ"%§-¡-°	Ó":�KØ&Ð2Ð2Ð2ð  	Ò)ð  ×.Ò.Ø#'§:¡:¬e°D·K±KÓ.@Ó#A˜Dá!# K°Ó!6˜Ø"Ÿw™w¨K˜wÓ8¸Ñ@Ò@ð  +Ò-ð "% U¡˜Ü+¨DÓ1˜ô & c¬9Ô5Ø*+¨k©/˜Ká!# F¨DÓ!1˜Ø"Ÿw™w¨K˜wÓ8¸Ñ@Ò@ð?AôB !Ð#:¸5¸'ÐAQÐ!RÓSÐSr^   )	rj   rø  r`   rš  Úinsertr_  rY  Úfilterrž   )ré   ræ  r;  r¸   r  rT  Úlabelsr�  r‰  r‹  rŠ  s   ``         r\   Úprocess_axeszTable.process_axes{  sÜ   ù€ ð ÐÜ˜7“mˆGð Ð 4×#6Ò#6Ü˜dŸk™k¬4Ô0Ð0Ð0Ø—[‘[ò )�Ø˜GÒ#Ø—N‘N 1 aÕ(ð)ð
 !×/Ñ/ò %	T‰LˆD�&Ü  T¨6°7Ó;ˆCö"Tð%	TðP ×ÑÐ'Ø#,×#3Ñ#3×#:Ñ#:Ó#<ò 6‘��r˜4Ù$ U¨D°"Ó5‘ð6ð ˆ
r^   c                ón  — |€t        | j                  d«      }d|dœ}| j                  D �ci c]  }|j                  |j                  “Œ c}|d<   |rC|€| j
                  xs d}t        «       j                  |||xs | j                  ¬«      }||d<   |S | j                  �| j                  |d<   |S c c}w )z:create the description of the table from the axes & valuesi'  ru   )rc   ry  r“  é	   )r¯   r°   rê   rÝ   )
Úmaxr   rx  r/  r.  rä   rš   r)  ræ   rç   )ré   r°   r¯   rê   ry  r‘  r›   rÝ   s           r\   Úcreate_descriptionzTable.create_description·  sÄ   € ð ÐÜ˜t×2Ñ2°EÓ:ˆLà¨lÑ;ˆð 59·I±IÖ>¨q˜AŸG™G Q§U¡U™NÒ>ˆˆ-ÑáØÐ Ø ŸO™OÒ0¨q�	Ü“i×'Ñ'Ø#ØØ%Ò9¨×)9Ñ)9ð (ó ˆGð
 #ˆAˆi‰Lð ˆð �]‰]Ð&ØŸ=™=ˆAˆi‰Làˆùò ?s   ¬B2c                ó¸   — | j                  «       sy|�| j                  |«      rt        d«      ‚t        | |||¬«      }|j	                  «       }t        |d¬«      S )zf
        select coordinates (row numbers) from a table; return the
        coordinates object
        Fa  selecting columns through the 'where' expression (e.g. "columns=['A']") is a column projection, not a row filter, so it cannot be read as row coordinates (e.g. with select_as_coordinates, select_as_multiple, iterator, or chunksize); use the 'columns' argument of 'select' insteadrF  r  )rA  Ú_where_selects_columnsr¾   r:  Úselect_coordsr0   )ré   rm   rŽ   r�   r;  Úcoordss         r\   rH  zTable.read_coordinatesÖ  sd   € ð �‰Ô ØàÐ ×!<Ñ!<¸UÔ!CÜ%ðMóð ô ˜d¨%°uÀ4ÔHˆ	Ø×(Ñ(Ó*ˆä�V %Ô(Ð(r^   c                óü   ‡— | j                   syt        | |¬«      }|j                  €y| j                  D �ch c]  }|j                  ’Œ c}Št        ˆfd„|j                  j                  «       D «       «      S c c}w )aà  
        Whether ``where`` contains a column selection such as "columns=['A']".

        Such a selection is a column projection rather than a row filter, which
        cannot be applied via row coordinates and so is unsupported on any
        coordinate-based read -- ``iterator``/``chunksize``,
        :meth:`select_as_coordinates`, and :meth:`select_as_multiple`
        (GH#12953); ``read_coordinates`` raises a clear error instead of a
        cryptic ``KeyError``.
        Fr"  c              3  ó.   •K  — | ]  \  }}}|‰v–— Œ y ­wrY   rÜ   )r~  r‰  Ú_opÚ_filtÚdata_column_namess       €r\   r€  z/Table._where_selects_columns.<locals>.<genexpr>  s%   øè ø€ ò 
á!��s˜Eð Ð*Ô*ñ
ùs   ƒ)r_  r:  r‘  rx  rc   ru  rž   )ré   rm   r;  r›   r   s       @r\   r™  zTable._where_selects_columnsð  su   ø€ ð ×"Ò"Øä˜d¨%Ô0ˆ	Ø×ÑÐ#Øð .2¯Y©YÖ7¨˜QŸV›VÒ7ÐÜó 
à%.×%5Ñ%5×%<Ñ%<Ó%>ô
ó 
ð 	
ùò 8s   ·A9c                ó(  — | j                  «       sy|�t        d«      ‚| j                  D ]×  }||j                  k(  sŒ|j                  st        d|› d�«      ‚t        | j                  j                  |«      }|j                  | j                  «       |j                  ||| | j                  | j                  | j                  ¬«      }|d   }t        | j                  j                  |› d�d«      }	t!        ||d|	¬	«      c S  t#        d|› d
�«      ‚)zj
        return a single column from the table, generally only indexables
        are interesting
        FNz4read_column does not currently accept a where clausezcolumn [z=] can not be extracted individually; it is not data indexabler  rg   r:  )rc   rº  r[  z] not found in the table)rA  r…   rx  rc   r(  r„   r€   ru   r  r¹  rÂ  r‹  r¡   r[   r¤   r†   r4   r  )
ré   rL  rm   rŽ   r�   r›   rª  Ú
col_valuesÚcvsr[  s
             r\   rM  zTable.read_column
  s  € ð �‰Ô ØàÐÜÐRÓSÐSð —‘ò 	IˆAØ˜Ÿ™ÓØ×*Ò*Ü$Ø" 6 (ð +3ð 3óð ô ˜DŸJ™JŸO™O¨VÓ4�Ø—
‘
˜4Ÿ9™9Ô%ØŸY™YØ�e˜D�MØ ŸL™LØ!Ÿ]™]ØŸ;™;ð	 'ó �
ð ! ‘m�Ü §
¡
× 0Ñ 0°V°H¸EÐ2BÀDÓI�Ü˜c¨°UÀ%ÔHÒHð'	Iô* ˜ & Ð)AÐBÓCÐCr^   )Nr”   NNNNNN)rÕ   r±   rÓ   rN   r[   r  r¤   ra   rç  zlist[IndexCol] | Noner_  z list[tuple[AxisInt, Any]] | Nonerè  zlist[DataCol] | Noner£   zlist | NonerÂ  zdict | Nonerÿ  r   r  )rª  ra   r  r  )ræ  r  rÿ  z tuple[DataFrame, list[Hashable]]r  )rÿ  zitertools.chain[IndexCol])rÿ  ztuple[int, ...])rÿ  údict[str, Any])rÿ  zlist[tuple[Any, Any]])rÿ  r  )r¨   ra   rÿ  ra   )r¨   ra   r�  rÆ  rÿ  r   r  r	  )rŸ  r  rÿ  r   r  )rŽ   rþ  r�   rþ  rÿ  z9list[tuple[np.ndarray, np.ndarray] | tuple[Index, Index]]©r|  rƒ   )rÜ   r  )TNNN)ræ  r.   r_  rƒ   )rÌ  r.   r_  rƒ   rY   )r;  r:  rÿ  r.   )r¯   rþ  rê   rƒ   ry  rþ  rÿ  r¤  ©rŽ   rþ  r�   rþ  )rL  ra   rŽ   rþ  r�   rþ  )4r  r  r  r  r2  r3  r  rš  r]  rë   r  rê  r  rù   r_  rø  rý  r   ré  rQ  ru   r[  r“  rx  rì  r  r  r  r  r  r  r¥  rÀ  rK  rN  r&  r   r#  r   r=  r"  r@  rG  rv  ÚstaticmethodrZ  r“  r—  rH  r™  rM  r#  r$  s   @r\   r  r  }  sT  ø… ñð. €KØ€K�ÓØƒOØ#$€FÐ Ó$Ø€HàƒNð  $ØØ,0Ø;?Ø,0Ø$(Ø Øðàðð ðð ð	ð
 ðð *ðð 9ðð *ðð "ðð ðð 
õð* ò-ó ð-ó
óó%ðN ò-ó ð-ð!Ø%ð!à	)ó!ð0 òFó ðFð ò%ó ð%ð ñ2ó ð2ð ñó ðð ñ ó ð ð ñ&ó ð&ð òBó ðBð ò<ó ð<ð òó ðð ò
ó ð
ó"ó<ó
3ó*ó

ó0ó$ó*
Qóð* ñfó ðfðR ?CðTØ1;ðTà	óTðn CGð Ø&ð Ø5?ð à	Bó ðD òó ðð
 HJð6=à	ó6=ðx ØØØðoð ðoð ó	oðb ð9!Øð9!àò9!ó ð9!ôv:ðxð ðð ð	ð
 !ðð 
óð@ HLð)Ø!+ð)Ø:Dó)ó4
ð: Ø Øð(Dàð(Dð ð	(Dð
 ÷(Dr^   r  c                  ó4   — e Zd ZdZdZ	 	 	 	 d	 	 	 dd„Zdd„Zy)	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Õ  Nc                ó   — t        d«      ‚)z[
        read the indices and the indexing array, calculate offset rows and return
        z!WORMTable needs to implement readrW  rX  s        r\   r9  zWORMTable.read>  s   € ô "Ð"EÓFÐFr^   c                ó   — t        d«      ‚)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 writerW  rZ  s      r\   rë  zWORMTable.writeJ  s   € ô "Ð"FÓGÐGr^   r\  r¦  r  )r  r  r  r  rÈ  r9  rë  rÜ   r^   r\   rÞ  rÞ  5  s>   „ ñð €Jð ØØ Øð
Gð ð	
Gð
 ó
GôHr^   rÞ  c                  ó„   — e Zd ZdZdZ	 	 	 	 	 	 	 	 	 	 	 	 d	 	 	 	 	 	 	 	 	 d	d„Zd
dd„Z	 	 	 	 	 	 	 	 	 	 dd„Z	 d	 	 	 	 	 dd„Zy)rÇ  ú(support the new appendable table formatsÚ
appendableNc                ó8  — |s2| j                   r&| j                  j                  | j                  d«       | j	                  ||||||¬«      }|j
                  D ]  }|j                  «        Œ |j                   sQ|j                  ||||	¬«      }|j                  «        ||d<    |j                  j                  |j                  fi |¤Ž |j                  |j                  _
        |j
                  D ]  }|j                  ||«       Œ |j                  ||
¬«       y )Nru   )rx  ræ  r_  r    r¡   r£   )r°   r¯   rê   ry  r«   )r¢   )ré  r×   rï  rÓ   rv  rx  rŸ  r—  rK  Úcreate_tablerÂ  r†   r¨  Ú
write_data)ré   ræ  rx  r¥   r°   r¯   rê   r    rº   ry  r¢   r¡   r£   r«   ru   r›   Úoptionss                    r\   rë  zAppendableTable.writeY  s  € ñ  ˜$Ÿ.š.Ø�L‰L×$Ñ$ T§Z¡Z°Ô9ð ×!Ñ!ØØØØ%ØØ%ð "ó 
ˆð —‘ò 	ˆAØ×ÑÕð	ð �Šà×.Ñ.ØØ#Ø%Ø)ð	 /ó ˆGð �O‰OÔà%0ˆG�MÑ"ð 'ˆE�M‰M×&Ñ& u§{¡{Ñ>°gÒ>ð !Ÿ:™:ˆ�‰Ôð —‘ò 	.ˆAØ×Ñ˜u fÕ-ð	.ð 	×Ñ˜¨6ÐÕ2r^   c                ó*  — | j                   j                  }| j                  }g }|rs| j                  D ]d  }t	        |j
                  «      j                  d¬«      }t        |t        j                  «      sŒC|j                  |j                  dd¬«      «       Œf |r%|d   }|dd D ]  }||z  }Œ	 |j                  «       }nd}| j                  D �cg c]  }|j                  ‘Œ }	}t        |	«      }
|
dk(  sJ |
«       ‚| j                  D �cg c]  }|j!                  «       ‘Œ }}|D �cg c]Q  }|j#                  t        j$                  t        j&                  |j(                  «      |j(                  dz
  «      «      ‘ŒS }}g }t+        |«      D ]H  \  }}|g| j                   ||
|z         j,                  ¢­}|j                  |j/                  |«      «       ŒJ |€d}t        j0                  t3        ||«      | j                   ¬	«      }||z  dz   }t5        |«      D ]^  }||z  }t3        |dz   |z  |«      }||k\  r y| j7                  ||	D �cg c]  }||| ‘Œ	 c}|�||| nd|D �cg c]  }||| ‘Œ	 c}¬
«       Œ` yc c}w c c}w c c}w c c}w c c}w )z`
        we form the data into a 2-d including indexes,values,mask write chunk-by-chunk
        r   r�  Úu1Fr  rg   Nr  rZ  )Úindexesrƒ  r�  )r[  r›  r   rè  r8   r¹  r|  r`   rp  rq  r¥   r  rs  rç  r™  rl   rŽ  Ú	transposeÚrollrw  r†  r™  rØ  Úreshaperå  r  r…  Úwrite_data_chunk)ré   rº   r¢   r›  r�   Úmasksr›   rƒ  ræ  r´  Únindexesr�  r”  Úbvaluesrœ  Ú	new_shapeÚrowsÚchunksÚstart_iÚend_is                       r\   r°  zAppendableTable.write_data”  sƒ  € ð —
‘
× Ñ ˆØ×#Ñ#ˆð ˆÙØ×%Ñ%ò @�ô ˜AŸF™F“|×'Ñ'¨QÐ'Ó/�Ü˜d¤B§J¡JÕ/Ø—L‘L §¡¨T¸ Ó!>Õ?ð@ñ Ø˜‘8ˆDØ˜1˜2�Yò  �Ø˜a‘x‘ð à—:‘:“<‰DàˆDð '+§o¡oÖ6 �1—9“9Ð6ˆÐ6Ü�w“<ˆØ˜1Š}Ð&˜hÓ&ˆ}ð *.×)9Ñ)9Ö: A�!—+‘+•-Ð:ˆÐ:ØOUÖVÈ!�!—+‘+œbŸg™g¤b§i¡i°·±Ó&7¸¿¹À!¹ÓDÕEÐVˆÐVØˆÜ˜fÓ%ò 	1‰DˆAˆqØÐG §¡¨E°(¸Q±,Ñ,?Ñ!@×!FÑ!FÑGˆIØ�N‰N˜1Ÿ9™9 YÓ/Õ0ð	1ð
 ÐØˆIä�x‰xœ˜I uÓ-°T·Z±ZÔ@ˆØ˜)Ñ# aÑ'ˆÜ�v“ò 	ˆAØ˜)‘mˆGÜ˜˜Q™ )Ñ+¨UÓ3ˆEØ˜%ÒÙà×!Ñ!ØØ3:Ö;¨a˜˜7 5Ò)Ò;Ø,0Ð,<�T˜' %Ñ(À$Ø29Ö:¨Q˜˜' %Ò(Ò:ð	 "õ ñ	ùò' 7ùò ;ùÚVùò( <ùâ:s   ÃI<ÄJÄ(AJÉJÉ%Jc                ó†  — |D ]#  }t        j                  |j                  «      rŒ# y |d   j                  d   }|t        |«      k7  r!t        j                  || j
                  ¬«      }| j
                  j                  }t        |«      }t        |«      D ]  \  }	}
|
|||	   <   Œ t        |«      D ]  \  }	}||||	|z      <   Œ |�;|j                  «       j                  t        d¬«       }|j                  «       s||   }t        |«      r6| j                  j                  |«       | j                  j                  «        yy)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   rZ  Fr  )rp  r¤  rØ  rl   rå  r[  r›  r™  rs  r  rƒ   r|  ru   r¥   r/  )ré   r½  r´  rƒ  r�  r”  r�   r›  rº  rœ  r²  ræ  s               r\   r¸  z AppendableTable.write_data_chunkÏ  s.  € ð  ò 	ˆAÜ—7‘7˜1Ÿ7™7Õ#Ùð	ð ˜‘
× Ñ  Ñ#ˆØ”C˜“IÒÜ—8‘8˜E¨¯©Ô4ˆDØ—
‘
× Ñ ˆÜ�w“<ˆô   Ó(ò 	!‰FˆAˆsØ ˆD��q‘ŠNð	!ô ˜fÓ%ò 	*‰DˆAˆqØ()ˆD��q˜8‘|Ñ$Ò%ð	*ð ÐØ—‘“×$Ñ$¤T°Ð$Ó6Ð6ˆAØ—5‘5”7Ø˜A‘w�äˆtŒ9Ø�J‰J×Ñ˜dÔ#Ø�J‰J×ÑÕð r^   c                óÈ  — |�t        |«      s€|€7|€5| j                  }| j                  j                  | j                  d¬«       |S |€| j                  }| j
                  j                  ||¬«      }| j
                  j                  «        |S | j                  «       sy | j
                  }t        | |||¬«      }|j                  «       }t        |d¬«      j                  «       }t        |«      }	|	rð|j                  «       }
t        |
|
dkD     j                  «      }|sdg}|d   |	k7  r|j!                  |	«       |d   dk7  r|j#                  dd«       |j%                  «       }t'        |«      D ]U  }|j)                  t+        ||«      «      }|j                  ||j                  d      ||j                  d      dz   ¬«       |}ŒW | j
                  j                  «        |	S )	NTrn  r†  Fr  rg   r   r\  )rl   r�   r×   rï  rÓ   ru   Úremove_rowsr/  rA  r:  rš  r4   Úsort_valuesÚdiffrj   rŸ   r¥   r�  r`  rÍ  rŒ  r…  )ré   rm   rŽ   r�   r�   ru   r;  r�  Úsorted_seriesÚlnrÅ  rÃ   Úpgr%  r½  s                  r\   ru  zAppendableTable.deleteû  sÒ  € ð ˆ=¤ E¤
Øˆ}  ØŸ
™
�Ø—‘×(Ñ(¨¯©¸tÐ(ÔDð ˆLð	 �<ØŸ:™:�DØŸ
™
×.Ñ.°UÀÐ.ÓF�Ø—
‘
× Ñ Ô"ØˆLð �‰Ô Øð —
‘
ˆÜ˜d E°¸TÔBˆ	Ø×(Ñ(Ó*ˆô ˜v¨EÔ2×>Ñ>Ó@ˆÜ�Óˆáà ×%Ñ%Ó'ˆDÜ˜$˜t a™x™.×.Ñ.Ó/ˆFñ Ø˜�ð �b‰z˜RÒØ—‘˜bÔ!ð �a‰y˜AŠ~Ø—‘˜a Ô#ð —‘“ˆBÜ˜fÓ%ò �Ø$×)Ñ)¬%°°2«,Ó7�Ø×!Ñ!Ø˜tŸz™z¨!™}Ñ-°D¸¿¹ÀB¹Ñ4HÈ1Ñ4Lð "ô ð ‘ðð �J‰J×ÑÔð ˆ	r^   )NFNNNNNNFNNT)
r¥   rƒ   rº   rþ  r¢   rƒ   r«   rƒ   rÿ  r   r  )rº   rþ  r¢   rƒ   rÿ  r   )
r½  rÆ  r´  úlist[np.ndarray]rƒ  znpt.NDArray[np.bool_] | Noner�  rÉ  rÿ  r   r	  r]  )	r  r  r  r  rÈ  rë  r°  r¸  ru  rÜ   r^   r\   rÇ  rÇ  S  sÈ   „ Ù2à€Jð ØØØØØØ $ØØØØØ ð93ð ð	93ð ð93ð ð93ð ð93ð 
ó93ôv9ðv*àð*ð "ð*ð +ð	*ð
 !ð*ð 
ó*ðZ HLð:Ø!+ð:Ø:Dð:à	ô:r^   rÇ  c                  óh   — e Zd ZU dZdZdZdZeZde	d<   e
dd„«       Zedd„«       Z	 	 	 	 d	 	 	 dd
„Zy	)rÜ  r¬  rÉ  rÓ  r°  r4  r5  c                ó:   — | j                   d   j                  dk(  S )Nr   rg   )rç  rT  rî   s    r\   r  z"AppendableFrameTable.is_transposed@  s   € à�‰˜qÑ!×&Ñ&¨!Ñ+Ð+r^   c                ó"   — |r|j                   }|S )zthese are written transposed)r€  r?  s      r\   r@  zAppendableFrameTable.get_objectD  s   € ñ Ø—%‘%ˆCØˆ
r^   Nc                óÚ  — | j                  «       sy | j                  |||¬«      }t        | j                  «      r,| j                  j                  | j                  d   d   i «      ni }t        | j                  «      D ��cg c]  \  }}|| j                  d   u sŒ|‘Œ }	}}t        |	«      dk(  sJ ‚|	d   }
||
   d   }g }t        | j                  «      D �]B  \  }}|| j                  vrŒ||   \  }}|j                  d«      dk7  rt        |«      }nt        j                  |«      }|j                  d«      }|�|j                  |d¬«       | j                  r|}|}t        |t        |d	d «      ¬
«      }n&|j                   }t        |t        |d	d «      ¬
«      }|}|j"                  dk(  r:t%        |t&        j(                  «      r |j+                  d|j,                  d   f«      }t%        |t&        j(                  t.        f«      r	 t1        |j                   ||d¬«      }n8t%        |t        «      rt1        |||¬«      }nt1        jB                  |g||¬«      }t7        «       r|jD                  jF                  dk(  sD|jH                  |jD                  k(  jK                  «       sJ |jH                  |jD                  f«       ‚|D ]B  }t        | jL                  jN                  |› d�d «      }|dv sŒ,||   jQ                  |«      ||<   ŒD |jS                  |«       �ŒE t        |«      dk(  r|d   }ntU        |d¬«      }tW        | |||¬«      }| jY                  |||¬«      }|S c c}}w # t2        $ ry}| j4                  dk(  r^t7        «       rTt9        |«      j;                  d«      r:t<        r4t1        |j                   ||dt?        dt&        j@                  ¬«      ¬«      }n‚ Y d }~�Œ‹d }~ww xY w)NrF  r   rg   r  r1   r›  T)Úinplacerc   rb   FrÐ  ri  rj  rk  rl  )r¸   rŸ   rº  r[  rÑ  r  r:  )ra   r`  r�  )r;  r¸   )-rA  r=  rl   r_  rÂ  r÷   r™  rx  rç  rè  r0   r1   Úfrom_tuplesÚ	set_namesr  r€   r€  r†  r`   rp  rq  r·  rØ  r:   r.   r~  r¤   r   ra   rù  r   r5   r  Ú_from_arraysr[  rŸ  Údtypesr|  ru   r†   r  r¥   r7   r:  r“  )ré   rm   r¸   rŽ   r�   rÌ   rÂ  rœ  rÕ  ÚindsÚindrŸ   Úframesr›   Ú
index_valsr™  r  r›  r�  Úindex_Úcols_rØ  rv  rL  r[  r;  s                             r\   r9  zAppendableFrameTable.readK  s•  € ð �‰Ô Øà—‘ u°EÀ�ÓEˆô �4×&Ñ&Ô'ð �I‰I�M‰M˜$×-Ñ-¨aÑ0°Ñ3°RÔ8àð 	ô  )¨¯©Ó3×P‘e�a˜°r¸T¿_¹_ÈQÑ=OÒ7O’ÐPˆÑPÜ�4‹y˜AŠ~Ðˆ~Ø�1‰gˆà�s‘˜A‘ˆàˆÜ˜dŸi™iÓ(ó =	‰DˆAˆqØ˜×(Ñ(Ñ(ØØ"(¨¡)ÑˆJ˜ð �x‰x˜Ó <Ò/Ü˜ZÓ(‘ä!×-Ñ-¨jÓ9�à—H‘H˜WÓ%ˆEØÐ Ø—‘˜u¨d�Ô3à×!Ò!Ø �Ø�Ü˜e¬'°%¸ÀÓ*FÔG‘à Ÿ™�Ü˜u¬7°5¸&À$Ó+GÔH�Ø�ð �{‰{˜aÒ¤J¨v´r·z±zÔ$BØŸ™¨¨F¯L©L¸©OÐ(<Ó=�ä˜&¤2§:¡:¬}Ð"=Ô>ðÜ" 6§8¡8°UÀ&ÈuÔU‘Bô" ˜F¤EÔ*Ü˜v¨u¸FÔC‘ô ×+Ñ+¨V¨H¸eÈ6ÔR�Ü&Ô(¨V¯\©\×->Ñ->À#Ò-EØŸ	™	 V§\¡\Ñ1×6Ñ6Ô8ÐS¸2¿9¹9ÀfÇlÁlÐ:SÓSÐ8ð  ò :�Ü §
¡
× 0Ñ 0°V°H¸EÐ2BÀDÓI�ØÐ-Ò-Ø!# F¡×!2Ñ!2°5Ó!9�B�v’Jð:ð �M‰M˜"Öð{=	ô~ ˆv‹;˜!ÒØ˜‘‰Bä˜ QÔ'ˆBä˜d¨%°uÀ4ÔHˆ	à×Ñ˜r¨YÀÐÓHˆØˆ	ùó] QøôN *ò àŸ™ Ò6Ü.Ô0Ü ›H×-Ñ-Ð.FÔGÝ'ä&Ø"ŸH™HØ$)Ø"(Ø!&Ü"-°hÌÏÉÔ"Pô™ð õ ûðús%   ÂM"ÂM"ÈM(Í(	O*Í1A.O%Ï%O*r  r¥  r\  r¦  )r  r  r  r  r2  rÈ  r†  r.   r5  r  r  r  r"  r@  r9  rÜ   r^   r\   rÜ  rÜ  8  so   … Ù2à€KØ#€JØ€DØ)2€HÐ&Ó2àò,ó ð,ð òó ðð ØØ Øðað ð	að
 ôar^   rÜ  c                  óz   ‡ — e Zd ZdZdZdZdZeZe	d	d„«       Z
ed
d„«       Zddˆ fd„Z	 	 	 	 d	 	 	 	 	 dˆ fd„Zˆ xZS )rÚ  r¬  rÐ  rÑ  r°  c                 ó   — yrË  rÜ   rî   s    r\   r  z#AppendableSeriesTable.is_transposed·  rÌ  r^   c                ó   — |S rY   rÜ   r?  s      r\   r@  z AppendableSeriesTable.get_object»  s   € àˆ
r^   c                ó¼   •— t        |t        «      s!|j                  xs d}|j                  |«      }t	        ‰| �  d||j                  j                  «       dœ|¤Ž y)ú+we are going to write this as a frame tabler�  ©ræ  r£   NrÜ   )r`   r.   rc   Úto_framerÒ  rë  r¸   r{  )ré   ræ  r£   rÈ   rc   rÓ  s        €r\   rë  zAppendableSeriesTable.writeÀ  sL   ø€ ä˜#œyÔ)Ø—8‘8Ò'˜xˆDØ—,‘,˜tÓ$ˆCÜ‰‰ÐK˜#¨C¯K©K×,>Ñ,>Ó,@ÑKÀFÓKr^   c                ób  •— | j                   }|�F|rDt        | j                  t        «      sJ ‚| j                  D ]  }||vsŒ|j	                  d|«       Œ t
        ‰| �  ||||¬«      }|r|j                  | j                  «      }|j                  d d …df   }|j                  dk(  rd |_	        |S )Nr   rS  r�  )
rø  r`   rš  rj   r�  rÒ  r9  Ú	set_indexÚilocrc   )	ré   rm   r¸   rŽ   r�   rø  r  r=  rÓ  s	           €r\   r9  zAppendableSeriesTable.readÇ  s­   ø€ ð ×,Ñ,ˆØÐ¡>Ü˜dŸk™k¬4Ô0Ð0Ð0Ø—[‘[ò )�Ø˜GÒ#Ø—N‘N 1 aÕ(ð)ô ‰G‰L˜u¨g¸UÈˆLÓNˆÙØ—‘˜DŸK™KÓ(ˆAà�F‰F’1�a�4‰Lˆð �6‰6�XÒØˆAŒFØˆr^   r  r¥  rY   r  r\  rÆ  )r  r  r  r  r2  rÈ  r†  r4   r5  r  r  r"  r@  rë  r9  r#  r$  s   @r\   rÚ  rÚ  ¯  s|   ø„ Ù2à €KØ$€JØ€DØ€Hàòó ðð òó ðöLð ØØ Øðð ð	ð
 ðð 
÷ñ r^   rÚ  c                  ó,   ‡ — e Zd ZdZdZdZdˆ fd„Zˆ xZS )rÛ  r¬  rÐ  rÒ  c                ó  •— |j                   xs d}| j                  |«      \  }| _        t        | j                  t        «      sJ ‚t	        | j                  «      }|j                  |«       t        |«      |_        t        ‰| �$  dd|i|¤Ž y)rÝ  r�  ræ  NrÜ   )
rc   rý  rš  r`   rj   r¥   r0   r¸   rÒ  rë  )ré   ræ  rÈ   rc   Únewobjr  rÓ  s         €r\   rë  z AppendableMultiSeriesTable.writeç  su   ø€ à�x‰xÒ#˜8ˆØ"×6Ñ6°sÓ;Ñˆ�”Ü˜$Ÿ+™+¤tÔ,Ð,Ð,Ü�D—K‘KÓ ˆØ�‰�DÔÜ˜t›ˆŒÜ‰‰Ñ+˜&Ð+ FÓ+r^   r  )r  r  r  r  r2  rÈ  rë  r#  r$  s   @r\   rÛ  rÛ  à  s   ø„ Ù2à €KØ)€J÷,ñ ,r^   rÛ  c                  ón   — e Zd ZU dZdZdZdZeZde	d<   e
dd„«       Ze
d„ «       Zdd	„Zed
„ «       Zdd„Zy)rÙ  z:a table that read/writes the generic pytables table formatrÉ  rÊ  r°  zlist[Hashable]rš  c                ó   — | j                   S rY   )r2  rî   s    r\   r£  zGenericTable.pandas_typeû  s   € à×ÑÐr^   c                óL   — t        | j                  dd «      xs | j                  S r  r  rî   s    r\   rQ  zGenericTable.storableÿ  s   € ä�t—z‘z 7¨DÓ1Ò?°T·Z±ZÐ?r^   c                óN  — g | _         d| _        g | _        | j                  D �cg c]  }|j                  sŒ|‘Œ c}| _        | j                  D �cg c]  }|j                  rŒ|‘Œ c}| _        | j                  D �cg c]  }|j                  ‘Œ c}| _        yc c}w c c}w c c}w )ry  N)	r_  r¡   rš  r#  r'  rç  rè  rc   r£   r  s     r\   rN  zGenericTable.get_attrs  s~   € à ˆÔØˆŒØˆŒà&*§o¡oÖK ¸×9JÓ9Jš1ÒKˆŒØ'+§¡ÖP !¸a×>OÓ>OšAÒPˆÔØ-1×-=Ñ-=Ö>¨˜QŸV›VÒ>ˆÕùò LùÚPùÚ>s   ¤B¶BÁBÁ"BÁ<B"c           
     ó†  — | j                   }| j                  d«      }|�dnd}t        dd| j                  ||¬«      }|g}t	        |j
                  «      D ]h  \  }}t        |t        «      sJ ‚t        ||«      }| j                  |«      }|�dnd}t        |||g|| j                  ||¬«      }	|j                  |	«       Œj |S )z0create the indexables from the table descriptionrŸ   NrY  r   )rc   rT  ru   rÏ   r1  )rc   r0  r�  r.  ru   rÏ   r1  )r“  rÀ  rÉ  ru   r™  Ú_v_namesr`   ra   r€   r/  r¥   )
ré   r‘  r*  rÏ   r2  r0  rœ  r  rî  r™  s
             r\   r#  zGenericTable.indexables  sß   € ð ×Ñˆð
 ×Ñ Ó(ˆØ˜^‰z°ˆÜ#Ø˜q¨¯
©
¸Èô
ˆ	ð IRÀ{ˆä˜aŸj™jÓ)ò 	#‰DˆAˆqÜ˜a¤Ô%Ð%Ð%ä˜1˜a“=ˆDØ×#Ñ# AÓ&ˆBØ!# ‘:°TˆDÜ(ØØØ�sØØ—j‘jØØôˆBð ×Ñ˜rÕ"ð	#ð" Ðr^   c                ó   — t        d«      ‚)Nzcannot write on a generic tablerW  )ré   rÈ   s     r\   rë  zGenericTable.write1  s   € Ü!Ð"CÓDÐDr^   Nr  r  )r  r  r  r  r2  rÈ  r†  r.   r5  r  r  r£  rQ  rN  r   r#  rë  rÜ   r^   r\   rÙ  rÙ  ò  sg   … ÙDà€KØ €JØ€DØ€HØÓàò ó ð ð ñ@ó ð@ó?ð ñ ó ð ôFEr^   rÙ  c                  óˆ   ‡ — e Zd ZdZdZeZdZ ej                  d«      Z
edd„«       Zd	d
ˆ fd„Z	 	 	 	 d	 	 	 	 	 dˆ fd„Zˆ xZS )rÝ  za frame with a multi-indexrÔ  r°  z^level_\d+$c                 ó   — y)NÚappendable_multirÜ   rî   s    r\   rê  z*AppendableMultiFrameTable.table_type_short=  s   € à!r^   c                ó*  •— |€g }n|du r|j                   j                  «       }| j                  |«      \  }| _        t	        | j                  t
        «      sJ ‚| j                  D ]  }||vsŒ|j                  d|«       Œ t        ‰| �   d||dœ|¤Ž y )NTr   rÞ  rÜ   )	r¸   r{  rý  rš  r`   rj   r�  rÒ  rë  )ré   ræ  r£   rÈ   r  rÓ  s        €r\   rë  zAppendableMultiFrameTable.writeB  s–   ø€ ØÐØ‰LØ˜TÑ!ØŸ;™;×-Ñ-Ó/ˆLØ×3Ñ3°CÓ8ÑˆˆTŒ[Ü˜$Ÿ+™+¤tÔ,Ð,Ð,Ø—‘ò 	*ˆAØ˜Ò$Ø×#Ñ# A qÕ)ð	*ô 	‰‰ÐC˜#¨LÑC¸FÓCr^   c                ó,  •— t         ‰| �  ||||¬«      }|j                  | j                  «      }|j                  j                  |j                  j                  D �cg c]!  }| j                  j                  |«      rd n|‘Œ# c}«      |_        |S c c}w )NrS  )	rÒ  r9  rá  rš  rŸ   rÐ  r›  Ú
_re_levelsÚsearch)ré   rm   r¸   rŽ   r�   rØ  rc   rÓ  s          €r\   r9  zAppendableMultiFrameTable.readN  s~   ø€ ô ‰W‰\ ¨w¸eÈ$ˆ\ÓOˆØ�\‰\˜$Ÿ+™+Ó&ˆð —8‘8×%Ñ%ØHJÏÉÏÉÖWÀ�T—_‘_×+Ñ+¨DÔ1‰T°tÑ;ÒWó
ˆŒð ˆ	ùò Xs   Á&Br  rY   r  r\  râ  )r  r  r  r  rÈ  r.   r5  r†  ÚreÚcompilerò  r  rê  rë  r9  r#  r$  s   @r\   rÝ  rÝ  5  ss   ø„ Ù$à(€JØ€HØ€DØ�—‘˜NÓ+€Jàò"ó ð"ö
Dð ØØ Øðð ð	ð
 ðð 
÷ñ r^   rÝ  c                ó¾  — | j                  |«      }t        |«      }|�t        |«      }|�|j                  |«      r|j                  |«      r| S t        |j                  «       «      }|�*t        |j                  «       «      j	                  |d¬«      }|j                  |«      s7t        d d «      g| j                  z  }|||<   | j                  t        |«         } | S )NF)Úsort)	r‡  rC   ÚequalsÚuniquerŽ  rŒ   r†  r�  rk   )ræ  rT  r’  rN  rÕ  Úslicers         r\   rY  rY  `  sÈ   € ð 
�‰�tÓ	€BÜ˜&Ó!€Fð ÐÜ˜UÓ#ˆØˆ˜Ÿ™ uÔ-°6·=±=ÀÔ3DØˆ
ä˜&Ÿ-™-›/Ó*€FØÐÜ˜eŸl™l›nÓ-×:Ñ:¸6ÈÐ:ÓNˆØ�=‰=˜ÔÜ',¨T°4Ó'8Ð&9¸C¿H¹HÑ&DˆØˆˆt‰Ø�g‰g”e˜F“mÑ$ˆØ€Jr^   c                ó0   — t        j                  | «      }|S )z+for a tz-aware type, return an encoded zone)r   Úget_timezone)r+  Úzones     r\   r“  r“  z  s   € ä×!Ñ! "Ó%€DØ€Kr^   c                óR   — |€|�t        d| › d�«      ‚|�|€t        d| › d�«      ‚yy)a0  
    Raise if an append would add or drop the timezone of a stored column.

    The read path localizes the whole stored column with this single tz, so
    changing it reinterprets the rows already written. update_info raises only
    when both sides are set, leaving the None cases silent. GH#68583
    Nz-cannot append tz-aware data to tz-naive col [rQ  z-cannot append tz-naive data to tz-aware col [rt  )rc   Úexisting_tzr+  s      r\   rX  rX  €  sJ   € ð Ð˜r˜~ÜÐGÈÀvÈQÐOÓPÐPØÐ 2 :ÜÐGÈÀvÈQÐOÓPÐPð $.Ðr^   c                óÖ   — | j                   dk(  sJ | j                   «       ‚t        j                  |«      \  }}t        d|«      }t	        ||¬«      }t        j                  | |¬«      }|S )zá
    Coerce the values to a DatetimeArray with appropriate tz.

    Parameters
    ----------
    values : ndarray[int64]
    tz : str, tzinfo, or None
    datetime64_dtype : str, e.g. "datetime64[ns]", "datetime64[25s]"
    rd  rT   )r+  r»  rZ  )r[  rp  Údatetime_datar   r<   r:   Ú_from_sequence)r�  r+  Údatetime64_dtyper»  r‘   r[  rm  s          r\   r  r  �  sg   € ð �<‰<˜4ÒÐ- §¡Ó-Ðô ×ÑÐ/Ó0�G€Dˆ!Ü�
˜DÓ!€Dô ˜2 DÔ)€EÜ
×
&Ñ
& v°UÔ
;€CØ€Jr^   c                ó(   — t        | |d«      }|xs dS )an  
    Read back the NaN sentinel persisted for a string Index column (GH#9604).

    The writer records the attribute for every string Index, empty when the
    index had no missing value, so its absence means the file predates the
    sentinel. Such a file stored a NaN as the bare string "nan", which is how
    pandas read it back before the sentinel existed.
    r  NrL  )r†   rc   r¡   s      r\   r¥  r¥  ¨  s   € ô �e˜T 5Ó)€GØŠ?�dÐr^   c           	     ó<  — | |    }t        j                  |d¬«      dk7  r:t        j                  |D �cg c]  }t	        |t
        «      sŒ|‘Œ c}t        ¬«      }d}||k(  j                  «       s|�%||v r!d|› d�}||k(  j                  «       rŒ|�||v rŒ!|S c c}w )a«  
    Choose a string NaN sentinel for a string column that does not collide with
    any non-missing value, so genuine missing values round-trip without being
    confused with a literal string such as ``"nan"`` (GH#9604).

    ``existing`` holds values already stored for this column in a prior
    ``table``-format append; the sentinel must avoid those too, since a single
    sentinel is persisted for the whole column.
    Tr­  r`  rZ  r  r‘   )r   r¹  rp  rA   r`   ra   rÅ  ru  )r�  rƒ  ÚexistingÚnon_missingrš  r¡   s         r\   Ú_make_nan_repr  µ  sª   € ð ˜$˜‘-€KÜ
‡��{¨4Ô0°HÒ<ô
 —h‘hØ'Ö@�S¬:°c¼3Õ+?ŠSÒ@Ìô
ˆð €GØ˜'Ñ!×
&Ñ
&Ô
(ØÐ ¨HÑ!4à�g�Y˜a�.ˆð ˜'Ñ!×
&Ñ
&Õ
(ØÐ ¨HÒ!4ð €Nùò As   ´BÁ
Bc                ó„   — t        | j                  |«      dd }t        |d||¬«      }t        |j	                  «       «      S )z‘
    Read the values already stored for a string column (GH#9604), so a NaN
    sentinel chosen for a later append cannot collide with them.
    Nr  )r€   r  r  r„  rs  )ru   r/  r[   r¤   ÚrawÚdecodeds         r\   rS  rS  Ò  s?   € ô
 �%—*‘*˜eÓ
$¡QÐ
'€CÜ%Ø�T H°Vô€Gô ˆw�}‰}‹ÓÐr^   c                óà  — t        | j                  t        «      r| j                  «       } | j                  t        k7  ryt        j                  | «      }|j                  d«      }t        |«      }|�|j                  nd}	|j                  «       r:|	€8d}
|�'|j                  dk(  rt        ||j                  ||«      }
t        |||
«      }	|	�¢t        j                   |d¬«      dk(  rˆ||    |	k(  j                  «       rq||	k(  t        |«       z  }|j"                  dk(  r.t%        t        j&                  |j                  d¬«      «      «      nd	}||   }t)        d
t+        |	«      ›d|› d�«      ‚|	S )a   
    Choose the NaN sentinel for a string data column, mirroring the string-Index
    handling (GH#9604): reuse the sentinel already persisted for the column,
    otherwise mint a collision-free one, and only when the column actually has a
    missing value. Returns None when no sentinel is needed (a literal "nan" then
    round-trips because the read path skips substitution when the sentinel is
    absent).
    Nr\  r`  Tr­  r°  rg   r�  r   úCannot store the string z in column [zF]: it collides with the sentinel used to encode missing values on disk)r`   r[  r5   r´  rÅ  rp  r  r·  r8   r¡   ru  rŸ  rS  r/  r  r   r¹  r†  r  Úargmaxr„   ra   )Ú
blk_valuesr¸   rO  ru   r[   r¤   r�  Úflatrƒ  r¡   rK  Úcollidesr0  Úlabels                 r\   r\  r\  ß  sh  € ô  �*×"Ñ"¤KÔ0Ø×(Ñ(Ó*ˆ
Ø×Ñœ6Ò!Øä�Z‰Z˜
Ó#€FØ�>‰>˜"Ó€DÜ�‹:€DØ&2Ð&>ˆl×"Ò"ÀD€GØ‡x�x„z�g�oØˆØÐ#¨×(9Ñ(9¸XÒ(EÜ8Ø�|×)Ñ)¨8°VóˆOô    d¨OÓ<ˆàÐô �O‰O˜D¨Ô.°(Ò:Ø�4�%‰[˜GÑ#×(Ñ(Ô*ð ˜gÑ%¬$¨v«,¨Ñ6ˆà6>·m±mÀqÒ6HŒc”"—)‘)˜HŸL™L¨a˜LÓ0Ó1Ô2ÈaˆØ˜‘ˆÜØ&¤s¨7£|Ð&6°lÀ5À'ð JOð Oó
ð 	
ð €Nr^   c                óü  — t        | t        «      sJ ‚|j                  }t        |j                  t        «      rct        |j                  «      sNt        |j                  «      s9t        |j                  t        t        f«      st        d|j                  › d�«      ‚t        |j                  t        «      rŒt        d|j                  «      }t        |«      \  }}	t        |	«      }
t        j                  |«      }t!        | ||
||dt#        j$                  |j&                  «      j)                  «       |j*                  ¬«      S t        |«      \  }}	t        |	«      }
t        j                  |«      }t-        j.                  |j                  d«      s*t        |j                  «      st        |j                  «      r(t!        | ||
|t1        |dd «      t1        |dd «      |¬	«      S t        |t2        «      rt5        d
«      ‚t-        j6                  |d¬«      }t#        j$                  |«      }|dk(  rgt#        j$                  |D �cg c]  }|j9                  «       ‘Œ c}t"        j:                  ¬«      }t!        | |dt=        «       j?                  «       |¬«      S |dk(  rèt#        j$                  |jA                  «       «      }|}|jC                  «       r|€tE        |||«      }|�W||    |k(  jC                  «       rtG        dt        |«      ›d| › d�«      ‚|jC                  «       r|jI                  «       }|||<   tK        |||«      }|j                  jL                  }t!        | |dt=        «       jO                  |«      ||¬«      S |dv rt!        | ||
||¬«      S t        |t"        jP                  «      r|j                  tR        k(  sJ ‚|
dk(  sJ |
«       ‚t=        «       jU                  «       }t!        | ||
||¬«      S c c}w )Nz!Cannot store an Index with dtype rä  r9   rY  )r�  rŸ  r.  r,  rÏ   r1  r•  Úiur*  r+  )r�  rŸ  r.  r*  r+  r,  zMultiIndex not supported here!Fr­  r   rZ  )r,  r`  r  z in Index column [zM]: it collides with the sentinel used to encode missing values in this column)r,  r¡   )rL  Úfloating)r�  rŸ  r.  r,  rÅ  )+r`   ra   rc   r[  r*   r'   r#   r5   r(   r¾   r   r�  rÜ  rÝ  r&  rï  r&  rp  r  r^  rs  r•  r   r|  r€   r1   r…   r¹  Ú	toordinalÚint32rš   Ú	Time32Colr8   ru  r  r„   rº  Ú_convert_string_arrayr4  rœ  rq  rÅ  r³  )rc   rŸ   r[   r¤   rJ  rK  r,  r…  r  rÞ  rŸ  rî  r¿  r�  r”  rƒ  r¡   r4  s                     r\   r’  r’    s‘  € ô �dœCÔ Ð Ð à—‘€Jô 	�5—;‘;¤Ô/Ü# E§K¡KÔ0Ü˜eŸk™kÔ*Ü˜5Ÿ;™;¬Ô6FÐ(GÔHä!Ø/°·±¨}ð =7ð 7ó
ð 	
ô �%—+‘+Ô/Ô0ô �= %§-¡-Ó0ˆÜ 8¸Ó =Ñˆ	�:Ü˜jÓ)ˆÜ×)Ñ)¨)Ó4ˆÜØØØØØ!ØÜ—Z‘Z §¡Ó/×5Ñ5Ó7Ø—K‘Kô	
ð 		
ô 5°UÓ;Ñ€IˆzÜ˜*Ó%€DÜ×%Ñ% iÓ0€Dô 	�‰˜Ÿ™ TÔ*Ü˜uŸ{™{Ô+Ü˜Ÿ™Ô%ô
 ØØØØÜ˜ ¨Ó-Ü�u˜d DÓ)Ø!ô
ð 	
ô �%œÔ$ÜÐ8Ó9Ð9ä—O‘O E°%Ô8€Mô �Z‰Z˜Ó€Fà˜ÒÜ—J‘J°vÖ>°! §¡¥Ò>ÄbÇhÁhÔOˆ	ÜØ�)˜V¤W£Y×%8Ñ%8Ó%:Àzô
ð 	
ð 
˜(Ò	"ô �z‰z˜%Ÿ*™*›,Ó'ˆð
 #ˆØ�8‰8Œ:˜'˜/Ü# F¨D°/ÓBˆGØÐØ˜�u‘ Ñ(×-Ñ-Ô/ô !Ø.¬s°7«|Ð.>ð ?Ø�vð 4ð4óð ð
 �x‰xŒzØŸ™›�Ø&��t‘Ü)¨&°(¸FÓCˆ	Ø—?‘?×+Ñ+ˆÜØØØÜ‹I×Ñ Ó)Ø!Øô
ð 	
ð 
Ð1Ñ	1ÜØ˜¨°4ÀJô
ð 	
ô ˜)¤R§Z¡ZÔ0°Y·_±_ÌÒ5NÐNÐNØ�xÒÐ% Ó%ÐÜ‹y×#Ñ#Ó%ˆÜ˜˜i¨¨tÀ
ÔKÐKùòe  ?s   ÉO9c           	     óþ  — |j                  d«      r2|dk(  rt        | d¬«      }|S t        | j                  |«      d¬«      }|S |j                  d«      r2|dk(  rt        | d¬«      }|S t        | j                  |«      d¬«      }|S |dk(  r?	 t	        j
                  | D �cg c]  }t        j                  |«      ‘Œ c}t        ¬«      }|S |dv rt	        j
                  | «      }|S |dv rt        | |||¬	«      }|S |d
k(  rt	        j
                  | d   «      }|S t        d|› �«      ‚c c}w # t        $ rF t	        j
                  | D �cg c]  }t        j                  |«      ‘Œ nc c}w c}t        ¬«      }Y |S w xY w)Nr  Fr  rb  r   rZ  )rL  Úfloatrƒ   r`  r  rÅ  r   zunrecognized index type )r°  r/   r}  r6   rp  r  r   r  rÅ  r„   r  r  )r¹  rŸ  r[   r¤   r¡   rŸ   r”  s          r\   r¦  r¦  œ  s�  € ð
 ‡��|Ô$Ø�<Òä! $¨UÔ3ˆEð0 €Lô- " $§)¡)¨D£/¸Ô>ˆEð, €Lð+ 
�‰˜Ô	'Ø�=Ò ä" 4¨eÔ4ˆEð$ €Lô! # 4§9¡9¨T£?¸Ô?ˆEð  €Lð 
�Šð	TÜ—J‘J¸TÖB¸¤× 0Ñ 0°Õ 3ÒBÌ&ÔQˆEð €Lð 
Ð-Ñ	-Ü—
‘
˜4Ó ˆð €Lð 
�(Ñ	Ü'Ø˜'¨H¸Vô
ˆð €Lð	 
�Ò	Ü—
‘
˜4 ™7Ó#ˆð €Lô Ð3°D°6Ð:Ó;Ð;ùò  CøÜò 	TÜ—J‘J¸tÖD¸!¤× 2Ñ 2°1Õ 5ÑDùÔDÌFÔS‰Eð €Lð	Tús0   ÂD- Â D(Â<D- Ä(D- Ä-E<Å	E&
Å%E<Å;E<c           	     ó¶  — t        |j                  t        «      r|j                  «       }|j                  t        k7  r|S t        d|«      }|j                  j                  }t        j                  |d¬«      }	|	dk(  rt        d«      ‚|	dk(  rt        d«      ‚|	dk(  s|d	k(  s|S t        |«      }
|j                  «       }|||
<   |rY|
j                  «       rIt        |«      |j                  kD  r1t        d
t!        |«      ›dt        |«      › d|j                  › d�«      ‚t        j                  |d¬«      }	|	dk7  rht#        |j$                  d   «      D ]M  }||   }t        j                  |d¬«      }	|	dk7  sŒ%t        |«      |kD  r||   nd|› �}t        d|› d|	› d�«      ‚ t'        |||«      j)                  |j$                  «      }|j                  }t        |t*        «      r1t-        |j/                  | «      xs |j/                  d«      xs d«      }t1        |xs d|«      }|�|j3                  |«      }|�||kD  r|}|j5                  d|› �d¬«      }|S )NrÆ  Fr­  r   z+[date] is not implemented as a table columnr`  z>too many timezones in this block, create separate data columnsr`  rÅ  z:NaN representation is too large for existing column size: z has length z  but this column has a limit of zn!
It can be longer than the values themselves. Recreate the table passing min_itemsize to reserve room for it.r   zNo.rñ  z2]
because its data contents are not [string] but [rò  r�  z|Sr  )r`   r[  r5   r´  rÅ  r   rc   r   r¹  r…   r8   rº  ru  rl   r4  r„   ra   r…  rØ  r  r·  r‚  r  r÷   r–  r¢  r  )rc   r»  rO  r    r¡   r[   r¤   r¸   rÞ  r¿  rƒ  r¹  rœ  r–  Úerror_column_labelrs  r4  Úecis                     r\   r]  r]  ¿  sq  € ô �'—-‘-¤Ô-Ø×"Ñ"Ó$ˆØ‡}�}œÒØˆä�< Ó)€Gà—‘×#Ñ#€JÜ—O‘O G°EÔ:€Mà˜ÒÜÐEÓFÐFØ˜
Ò"ô ØLó
ð 	
ð ˜XÒ%¨°xÒ)?Øˆä�‹=€DØ�<‰<‹>€DØ€Dˆ�Já˜Ÿ™œ
¤s¨7£|°l×6KÑ6KÒ'KÜØHÜ�7‹|Ð˜l¬3¨w«<¨.ð 9Ø$×-Ñ-Ð.ð /;ð;ó
ð 	
ô —O‘O D°Ô7€MØ˜Ò ô �t—z‘z !‘}Ó%ò 		ˆAØ�q‘'ˆCÜŸO™O¨C¸Ô>ˆMØ Ó(Ü36°w³<À!Ò3C W¨Q¢ZÈ3ÈqÈcÈÐ"ÜØ3Ð4FÐ3Gð Hà%� nð6óð ð		ô +¨4°¸6ÓB×JÑJÈ4Ï:É:ÓV€NØ×&Ñ&€Hô �,¤Ô%Ü˜<×+Ñ+¨DÓ1ÒT°\×5EÑ5EÀhÓ5OÒTÐSTÓUˆÜ�<Ò$ 1 hÓ/€Hð ÐØ×'Ñ'¨Ó1ˆØˆ?˜s Xš~ØˆHà#×*Ñ*¨R°¨z¨?ÀÐ*ÓG€NØÐr^   c                ór  — t        | «      rYt        | j                  «       dd¬«      j                  j	                  ||«      j
                  j                  | j                  «      } t        | j                  «       «      }t        dt        j                  |«      «      }t        j                  | d|› �¬«      } | S )a  
    Take a string-like that is object dtype and coerce to a fixed size string type.

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

    Returns
    -------
    np.ndarray[fixed-length-string]
    FrÅ  )rº  r[  rg   ÚSrZ  )rl   r4   rs  ra   rR  r�  r·  rØ  r"   r–  Ú
libwritersÚmax_len_string_arrayrp  r  )r¹  r[   r¤   Úensuredr4  s        r\   r  r    sˆ   € ô  ˆ4„yä�4—:‘:“< e°8Ô<ß‰S—‘˜ &Ó)ß‰W—W‘W˜TŸZ™ZÓ(ð 	ô ˜DŸJ™J›LÓ)€GÜ�1”j×5Ñ5°gÓ>Ó?€Hä�:‰:�d A h Z .Ô1€DØ€Kr^   c                ó&  — | j                   }t        j                  | j                  «       t        ¬«      } t        | «      r©t        j                  t        | «      «      }d|› �}t        | d   t        «      rKt        | d¬«      j                  j                  ||d¬«      }|j                  «       } d| j                  _        n(| j#                  |d¬«      j#                  t        d¬«      } |�t        j$                  | |«       | j'                  |«      S )	a  
    Inverse of _convert_string_array.

    Parameters
    ----------
    data : np.ndarray[fixed-length-string]
    nan_rep : the storage repr of NaN, or None to skip substitution.
        Pass None when the writer did not encode NaN as a sentinel string;
        otherwise legitimate occurrences of the sentinel value would be
        incorrectly replaced with NaN on read.
    encoding : str
    errors : str
        Handler for encoding errors.

    Returns
    -------
    np.ndarray[object]
        Decoded data.
    rZ  ÚUr   Fr  rÅ  )r¤   r[  T)rØ  rp  r  rs  rÅ  rl   r!  r"  r"   r`   rp  r4   ra   Údecoder´  r  Ú	writeabler  Ú!string_array_replace_from_nan_repr·  )r¹  r¡   r[   r¤   rØ  r4  r[  Úsers           r\   r  r  2  sá   € ð, �J‰J€EÜ�:‰:�d—j‘j“l¬&Ô1€Dä
ˆ4„yÜ×2Ñ2´=ÀÓ3FÓGˆØ�H�:�ˆä�d˜1‘gœuÔ%Ü˜ EÔ*×.Ñ.×5Ñ5Ø ¨xð 6ó ˆCð —<‘<“>ˆDØ#'ˆD�J‰JÕ à—;‘;˜u¨5�;Ó1×8Ñ8¼ÀeÐ8ÓLˆDàÐÜ×4Ñ4°T¸7ÔCØ�<‰<˜ÓÐr^   c                óˆ   — t        |t        «      sJ t        |«      «       ‚t        |«      rt	        ||||«      } || «      } | S rY   )r`   ra   r  Ú_need_convertÚ_get_converter)r�  r‡  r[   r¤   r¡   Úconvs         r\   r{  r{  ]  sC   € ô �h¤Ô$Ð4¤d¨8£nÓ4Ð$Ü�XÔÜ˜h¨°&¸'ÓBˆÙ�f“ˆØ€Mr^   c                ó`   ‡ ‡‡‡— ‰ dk(  rd„ S d‰ v rˆ fd„S ‰ dk(  rˆˆˆfd„S t        d‰ › �«      ‚)Nr  c                ó0   — t        j                  | d¬«      S )NzM8[ns]rZ  ©rp  r  )rc  s    r\   r©   z _get_converter.<locals>.<lambda>i  s   € œŸ™ A¨XÔ6€ r^   c                ó2   •— t        j                  | ‰¬«      S )NrZ  r0  )rc  rŸ  s    €r\   r©   z _get_converter.<locals>.<lambda>k  s   ø€ œŸ™ A¨TÔ2€ r^   r`  c                ó"   •— t        | ‰‰‰¬«      S )Nr  )r  )rc  r[   r¤   r¡   s    €€€r\   r©   z _get_converter.<locals>.<lambda>m  s   ø€ Ô0Ø�w¨¸&ô
€ r^   zinvalid kind )r„   )rŸ  r[   r¤   r¡   s   ````r\   r,  r,  g  sE   û€ Øˆ|ÒÙ6Ð6Ø	˜Ñ	Û2Ð2Ø	�Ò	õ
ð 	
ô ˜=¨¨Ð/Ó0Ð0r^   c                ó   — | dv sd| v ryy)N)r  r`  r  TFrÜ   rå  s    r\   r+  r+  t  s   € ØÐ'Ñ'¨<¸4Ñ+?ØØr^   c                ó¾  — | j                  d«      rd}|S | j                  d«      rd}|S | j                  d«      rd}|S | j                  d«      rd}|S | j                  d«      r| }|S | j                  d«      r| }|S | j                  d	«      rd	}|S | j                  d
«      rd
}|S | j                  d«      rd}|S | dk(  rd}|S | dk(  rd}|S t        d| › d�«      ‚)zA
    Find the "kind" string describing the given dtype name.
    )r`  rp  r`  r  r4  )r  rô  rL  r  Ú	timedeltarƒ   rY  r÷  rÅ  ra   zcannot interpret dtype of [rQ  )r°  r„   )Ú	dtype_strrŸ  s     r\   rÝ  rÝ  z  sB  € ð ×ÑÐ/Ô0Øˆð2 €Kð1 
×	Ñ	˜gÔ	&Øˆð. €Kð- 
×	Ñ	˜iÔ	(Øˆð* €Kð) 
×	Ñ	˜oÔ	.Øˆð& €Kð% 
×	Ñ	˜lÔ	+Øˆð" €Kð! 
×	Ñ	˜kÔ	*Øˆð €Kð 
×	Ñ	˜fÔ	%Øˆð €Kð 
×	Ñ	˜jÔ	)Øˆð €Kð 
×	Ñ	˜hÔ	'àˆð €Kð 
�hÒ	Øˆð €Kð 
�eÒ	Øˆð €Kô Ð6°y°kÀÐCÓDÐDr^   c                óÀ  — t        | t        «      r| j                  } t        | j                  t        «      rd| j                  j
                  › d�}n| j                  j                  }| j                  j                  dv r%t        j                  | j                  d«      «      } n"t        | t        t        f«      r| j                  } t        j                  | «      } | |fS )zJ
    Convert the passed data into a storable form and a dtype string.
    r±  rQ  ÚmMrd  )r`   r9   r‚  r[  r)   r»  rc   rŸ  rp  r  r}  r2   r;   rº  )r¹  rÞ  s     r\   rÜ  rÜ  ›  s¢   € ô �$œÔ$Ø�z‰zˆä�$—*‘*œoÔ.à" 4§:¡:§?¡?Ð"3°1Ð5‰
à—Z‘Z—_‘_ˆ
à‡z�z‡�˜$ÑÜ�z‰z˜$Ÿ)™) D›/Ó*‰ô 
�Dœ;¬Ð4Ô	5Ø�y‰yˆä�:‰:�dÓ€DØ�ÐÐr^   c                óL   ‡‡‡— t        «       Šdˆˆfd„Šdˆˆfd„Š ‰| «       ‰S )aÍ  
    Look for an OR with at least one AND operand, e.g. ``(A & B) | (C & D)``
    or ``(A & B) | C``, in a pruned PyTables condition tree. The AND operand
    need not span two columns -- ``(A > 1 & A < 5) | B`` counts too.

    This is the query shape that can trigger an upstream PyTables bug where
    index-accelerated reads silently drop matching rows (GH#50598). Return the
    set of column names referenced by the AND-ed operands of such an OR, or an
    empty set if the pattern is not present.

    Only the AND-ed operands matter: the bug needs one of *their* columns to be
    indexed. Indexing a column that appears solely as a bare OR operand (the
    ``C`` of ``(A & B) | C``) does not trigger it.
    c                óº   •— t        | t        «      s&‰j                  | j                  j                  «       y ‰| j                  «        ‰| j
                  «       y)z0Add every column name referenced under ``node``.N)r`   r>   ÚaddÚlhsr‡   Úrhs)r  Úcollectr  s    €€r\   r>  z$_or_of_ands_columns.<locals>.collectÅ  s=   ø€ ä˜$Ô 3Ô4à�H‰H�T—X‘X—^‘^Ô$ØÙ�—‘ÔÙ�—‘Õr^   c                ó  •— t        | t        «      sy | j                  dk(  rF| j                  | j                  fD ]+  }t        |t        «      sŒ|j                  dk(  sŒ$ ‰|«       Œ-  ‰| j                  «        ‰| j                  «       y )Nú|ú&)r`   r>   r‹  r<  r=  )r  Úoperandr>  Úvisits     €€r\   rC  z"_or_of_ands_columns.<locals>.visitÎ  sn   ø€ Ü˜$Ô 3Ô4ØØ�7‰7�cŠ>Ø ŸH™H d§h¡hÐ/ò %�Ü˜gÔ':Õ;ÀÇ
Á
ÈcÓ@QÙ˜GÕ$ð%ñ 	ˆd�h‰hŒÙˆd�h‰h�r^   r  )r„  )Ú	conditionr>  r  rC  s    @@@r\   Ú_or_of_ands_columnsrE  ´  s%   ú€ ô “U€Dööñ 
ˆ)ÔØ€Kr^   c                  ón   — e Zd ZdZ	 	 	 d
	 	 	 	 	 	 	 dd„Zdd„Zedd„«       Zedd„«       Zdd„Zd„ Zd	„ Z	y)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

    Nc           	     óŽ  — || _         || _        || _        || _        d | _        d | _        d | _        d | _        t        |«      �r*t        j                  |d¬«      }|dv �rt        j                  |«      }t        | j                  | j                  | j                   j                  «      \  }}|j                  t        j                   k(  rt        j"                  ||«      |   | _        n…t%        |j                  j&                  t        j(                  «      rW|||k  ||k\  z     }t+        |«      r7t-        d|d d j/                  «       › t+        |«      dkD  rdnd› d|› d	|› �«      ‚|| _        | j                  €K| j1                  |«      | _        | j                  �(| j                  j3                  «       \  | _        | _        y y y )
NFr­  )rL  Úbooleanz=where must have index locations >= start and < stop, but got é   z ...r»  z with start=z
 and stop=)ru   rm   rŽ   r�   rD  r‘  ÚtermsrY  r%   r   r¹  rp  r  r’   r�   r[  Úbool_rw  Ú
issubclassr  rL  rl   r„   r{  ÚgenerateÚevaluate)ré   ru   rm   rŽ   r�   ÚinferredÚinvalids          r\   rë   zSelection.__init__è  s�  € ð ˆŒ
ØˆŒ
ØˆŒ
ØˆŒ	ØˆŒØˆŒØˆŒ
ØˆÔä˜Õä—‘ u°UÔ;ˆHØÐ1Ò1ÜŸ
™
 5Ó)�ô 2Ø—J‘J §	¡	¨4¯:©:×+;Ñ+;ó‘��tð —;‘;¤"§(¡(Ò*Ü')§y¡y°¸Ó'=¸eÑ'D�DÕ$Ü §¡× 0Ñ 0´"·*±*Ô=Ø# U¨U¡]°uÀ±}Ñ$EÑF�GÜ˜7”|Ü(ð'Ø'.¨r° {×'9Ñ'9Ó';Ð&<Ü),¨W«¸Ò)9™v¸rÐBð C*Ø*/¨°
¸4¸&ðBóð ð (-�DÔ$à×ÑÐ#ØŸ™ uÓ-ˆDŒJð �z‰zÐ%Ø.2¯j©j×.AÑ.AÓ.CÑ+�” ¥ð &ð	 $r^   c                óÖ   ‡— t        | j                  dd«      Š‰€yt        | j                  «      }t	        ˆfd„|D «       «      syt        j                  dt        t        «       ¬«       y)až  
        Warn for nested-OR queries with AND-ed operands over indexed columns
        (e.g. ``(A & B) | (C & D)``) that can return incorrect results due to
        an upstream PyTables bug (GH#50598).

        Called from the query methods rather than ``__init__``: one read builds
        several ``Selection`` objects for the same ``where``, and only the one
        that runs the condition should warn.
        ru   Nc              3  ól   •K  — | ]+  }|‰j                   v r‰j                  |   j                  –— Œ- y ­wrY   )ÚcolnamesÚcolinstancesrµ  )r~  rc   ru   s     €r\   r€  z3Selection._warn_if_unreliable_or.<locals>.<genexpr>$  s6   øè ø€ ò 
àØ�u—~‘~Ñ%ð ×Ñ˜tÑ$×/Õ/ñ
ùs   ƒ14a*  Querying with a nested 'where' that ORs AND-ed conditions over indexed columns (e.g. '(A & B) | (C & D)') can silently match the wrong rows due to an upstream PyTables bug (GH#50598). To get correct results, write the table with 'index=False', or split the 'where' into one operation per OR branch.rÚ   )	r€   ru   rE  rD  ru  rà   rá   râ   r!   )ré   r  ru   s     @r\   Ú_warn_if_unreliable_orz Selection._warn_if_unreliable_or  sc   ø€ ô ˜Ÿ
™
 G¨TÓ2ˆØˆ=ØÜ" 4§>¡>Ó2ˆÜó 
àô
ô 
ð
 Ü�‰ð8ô
 Ü'Ó)ö	
r^   c                 ó   — y rY   rÜ   ©ré   rm   s     r\   rM  zSelection.generate4  s   € ØJMr^   c                 ó   — y rY   rÜ   rW  s     r\   rM  zSelection.generate7  s   € Ø-0r^   c                ó  — |€y| j                   j                  «       }	 t        ||| j                   j                  ¬«      S # t        $ rB}dj                  |j                  «       «      }t        d|› d|› d�«      }t        |«      |‚d}~ww xY w)z'where can be a : dict,list,tuple,stringN)r  r[   rB  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
                )	ru   r  r?   r[   Ú	NameErrorrE  r  r   r„   )ré   rm   r%  rv  Úqkeysr}   s         r\   rM  zSelection.generate:  sœ   € àˆ=Øà�J‰J×!Ñ!Ó#ˆð	+Ü °!¸d¿j¹j×>QÑ>QÔRÐRøÜò 	+ð —H‘H˜QŸV™V›XÓ&ˆEÜð.Ø.3¨Wð 5Cð DIÀ'ð JðóˆCô ˜S“/ sÐ*ûð	+ús   Ÿ!A Á	BÁ
=BÂBc                ó&  — | j                   �e| j                  «        	 | j                  j                  j                  | j                   j	                  «       | j
                  | j                  ¬«      S | j                  �/| j                  j                  j                  | j                  «      S | j                  j                  j                  | j
                  | j                  ¬«      S # t        $ r}dt        |«      vr‚ t        d«      |‚d}~ww xY w)ú(
        generate the selection
        Nr†  ztoo many inputsa  The passed where expression has too many comparisons for a query against indexed columns (a numexpr limitation). Reduce the number of comparisons, or store the table with 'index=False' (e.g. DataFrame.to_hdf(..., index=False)) so the query does not use the column index.)rD  rU  ru   Ú
read_whererž   rŽ   r�   r„   ra   rY  rH  r9  )ré   rv  s     r\   rÆ   zSelection.selectQ  sî   € ð �>‰>Ð%Ø×'Ñ'Ô)ðØ—z‘z×'Ñ'×2Ñ2Ø—N‘N×)Ñ)Ó+°4·:±:ÀDÇIÁIð 3ó ð ð& ×ÑÐ)Ø—:‘:×#Ñ#×4Ñ4°T×5EÑ5EÓFÐFØ�z‰z×Ñ×$Ñ$¨4¯:©:¸D¿I¹IÐ$ÓFÐFøô% ò ð %¬C°«HÑ4ØÜ ð0óð ðûðús   žAC( Ã(	DÃ1DÄDc                óä  — t        | j                  | j                  | j                  j                  «      \  }}| j
                  �R| j                  «        | j                  j                  j                  | j
                  j                  «       ||d¬«      }n.| j                  �| j                  S t        j                  ||«      }| j                  �Ÿt        |«      r”| j                  j                  «       D ]w  \  }}}| j                  j                  ||j                  «       |j!                  «       dz   ¬«      }| ||j"                  ||j                  «       z
     |«      j$                     }Œy |S )r]  T)rŽ   r�   r÷  rg   r†  )r’   rŽ   r�   ru   r�   rD  rU  Úget_where_listrž   rY  rp  rw  r‘  rl   rM  r  r–  râ  r�  )ré   rŽ   r�   r›  r‰  r‹  rŠ  r¹  s           r\   rš  zSelection.select_coordso  s8  € ô *¨$¯*©*°d·i±iÀÇÁ×AQÑAQÓR‰ˆˆtà�>‰>Ð%Ø×'Ñ'Ô)Ø—Z‘Z×%Ñ%×4Ñ4Ø—‘×%Ñ%Ó'¨u¸4Àdð 5ó ‰Fð ×ÑÐ)Ø×#Ñ#Ð#ä—Y‘Y˜u dÓ+ˆFà�;‰;Ð"¤s¨6¤{ð $(§;¡;×#5Ñ#5Ó#7ò S‘��r˜4Ø—z‘z×-Ñ-Ø §¡£°F·J±J³LÀ1Ñ4Dð .ó �ð  ¡ 4§9¡9¨V°f·j±j³lÑ-BÑ#CÀTÓ J× QÑ QÑR‘ð	Sð
 ˆr^   r	  )ru   r  rŽ   rþ  r�   rþ  rÿ  r   r  )rm   zdict | list | tuple | strrÿ  r?   )rm   r   rÿ  r   )rm   z dict | list | tuple | str | Nonerÿ  zPyTablesExpr | None)
r  r  r  r  rë   rU  r   rM  rÆ   rš  rÜ   r^   r\   r:  r:  Ü  sv   „ ñ	ð Ø Øð,Dàð,Dð ð	,Dð
 ð,Dð 
ó,Dó\
ð< ÚMó ØMàÚ0ó Ø0ó+ò.Gó<r^   r:  )r[   r  rÿ  ra   )ri   r  )rc   ra   rÿ  r   )rŽ   rþ  r�   rþ  r�   r  rÿ  ztuple[int, int])r²   úFilePath | HDFStorer¨   ra   r‡   r  r®   ra   r¯   rþ  r°   r  r¥   rƒ   rž   r  rŸ   rƒ   r    r  r¢   r  r£   r  r¤   ra   r[   ra   rÿ  r   )	Nr¶   r”   NNNNFN)r²   ra  r®   ra   r¤   ra   rm   zstr | list | NonerŽ   rþ  r�   rþ  r¸   zlist[str] | Noner¹   rƒ   rº   rþ  )rÓ   rN   rÔ   rN   rÿ  rƒ   rY   )ræ  r.   rT  rQ   r’  r0   rÿ  r.   )r+  r   rÿ  zstr | tzinfo)rc   ra   rÿ  ústr | tzinfo | Noner+  rb  rÿ  r   )r�  znpt.NDArray[np.int64]r+  rb  r  ra   rÿ  r:   )r¡   )rc   ra   rÿ  r  )r�  rÆ  rƒ  rÆ  r  ú
set | Nonerÿ  ra   )r/  ra   r[   ra   r¤   ra   rÿ  r„  )r¸   rj   r[   ra   r¤   ra   rÿ  r  r  )rc   ra   rŸ   r0   r[   ra   r¤   ra   rJ  r  rK  rc  rÿ  r&  )rŸ  ra   r[   ra   r¤   ra   rÿ  znp.ndarray | Index)rc   ra   r»  rP   r¸   r  )r¹  rÆ  r[   ra   r¤   ra   rÿ  rÆ  )r�  rÆ  r‡  ra   r[   ra   r¤   ra   )rŸ  ra   r[   ra   r¤   ra   )rŸ  ra   rÿ  rƒ   )r6  ra   rÿ  ra   )r¹  rP   )rÿ  zset[str])Êr  Ú
__future__r   Ú
contextlibr   rº  r`  r   r   rZ  r¿   rô  Útextwrapr   Útypingr   r	   r
   r   r   r   r   r   rà   Únumpyrp  Úpandas._configr   Úpandas._config.configÚ_configrj  Úcfr   Úpandas._libsr   r   r!  Úpandas._libs.libr   Úpandas._libs.tslibsr   Úpandas.compatr   r   Úpandas.compat._optionalr   Úpandas.compat.pickle_compatr   Úpandas.errorsr   r   r   r   r   Úpandas.util._decoratorsr   r    Úpandas.util._exceptionsr!   Úpandas.core.dtypes.commonr"   r#   r$   r%   r&   r'   Úpandas.core.dtypes.dtypesr(   r)   r*   r+   Úpandas.core.dtypes.missingr,   r´   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   Úpandas.core.arraysr9   r:   r;   Úpandas.core.arrays.datetimesr<   Úpandas.core.arrays.string_r=   Úpandas.core.commonÚcoreÚcommonrs  Ú pandas.core.computation.pytablesr>   r?   r@   Úpandas.core.constructionrA   r  rB   Úpandas.core.indexes.apirC   Úpandas.io.commonrD   Úpandas.io.formats.printingrE   rF   Úcollections.abcrG   rH   rI   ÚtypesrJ   rK   r•   rL   rM   rN   Úpandas._typingrO   rP   rQ   rR   rS   rT   rU   Úpandas.core.internalsrV   rZ   r]   rd   re   r  rq   rr   rs   rÅ  r‡  rx   ry   Úconfig_prefixÚregister_optionÚis_boolÚis_one_of_factoryÚdeprecate_optionr~   r™   rÅ  r�   rŠ   r’   rš   ri  r³   rÍ   rÄ   r±   rB  r&  rÉ  rÐ  r&  r/  r1  r_  rÖ  rÈ  r×  r  rÞ  rÇ  rÜ  rÚ  rÛ  rÙ  rÝ  rY  r“  rX  r  r¥  r  rS  r\  r’  r¦  r]  r  r  r{  r,  r+  rÝ  rÜ  rE  r:  rÜ   r^   r\   ú<module>r�     sþ  ðòõ
 #å Û ÷ó Û 	Û 	Ý ÷	÷ 	ó 	ó ã õ÷ #Ð "Ý :÷õ -Ý )÷õ ?Ý 4÷õ ÷õ 5÷÷ ÷ó õ 8÷÷ ÷ ó ÷ñ õ
 5Ý 6ß  Ð  ÷ñ ÷
õ 1å +÷ñ
 ÷ñ ÷
÷
ñ ÷÷ ñ õ ,ð Ð óò	ð €€iÓ ó:ð6!Ð ˜ó ð
€�ó ð  g°GÀgÑN€ð ˜˜Ð€	ð€
ˆEó ð€
ˆEó ð €R×Ò�hÓñ Ø€B×Ò�~ u¨jÀBÇJÂJÕOØ€B×ÒØØØØ&�"×&Ò&Ò'?Ó@õ	÷ð €× Ò ØØð	õð !%€
ÐÓ $Ø$)Ð !ñ ‹8€ó$ð(ØðØ'ðØ03ðàóòð4 Ø ØØØØØ04ØØ*-¯.ª.Ø59ØØð6Ø$ð6à	ð6ð ð6ð ð	6ð
 ð6ð ð6ð ð6ð ð6ð ð6ð .ð6ð (ð6ð 3ð6ð ð6ð ð6ð  
ó!6ñr ˆHÓð 	ØØØ#ØØØ $ØØ ðkØ$ðkð ðkð ð	kð
 ðkð ðkð ðkð ðkð ðkð òkó ðkó\ñ ˆHÓ÷Sð Só ðS÷l<xñ x÷vR>ñ R>ôj�hô ô:BNˆhô BNôJ
$�wô $ô63Ð.ô 3÷U?ñ U?ôpgB�5ô gBôT4#�,ô 4#ôni;˜ô i;ôXÐ"ô ô
uDˆEô uDôp%H�ô Hô<b�eô bôJt˜?ô tôn.Ð0ô .ôb,Ð!6ô ,ô$@EÐ'ô @EôF(Ð 4ô (ðX 9=ðØ	ðØ!ðØ+0ðàóó4ðQØ
ðQØ/ðQØ5HðQà	óQð Ø!ðØ':ðØNQðàóô0
ð BFðØðØ(ðØ4>ðàóó:
 ð2àð2ð
 ð2ð ð2ð ó2ðt $(Ø"&ðELØ
ðELàðELð ðELð ð	ELð
 !ðELð  ðELð óELðR :>ð Øð Ø"ð Ø,/ð àó ðFQØ
ðQàðQð óQóhð>(Ø
ð(Ø),ð(Ø69ð(àó(ðX LPðØðØ"%ðØ14ðØ>Aóô
1óóóBó2%÷Pqò q÷oGñ ús   Æ+AP6Ð6Q 