
    fhn                         d Z ddlmZ ddlmZ ddlmZmZmZmZm	Z	 ddl
mZ ddlmZ dZd	Zd
ZdZdZ G d d          Z G d d          Z G d d          Zd ZddZddZ ej                     dS )z
    tablib.core
    ~~~~~~~~~~~

    This module implements the central Tablib objects.

    :copyright: (c) 2016 by Kenneth Reitz. 2019 Jazzband.
    :license: MIT, see LICENSE for more details.
    )copy)
itemgetter   )HeadersNeededInvalidDatasetIndexInvalidDatasetTypeInvalidDimensionsUnsupportedFormat)registry)normalize_inputtablibzKenneth ReitzMITz,Copyright 2017 Kenneth Reitz. 2019 Jazzband.restructuredtextc                       e Zd ZdZddgZddZd Zd Zd Zd	 Z	d
 Z
d Zd Zd Zd Zd Zd Zd Zd Zd Zed             Zed             Zd ZdS )Rowz/Internal Row object. Mainly used for filtering._rowtags c                 V    t          |          | _        t          |          | _        d S N)listr   r   selfrowr   s      B/var/www/histauto/venv/lib/python3.11/site-packages/tablib/core.py__init__zRow.__init__$   s     II	JJ			    c                 $    d | j         D             S )Nc              3      K   | ]}|V  d S r   r   ).0cols     r   	<genexpr>zRow.__iter__.<locals>.<genexpr>)   s"      ))))))))r   r   r   s    r   __iter__zRow.__iter__(   s    ))ty))))r   c                 *    t          | j                  S r   )lenr   r$   s    r   __len__zRow.__len__+   s    49~~r   c                 *    t          | j                  S r   )reprr   r$   s    r   __repr__zRow.__repr__.   s    DIr   c                     | j         |         S r   r#   r   is     r   __getitem__zRow.__getitem__1   s    y|r   c                     || j         |<   d S r   r#   )r   r.   values      r   __setitem__zRow.__setitem__4   s    	!r   c                     | j         |= d S r   r#   r-   s     r   __delitem__zRow.__delitem__7   s    IaLLLr   c                     | j         | j        fS r   r   r   r$   s    r   __getstate__zRow.__getstate__:   s    y$)##r   c                 $    |\  | _         | _        d S r   r6   )r   states     r   __setstate__zRow.__setstate__=   s    $	4999r   c                 V    |                      t          | j                  |           d S r   )insertr'   r   r   r1   s     r   rpushz	Row.rpush@   s$    C	NNE*****r   c                 2    |                      d|           d S )Nr   r<   r=   s     r   lpushz	Row.lpushC   s    Aur   c                 0    |                      |           d S r   r>   r=   s     r   appendz
Row.appendF   s    

5r   c                 <    | j                             ||           d S r   )r   r<   )r   indexr1   s      r   r<   z
Row.insertI   s     	&&&&&r   c                 ~    t          | j                                        | j                                                  S r   )r   r   r   r   r$   s    r   r   zRow.copyL   s*    49>>##TY^^%5%5666r   c                     || j         v S r   r#   )r   items     r   __contains__zRow.__contains__O   s    ty  r   c                 *    t          | j                  S )z%Tuple representation of :class:`Row`.)tupler   r$   s    r   rL   z	Row.tupleR   s     TYr   c                 *    t          | j                  S )z$List representation of :class:`Row`.)r   r   r$   s    r   r   zRow.listW   s     DIr   c                     |dS t          |t                    r	|| j        v S t          t	          t          |          t          | j                  z                      S )z)Returns true if current row contains tag.NF)
isinstancestrr   boolr'   set)r   tags     r   has_tagzRow.has_tag\   sV     ;5S!! 	8$)##CHHs49~~566777r   N)r   r   )__name__
__module____qualname____doc__	__slots__r   r%   r(   r+   r/   r2   r4   r7   r:   r>   rA   rD   r<   r   rJ   propertyrL   r   rT   r   r   r   r   r      sO       99 I   * * *          $ $ $% % %+ + +    ' ' '7 7 7! ! !     X    X8 8 8 8 8r   r   c                      e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
d	 Zd
 Zd6dZd7dZd Zd Z eee          Zd Zd Z eee          Zd Zed             Zed             Zd8dZd Zd9dZd9dZd9dZd9dZd9dZd Z d  Z!d! Z"d" Z#d:d#Z$d8d$Z%d8d%Z&d;d'Z'd;d(Z(d8d)Z)d* Z*d+ Z+d, Z,d<d-Z-d. Z.d/ Z/d0 Z0d1 Z1d2 Z2d3 Z3d4 Z4d:d5Z5dS )=Dataseta  The :class:`Dataset` object is the heart of Tablib. It provides all core
    functionality.

    Usually you create a :class:`Dataset` instance in your main module, and append
    rows as you collect data. ::

        data = tablib.Dataset()
        data.headers = ('name', 'age')

        for (name, age) in some_collector():
            data.append((name, age))


    Setting columns is similar. The column data length must equal the
    current height of the data and headers must be set. ::

        data = tablib.Dataset()
        data.headers = ('first_name', 'last_name')

        data.append(('John', 'Adams'))
        data.append(('George', 'Washington'))

        data.append_col((90, 67), header='age')


    You can also set rows and headers upon instantiation. This is useful if
    dealing with dozens or hundreds of :class:`Dataset` objects. ::

        headers = ('first_name', 'last_name')
        data = [('John', 'Adams'), ('George', 'Washington')]

        data = tablib.Dataset(*data, headers=headers)

    :param \*args: (optional) list of rows to populate Dataset
    :param headers: (optional) list strings for Dataset header row
    :param title: (optional) string to use as title of the Dataset


    .. admonition:: Format Attributes Definition

    If you look at the code, the various output/import formats are not
    defined within the :class:`Dataset` object. To add support for a new format, see
    :ref:`Adding New Formats <newformats>`.

    c                     t          d |D                       | _        d | _        g | _        g | _        i | _        |                    d          | _        |                    d          | _        d S )Nc              3   4   K   | ]}t          |          V  d S r   r   )r    args     r   r"   z#Dataset.__init__.<locals>.<genexpr>   s(      33s#c((333333r   headerstitle)	r   _data_Dataset__headers_separators_formatters_dynamic_columnsgetra   rb   )r   argskwargss      r   r   zDataset.__init__   so    33d33333
   !#zz),,ZZ((


r   c                     | j         S r   )heightr$   s    r   r(   zDataset.__len__   s
    {r   c                    t          |t                    r=|| j        v r-| j                            |          fd| j        D             S t
          | j        |         }t          |t                    r|j        S d |D             S )Nc                      g | ]
}|         S r   r   )r    r   poss     r   
<listcomp>z'Dataset.__getitem__.<locals>.<listcomp>   s    777SC777r   c                     g | ]	}|j         
S r   )rL   )r    results     r   rp   z'Dataset.__getitem__.<locals>.<listcomp>   s    <<<<<<r   )rO   rP   ra   rF   rc   KeyErrorr   rL   )r   key_resultsro   s      @r   r/   zDataset.__getitem__   s    c3 	=dl""l((--7777DJ7777z#H(C(( =~%<<8<<<<r   c                 ^    |                      |           t          |          | j        |<   d S r   )	_validater   rc   )r   rt   r1   s      r   r2   zDataset.__setitem__   s)    ue**
3r   c                    t          |t                    rl|| j        v r\| j                            |          }| j        |= || j        v r| j        |= t          | j                  D ]\  }}||= || j        |<   d S t          | j        |= d S r   )rO   rP   ra   rF   rg   	enumeraterc   rs   )r   rt   ro   r.   r   s        r   r4   zDataset.__delitem__   s    c3 	 dl""l((--L%$///-c2'
33 ( (FAsC$'DJqMM( (
 
3r   c                 ^    	 d| j                                         z  S # t          $ r Y dS w xY w)Nz<%s dataset>z<dataset object>rb   lowerAttributeErrorr$   s    r   r+   zDataset.__repr__   sD    	&!TZ%5%5%7%788 	& 	& 	&%%%	&    
,,c                    g }| j         r$|                    d | j         D                        |                    d | j        D                        d |D             }t	          t          t          t          |                     }| j         r |                    dd |D                        d	                    d t          |          D                       d	                    fd	|D                       S )
Nc                 ,    g | ]}t          |          S r   )rP   )r    hs     r   rp   z#Dataset.__str__.<locals>.<listcomp>   s    :::a3q66:::r   c              3   Z   K   | ]&}t          t          t          |                    V  'd S r   )r   maprP   r    r   s     r   r"   z"Dataset.__str__.<locals>.<genexpr>   s2      @@cd3sC==))@@@@@@r   c                 R    g | ]$}t          t          t          |                    %S r   )r   r   r'   r   s     r   rp   z#Dataset.__str__.<locals>.<listcomp>   s(    666Sc]]##666r   r   c                     g | ]}d |z  S -r   )r    lengths     r   rp   z#Dataset.__str__.<locals>.<listcomp>   s    DDDvcFlDDDr   |c              3       K   | ]	}d |z  V  
dS )z{%s:%s}Nr   )r    rI   s     r   r"   z"Dataset.__str__.<locals>.<genexpr>   s'       T TdT!1 T T T T T Tr   
c              3   ,   K   | ]} j         | V  d S r   )format)r    r   format_strings     r   r"   z"Dataset.__str__.<locals>.<genexpr>   s.      FF--s3FFFFFFr   )rd   rD   extendrc   r   r   maxzipr<   joinry   )r   rr   lens
field_lensr   s       @r   __str__zDataset.__str__   s	    > 	<MM::4>:::;;; 	@@TZ@@@@@@66v666#c3:..//
 > 	FMM!DDDDDEEE T Ti
>S>S T T TTTyyFFFFvFFFFFFr   c                 B     t          j        |          j        | fi |S r   )r   
get_format
export_set)r   fmt_keyrj   s      r   _get_in_formatzDataset._get_in_format   s(    6x"7++6tFFvFFFr   c                 b    t          |          } t          j        |          j        | |fi |S r   )r   r   r   
import_set)r   r   	in_streamrj   s       r   _set_in_formatzDataset._set_in_format   s7    #I..	6x"7++6tYQQ&QQQr   NFc                 z    |rP j         rFt          |           j         k    p,t          |           j         t           j                  z
  k    }n]d}nZ|r8t          |          dk     rd}nB j        rt          |           j        k    nd}n t	           fd j        D                       }|rdS |st          dS )z>Assures size of every row in dataset is of proper proportions.Tr   c              3   H   K   | ]}t          |          j        k    V  d S r   )r'   width)r    xr   s     r   r"   z$Dataset._validate.<locals>.<genexpr>  s0      DDA3q66TZ/DDDDDDr   F)r   r'   rg   rl   allrc   r	   )r   r   r!   safetyis_valids   `    r   rw   zDataset._validate   s     	Ez  HH
* JHHc$2G.H.H!HI 
   	E3xx!||8<MCHH33DDDDDDDDDH 	4 (''5r   Tc                      t           j                  } fd j        r7|r fd|D             }n3t           j                  gfd|D             z   }nfd|D             }|S )z=Packages Dataset into lists of dictionaries for transmission.c                     j         rF|                                 } j         D ]*\  }|fd| D             }  | |                   | |<   +t          |           S )Nc                 &    g | ]} |          S r   r   )r    cellcallbacks     r   rp   z8Dataset._package.<locals>.format_row.<locals>.<listcomp>  s!    >>>$xx~~>>>r   )rf   r   r   )r   r!   r   r   s     @r   
format_rowz$Dataset._package.<locals>.format_row  sw     6hhjj%)%5 6 6MC{>>>>#>>>#+8CH#5#5C99r   c                     g | ]:}t          t          t          j         |                                        ;S r   )dictr   r   ra   )r    r   r   r   s     r   rp   z$Dataset._package.<locals>.<listcomp>"  s=    XXX3T#dlJJsOO"D"DEEFFXXXr   c                 &    g | ]} |          S r   r   r    r   r   s     r   rp   z$Dataset._package.<locals>.<listcomp>$  s!    .P.P.P3zz#.P.P.Pr   c                 &    g | ]} |          S r   r   r   s     r   rp   z$Dataset._package.<locals>.<listcomp>&  s!    555JJsOO555r   )r   rc   ra   )r   dictsrc   datar   s   `   @r   _packagezDataset._package  s     TZ  
	 
	 
	 
	 
	 < 	6 QXXXXXRWXXXT\**+.P.P.P.P%.P.P.PP5555u555Dr   c                     | j         S )zAn *optional* list of strings to be used for header rows and attribute names.

        This must be set manually. The given list length must equal :attr:`Dataset.width`.

        )rd   r$   s    r   _get_headerszDataset._get_headers)  s     ~r   c                 n    |                      |           |rt          |          | _        dS d| _        dS )zValidating headers setter.N)rw   r   rd   )r   
collections     r   _set_headerszDataset._set_headers1  s:    z""" 	"!*--DNNN!DNNNr   c                 *    |                                  S )a  A native Python representation of the :class:`Dataset` object. If headers have
        been set, a list of Python dictionaries will be returned. If no headers have been set,
        a list of tuples (rows) will be returned instead.

        A dataset object can also be imported by setting the `Dataset.dict` attribute: ::

            data = tablib.Dataset()
            data.dict = [{'age': 90, 'first_name': 'Kenneth', 'last_name': 'Reitz'}]

        )r   r$   s    r   	_get_dictzDataset._get_dict;  s     }}r   c           	      j   d}|sdS t          |t                    st          |          t          |d         t                    r=|                                  |D ]$}|                     t          |                     %dS t          |d         t                    r|                                  t          |d                                                   | _        |D ]C}|                     t          t          |	                                                               DdS t          |          )a  A native Python representation of the Dataset object. If headers have been
        set, a list of Python dictionaries will be returned. If no headers have been
        set, a list of tuples (rows) will be returned instead.

        A dataset object can also be imported by setting the :attr:`Dataset.dict` attribute. ::

            data = tablib.Dataset()
            data.dict = [{'age': 90, 'first_name': 'Kenneth', 'last_name': 'Reitz'}]

        z[Please check format documentation https://tablib.readthedocs.io/en/stable/formats.html#yamlNr   )
rO   r   r
   wiperD   r   r   keysra   values)r   pickleerror_detailsr   s       r   	_set_dictzDataset._set_dictH  s/   H 	
  	F&$'' 	3 $M222 fQi&& 	3IIKKK & &CHH%%%%& & q	4(( 	3IIKKKq	 0 011DL 5 5CSZZ\\ 2 23344445 5 $M222r   c                     t          |          }t          |          dk    r>t          |d         d          r(t          t          |d         | j                            }|S )zsPrepares the given column for insert/append. `col` is not supposed to
           contain any header value.
        r   r   __call__)r   r'   hasattrr   rc   )r   r!   s     r   
_clean_colzDataset._clean_colq  sR    
 3iis88q==WSVZ88=s3q64:..//C
r   c                 *    t          | j                  S )zfThe number of rows currently in the :class:`Dataset`.
           Cannot be directly modified.
        )r'   rc   r$   s    r   rl   zDataset.height}  s    
 4:r   c                     	 t          | j        d                   S # t          $ r* 	 t          | j                  cY S # t          $ r Y Y dS w xY ww xY w)ziThe number of columns currently in the :class:`Dataset`.
           Cannot be directly modified.
        r   )r'   rc   
IndexErrorra   	TypeErrorr$   s    r   r   zDataset.width  su    	tz!}%%% 	 	 	4<(((((   qqq	s)    
A=A
AAAAc                     t          |          }|st          |          }t          j        |          }t	          |d          st          d| d           |j        | |fi | | S )z
        Import `in_stream` to the :class:`Dataset` object using the `format`.
        `in_stream` can be a file-like object, a string, or a bytestring.

        :param \*\*kwargs: (optional) custom configuration to the format `import_set`.
        r   Format z cannot be imported.)r   detect_formatr   r   r   r
   r   r   r   r   rj   streamfmts         r   loadzDataset.load  s     !++ 	+"6**F!&))sL)) 	L#$Jf$J$J$JKKKtV..v...r   c                     t          j        |          }t          |d          st          d| d           |j        | fi |S )z
        Export :class:`Dataset` object to `format`.

        :param \*\*kwargs: (optional) custom configuration to the format `export_set`.
        r   r    cannot be exported.)r   r   r   r
   r   r   r   rj   r   s       r   exportzDataset.export  s[     !&))sL)) 	L#$Jf$J$J$JKKKs~d--f---r   r   c                 N   |                      |           t          |          | j        k     rM| j                                        D ]3\  }}t          |          }|                    | ||                     4| j                            |t          ||                     dS )a  Inserts a row to the :class:`Dataset` at the given index.

        Rows inserted must be the correct size (height or width).

        The default behaviour is to insert the given row to the :class:`Dataset`
        object at the given index.

        You can add :ref:`tags <tags>` to the row you are inserting.
        This gives you the ability to :method:`filter <Dataset.filter>` your
        :class:`Dataset` later.
        )r   N)	rw   r'   r   rg   itemsr   r<   rc   r   )r   rF   r   r   ro   funcs         r   r<   zDataset.insert  s     	ss88dj  !288:: + +	T3ii

3S		****
%St!4!4!455555r   c                 @    |                      | j        ||           dS )zzAdds a row to the end of the :class:`Dataset`.
        See :method:`Dataset.insert` for additional documentation.
        r   r   N)r<   rl   r   s      r   r>   zDataset.rpush  s$    
 	DKSt44444r   c                 6    |                      d||           dS )zzAdds a row to the top of the :class:`Dataset`.
        See :method:`Dataset.insert` for additional documentation.
        r   r   Nr@   r   s      r   rA   zDataset.lpush  s"    
 	A3T*****r   c                 2    |                      ||           dS )zoAdds a row to the :class:`Dataset`.
        See :method:`Dataset.insert` for additional documentation.
        NrC   r   s      r   rD   zDataset.append  s    
 	

3r   c                 <    |D ]}|                      ||           dS )z[Adds a list of rows to the :class:`Dataset` using
        :method:`Dataset.append`
        N)rD   )r   rowsr   r   s       r   r   zDataset.extend  s4    
  	# 	#CKKT""""	# 	#r   c                     | d         }| d= |S )z:Removes and returns the first row of the :class:`Dataset`.r   r   r   caches     r   lpopzDataset.lpop  s     QGr   c                     | d         }| d= |S )9Removes and returns the last row of the :class:`Dataset`.r   r   s     r   rpopzDataset.rpop  s     RHr   c                 *    |                                  S )r   )r   r$   s    r   popzDataset.pop  s     yy{{r   c                 Z    t          |t                    r| |         S t          d          )z=Returns the row from the :class:`Dataset` at the given index.zRow indices must be integers.)rO   intr   r   rF   s     r   rh   zDataset.get  s/     eS!! 	;7888r   c                 P   |g }t          |          r1|| j        | j        <   t          t	          || j                            }|                     |          }|                     |           | j        rN|st                      |r!| j
        dk    rt          |          rt          | j                            ||           | j
        rI| j        rBt          | j                  D ]+\  }}|                    |||                    || j        |<   ,dS d |D             | _        dS )a?  Inserts a column to the :class:`Dataset` at the given index.

        Columns inserted must be the correct height.

        You can also insert a column of a single callable object, which will
        add a new column with the return values of the callable each as an
        item in the column. ::

            data.append_col(col=random.randint)

        If inserting a column, and :attr:`Dataset.headers` is set, the
        header attribute must be set, and will be considered the header for
        that row.

        See :ref:`dyncols` for an in-depth example.
        Nr!   r   c                 .    g | ]}t          |g          S r   r_   r   s     r   rp   z&Dataset.insert_col.<locals>.<listcomp>6  s     444#se**444r   )callablerg   r   r   r   rc   r   rw   ra   r   rl   r'   r	   r<   ry   )r   rF   r!   headerr.   r   s         r   
insert_colzDataset.insert_col  s@   $ ;C C== 	-03D!$*-s3
++,,Cooc""3< 		/ (#oo%  (DK1,,S,''Lv...; 	54: 	5#DJ// $ $3

5#a&))) #
1$ $
 54444DJJJr   c                 @    |                      | j        ||           dS )z}Adds a column to the end of the :class:`Dataset`.
        See :method:`Dataset.insert` for additional documentation.
        r   N)r   r   r   r!   r   s      r   	rpush_colzDataset.rpush_col8  s$    
 	
C77777r   c                 6    |                      d||           dS )z}Adds a column to the top of the :class:`Dataset`.
        See :method:`Dataset.insert` for additional documentation.
        r   r   N)r   r   s      r   	lpush_colzDataset.lpush_col?  s"    
 	3v.....r   r   c                 B    ||f}| j                             |           dS )z4Adds a separator to :class:`Dataset` at given index.N)re   rD   )r   rF   textseps       r   insert_separatorzDataset.insert_separatorF  s*     dm$$$$$r   c                     | j         s| j        r| j        nd}n| j        r
| j        dz   nd}|                     ||           dS )z=Adds a :ref:`separator <separators>` to the :class:`Dataset`.r   r   N)ra   rl   r   )r   r   rF   s      r   append_separatorzDataset.append_separatorL  sT     | 	<#';5DKKAEE)-;T[1__!EeT*****r   c                 2    |                      ||           dS )zvAdds a column to the :class:`Dataset`.
        See :method:`Dataset.insert_col` for additional documentation.
        N)r   r   s      r   
append_colzDataset.append_colW  s    
 	sF#####r   c                 *    fd| j         D             S )z@Returns the column from the :class:`Dataset` at the given index.c                      g | ]
}|         S r   r   )r    r   rF   s     r   rp   z#Dataset.get_col.<locals>.<listcomp>a  s    111sE
111r   )rc   r   s    `r   get_colzDataset.get_col^  s!     2111dj1111r   c                     t          |t                    r+|| j        v r| j                            |          }nt          ||| j        k    r| j                            ||f           nt          dS )a'  Adds a formatter to the :class:`Dataset`.

        :param col: column to. Accepts index int, header str, or None to apply
                    the formatter to all columns.
        :param handler: reference to callback function to execute against
                        each cell value.
        NT)	rO   rP   ra   rF   rs   r   rf   rD   r   )r   r!   handlers      r   add_formatterzDataset.add_formatterg  sy     c3 	dl""l((--;#++##S'N3333%%tr   c                 V    t          |           }fd|j        D             |_        |S )zReturns a new instance of the :class:`Dataset`, excluding any rows
        that do not contain the given :ref:`tags <tags>`.
        c                 >    g | ]}|                               |S r   )rT   )r    r   rS   s     r   rp   z"Dataset.filter.<locals>.<listcomp>  s*    FFFsS[[5E5EFsFFFr   )r   rc   )r   rS   _dsets    ` r   filterzDataset.filter}  s2     T

FFFFekFFFr   c                 @   t          |t                    r|| j        st          t	          | j        t          |          |          }t          | j        | j                  }|D ]+fd| j        D             }|	                    |           ,n| j        r| j        |         }t	          | j        t          |          |          }t          | j        | j                  }|D ]5| j        rfd| j        D             }n}|	                    |           6|S )a  Sort a :class:`Dataset` by a specific column, given string (for
        header) or integer (for column index). The order can be reversed by
        setting ``reverse`` to ``True``.

        Returns a new :class:`Dataset` instance where columns have been
        sorted.
        )rt   reverse)ra   rb   c                      g | ]
}|         S r   r   r    rt   rI   s     r   rp   z Dataset.sort.<locals>.<listcomp>  s    999StCy999r   r   c                      g | ]
}|         S r   r   r  s     r   rp   z Dataset.sort.<locals>.<listcomp>  s    ===49===r   )
rO   rP   ra   r   sortedr   r   r\   rb   rD   )r   r!   r  _sortedr  r   rI   s         @r   sortzDataset.sort  s@    c3 	&< $##TYJsOOWMMMGDL
CCCE & &9999DL999%%%%&
 | (l3'TYJsOOWMMMGDL
CCCE & &< =======CCC%%%%r   c                 H   t                      }| j        d         g| | j        d                  z   }||_        t          | j                  D ]U\  }}|| j        d         k    r|g|                     |          z   }t	          |          }|                    |           V|S )zTranspose a :class:`Dataset`, turning rows into columns and vice
        versa, returning a new ``Dataset`` instance. The first row of the
        original instance becomes the new header row.r   r  )r\   ra   ry   r  r   rD   )r   r  new_headersrF   columnrow_datas         r   _transpose_with_headerszDataset._transpose_with_headers  s    
 		 |A'$t|A*??#&t|44 
	' 
	'ME6a(( x$,,u"5"55H8}}HLLXL&&&&r   c                     t                      }t          dt          | j        d                             D ]-}|                     |          }|                    |           .|S )zTranspose a :class:`Dataset`, turning rows into columns and vice
        versa, returning a new ``Dataset`` instance. This instance should not
        have headers, or the dimension would be invalid.r   r  )r\   ranger'   rc   r  rD   )r   r  rF   r  s       r   _transpose_without_headersz"Dataset._transpose_without_headers  sc    
 		 1c$*Q-0011 	' 	'E||E**HLLXL&&&&r   c                 h    | sdS | j         |                                 S |                                 S )zTranspose a :class:`Dataset`, turning rows into columns and vice
        versa, returning a new ``Dataset`` instance. If the instance has
        headers, the first row of the original instance becomes the new header
        row.N)ra   r  r  r$   s    r   	transposezDataset.transpose  s=      	F<22444//111r   c                     t          |t                    sdS | j        |j        k    rt          t	          |           }d |j        D             }d |j        D             }|                    |           ||_        |S )zStack two :class:`Dataset` instances together by
        joining at the row level, and return new combined
        ``Dataset`` instance.Nc                     g | ]}|S r   r   r   s     r   rp   z!Dataset.stack.<locals>.<listcomp>  s    444444r   c                     g | ]}|S r   r   r   s     r   rp   z!Dataset.stack.<locals>.<listcomp>  s    111cc111r   )rO   r\   r   r	   r   rc   r   )r   otherr  rows_to_stack
other_rowss        r   stackzDataset.stack  s    
 %)) 	F:$$## T

4444411U[111
Z(((#r   c                    t          |t                    sdS | j        s|j        r| j        r|j        st          | j        |j        k    rt
          	 | j        |j        z   }n# t          $ r d}Y nw xY wt                      }| j        D ]}|                    | |                    |j        D ]}|                    ||                    ||_        |S )zStack two :class:`Dataset` instances together by
        joining at the column level, and return a new
        combined ``Dataset`` instance. If either ``Dataset``
        has headers set, than the other must as well.Nr   )rO   r\   ra   r   rl   r	   r   r   )r   r   r  r  r  s        r   
stack_colszDataset.stack_cols  s
    %)) 	F< 	$5= 	$< $u} $##;%,&&##	,6KK 	 	 	KKK	 		l 	/ 	/Ff....m 	0 	0Fv////#s   A# #A21A2c                 ^    t                      fd| j        D             | j        dd<   dS )ziRemoves all duplicate rows from the :class:`Dataset` object
        while maintaining the original order.c                 z    g | ]7}t          |          v                     t          |                    5|8S r   )rL   add)r    r   seens     r   rp   z-Dataset.remove_duplicates.<locals>.<listcomp>  sH     
 
 
eCjjD.@.@DHHUSVZZDXDX.@C.@.@.@r   N)rR   rc   )r   r)  s    @r   remove_duplicateszDataset.remove_duplicates  sF     uu
 
 
 
:
 
 

111r   c                 :    t                      | _        d| _        dS )zARemoves all content and headers from the :class:`Dataset` object.N)r   rc   rd   r$   s    r   r   zDataset.wipe  s    VV
r   c                 0     sdS |!t          t           j                            }|t           j                  } fd|D             } fd|D             }t	                      }t          |          |_        g |_        t           j                  D ]}\  }}g }|j        D ]G}| j        v r6 j                            |          }|                    ||                    At          ||v r#|                    t          |                     ~|S )zkReturns a new instance of the :class:`Dataset`,
        including only specified rows and columns.
        Nc                 @    g | ]}|t          j                  v |S r   )r  rl   )r    r   r   s     r   rp   z"Dataset.subset.<locals>.<listcomp>4  s-    AAAseDK.@.@'@'@'@'@'@r   c                 &    g | ]}|j         v |S r   )ra   )r    r   r   s     r   rp   z"Dataset.subset.<locals>.<listcomp>5  s%    DDD6Vt|-C-C-C-C-Cr   r  )r   r  rl   ra   r\   rc   ry   rF   rD   rs   r   )	r   r   colsr  row_nor   data_rowrt   ro   s	   `        r   subsetzDataset.subset$  s2     	F<dk**++D<%%D BAAAtAAADDDDTDDD		 T

$TZ00 
	0 
	0KFCH} # #$,&&,,,S11COOCH----"N~~X///r   )NNF)Tr   )r   )NNr   )F)6rU   rV   rW   rX   r   r(   r/   r2   r4   r+   r   r   r   rw   r   r   r   rZ   ra   r   r   r   r   rl   r   r   r   r<   r>   rA   rD   r   r   r   r   rh   r   r   r   r   r   r   r  r  r	  r  r  r  r  r#  r%  r*  r   r2  r   r   r   r\   r\   g   s{       , ,\) ) )"  = = =% % %     && & &G G G2G G GR R R   2   6  " " " h|\22G  %3 %3 %3N 8Iy))D
 
 
   X   X   &
. 
. 
. 6 6 6 6(5 5 5 5+ + + +   # # # #      
9 9 9/5 /5 /5 /5b8 8 8 8/ / / /% % % %	+ 	+ 	+ 	+$ $ $ $2 2 2  ,  # # # #J  0  2 2 2  ,  B
 
 
  
% % % % % %r   r\   c                   Z    e Zd ZdZddZd Zd Zd Zd Zd Z	e
d	             Zd
 Zd ZdS )Databookz(A book of :class:`Dataset` objects.
    Nc                     |pg | _         d S r   	_datasets)r   setss     r   r   zDatabook.__init__P  s    r   c                 ^    	 d| j                                         z  S # t          $ r Y dS w xY w)Nz<%s databook>z<databook object>r{   r$   s    r   r+   zDatabook.__repr__S  sD    	'"dj&6&6&8&899 	' 	' 	'&&&	'r~   c                     g | _         dS )z@Removes all :class:`Dataset` objects from the :class:`Databook`.Nr6  r$   s    r   r   zDatabook.wipeY  s    r   c                     | j         S r   r6  r$   s    r   sheetszDatabook.sheets]  s
    ~r   c                 r    t          |t                    r| j                            |           dS t          )z5Adds given :class:`Dataset` to the :class:`Databook`.N)rO   r\   r7  rD   r   )r   datasets     r   	add_sheetzDatabook.add_sheet`  s6    gw'' 	%N!!'*****$$r   c                 |    g }| j         D ]1}|                    |j        |                                d           2|S )z(Packages :class:`Databook` for delivery.)rb   r   )r7  rD   rb   r   )r   	collectordsets      r   r   zDatabook._packageg  sW    	N 	 	D      r   c                 *    t          | j                  S )zDThe number of the :class:`Dataset` objects within :class:`Databook`.)r'   r7  r$   s    r   sizezDatabook.sizer  s     4>"""r   c                     t          |          }|st          |          }t          j        |          }t	          |d          st          d| d           |j        | |fi | | S )z
        Import `in_stream` to the :class:`Databook` object using the `format`.
        `in_stream` can be a file-like object, a string, or a bytestring.

        :param \*\*kwargs: (optional) custom configuration to the format `import_book`.
        import_bookr   z cannot be loaded.)r   r   r   r   r   r
   rF  r   s         r   r   zDatabook.loadw  s     !++ 	+"6**F!&))sM** 	J#$Hf$H$H$HIIIf/////r   c                     t          j        |          }t          |d          st          d| d           |j        | fi |S )z
        Export :class:`Databook` object to `format`.

        :param \*\*kwargs: (optional) custom configuration to the format `export_book`.
        export_bookr   r   )r   r   r   r
   rH  r   s       r   r   zDatabook.export  s[     !&))sM** 	L#$Jf$J$J$JKKKst..v...r   r   )rU   rV   rW   rX   r   r+   r   r<  r?  r   rZ   rD  r   r   r   r   r   r4  r4  L  s         $ $ $ $' ' '    % % %	 	 	 # # X#  &
/ 
/ 
/ 
/ 
/r   r4  c                    t          |           } d}t          j                    D ]}	 |                    |           r/|j        }	 t          | d          r|                     d            nbn# t          $ r Y nw xY wt          | d          r|                     d           ~# t          | d          r|                     d           w w xY w|S )zMReturn format name of given stream (file-like object, string, or bytestring).Nseekr   )r   r   formatsdetectrb   r   rJ  r}   )r   	fmt_titler   s      r   r   r     s    V$$FI!! 	 		zz&!! I	 vv&& A  	 	 	D	 vv&& A vv&& As)   A-,B#-
A:7B#9A::B##(CNc                 8     t                      j        | |fi |S zIReturn dataset of given stream (file-like object, string, or bytestring).)r\   r   r   r   rj   s      r   r   r     s$     799>&&33F333r   c                 8     t                      j        | |fi |S rO  )r4  r   rP  s      r   rF  rF    s$     8::?6644V444r   r   )rX   r   operatorr   
exceptionsr   r   r   r	   r
   rK  r   utilsr   	__title__
__author____license____copyright____docformat__r   r\   r4  r   r   rF  register_builtinsr   r   r   <module>r[     s                                   " " " " " "	
>"E8 E8 E8 E8 E8 E8 E8 E8Pb b b b b b b bJH/ H/ H/ H/ H/ H/ H/ H/V  "4 4 4 45 5 5 5       r   