
    ?wgdo                         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j2                          y)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y)Rowz/Internal Row object. Mainly used for filtering._rowtagsc                 D    t        |      | _        t        |      | _        y N)listr   r   selfrowr   s      B/var/www/horilla/myenv/lib/python3.12/site-packages/tablib/core.py__init__zRow.__init__$   s    I	J	    c                 (    d | j                   D        S )Nc              3       K   | ]  }|  y wr    ).0cols     r   	<genexpr>zRow.__iter__.<locals>.<genexpr>)   s     ))s   r   r   s    r   __iter__zRow.__iter__(   s    )tyy))r   c                 ,    t        | j                        S r   )lenr   r$   s    r   __len__zRow.__len__+   s    499~r   c                 ,    t        | j                        S r   )reprr   r$   s    r   __repr__zRow.__repr__.   s    DIIr   c                      | j                   |   S r   r#   r   is     r   __getitem__zRow.__getitem__1   s    yy|r   c                 "    || j                   |<   y r   r#   )r   r.   values      r   __setitem__zRow.__setitem__4   s    		!r   c                     | j                   |= y r   r#   r-   s     r   __delitem__zRow.__delitem__7   s    IIaLr   c                 2    | j                   | j                  fS r   r   r   r$   s    r   __getstate__zRow.__getstate__:   s    yy$))##r   c                 "    |\  | _         | _        y r   r6   )r   states     r   __setstate__zRow.__setstate__=   s    $	49r   c                 N    | j                  t        | j                        |       y r   )insertr'   r   r   r1   s     r   rpushz	Row.rpush@   s    C		NE*r   c                 (    | j                  d|       y )Nr   r<   r=   s     r   lpushz	Row.lpushC   s    Aur   c                 &    | j                  |       y r   r>   r=   s     r   appendz
Row.appendF   s    

5r   c                 <    | j                   j                  ||       y r   )r   r<   )r   indexr1   s      r   r<   z
Row.insertI   s    		&r   c                 z    t        | j                  j                         | j                  j                               S r   )r   r   r   r   r$   s    r   r   zRow.copyL   s%    499>>#TYY^^%566r   c                     || j                   v S r   r#   )r   items     r   __contains__zRow.__contains__O   s    tyy  r   c                 ,    t        | j                        S )z%Tuple representation of :class:`Row`.)tupler   r$   s    r   rL   z	Row.tupleR   s     TYYr   c                 ,    t        | j                        S )z$List representation of :class:`Row`.)r   r   r$   s    r   r   zRow.listW   s     DIIr   c                     |yt        |t              r|| j                  v S t        t	        t        |      t        | j                        z              S )z)Returns true if current row contains tag.F)
isinstancestrr   boolr'   set)r   tags     r   has_tagzRow.has_tag\   sF     ;S!$))##CHs499~56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      s    9 I*$%+'7!      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d2dZd3d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d4dZd Zd5dZd5dZd5dZd5dZd5dZd Z d Z!d Z"d Z#d6d Z$d4d!Z%d4d"Z&d7d#Z'd7d$Z(d4d%Z)d& Z*d' Z+d( Z,d8d)Z-d* Z.d+ Z/d, Z0d- Z1d. Z2d/ Z3d0 Z4d6d1Z5y)9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 | _        |j                  d      | _        |j                  d      | _        y )Nc              3   2   K   | ]  }t        |        y wr   )r   )r    args     r   r"   z#Dataset.__init__.<locals>.<genexpr>   s     3s#c(3s   headerstitle)	r   _data_Dataset__headers_separators_formatters_dynamic_columnsgetr`   ra   )r   argskwargss      r   r   zDataset.__init__   sY    3d33
   !#zz),ZZ(
r   c                     | j                   S r   )heightr$   s    r   r(   zDataset.__len__   s    {{r   c                 X   t        |t              rL|| j                  v r8| j                  j                  |      }| j                  D cg c]  }||   	 c}S t
        | j                  |   }t        |t              r|j                  S |D cg c]  }|j                   c}S c c}w c c}w r   )rO   rP   r`   rF   rb   KeyErrorr   rL   )r   keyposr   _resultsresults         r   r/   zDataset.__getitem__   s    c3dll"ll((-,0JJ7SC77zz#H(C(~~%3;<<< 8 =s   B"B'c                 V    | j                  |       t        |      | j                  |<   y r   )	_validater   rb   )r   rn   r1   s      r   r2   zDataset.__setitem__   s    ue*

3r   c                 L   t        |t              r|| j                  v rs| j                  j                  |      }| j                  |= || j                  v r| j                  |= t        | j                        D ]  \  }}||= || j                  |<    y t        | j                  |= y r   )rO   rP   r`   rF   rf   	enumeraterb   rm   )r   rn   ro   r.   r   s        r   r4   zDataset.__delitem__   s    c3dll"ll((-LL%$///--c2'

3 (FAsC$'DJJqM(
 

3r   c                 \    	 d| j                   j                         z  S # t        $ r Y yw xY w)Nz<%s dataset>z<dataset object>ra   lowerAttributeErrorr$   s    r   r+   zDataset.__repr__   s1    	&!TZZ%5%5%788 	&%	&    	++c           	      D   g }| j                   r2|j                  | j                   D cg c]  }t        |       c}       |j                  d | j                  D               |D cg c]  }t        t        t        |             }}t        t        t        t        |             }| j                   r#|j                  d|D cg c]  }d|z  	 c}       dj                  d t        |      D              dj                  fd|D              S c c}w c c}w c c}w )Nc              3   N   K   | ]  }t        t        t        |              y wr   )r   maprP   )r    r   s     r   r"   z"Dataset.__str__.<locals>.<genexpr>   s     @cd3sC=)@s   #%r   -|c              3   &   K   | ]	  }d |z    yw)z{%s:%s}Nr   )r    rI   s     r   r"   z"Dataset.__str__.<locals>.<genexpr>   s      TdT!1 Ts   
c              3   <   K   | ]  } j                   |   y wr   )format)r    r   format_strings     r   r"   z"Dataset.__str__.<locals>.<genexpr>   s     F---s3Fs   )rc   rD   rP   extendrb   r   r}   r'   maxzipr<   joinru   )r   rq   hr   lens
field_lenslengthr   s          @r   __str__zDataset.__str__   s     >>MM4>>:a3q6:; 	@TZZ@@/56Sc]#66#c3:./
 >>MM!DvcFlDE Ti
>S TTyyFvFFF ;
 7
 Es   D( DD
c                 N     t        j                  |      j                  | fi |S r   )r   
get_format
export_set)r   fmt_keyri   s      r   _get_in_formatzDataset._get_in_format   s%    6x""7+66tFvFFr   c                 f    t        |      } t        j                  |      j                  | |fi |S r   )r   r   r   
import_set)r   r   	in_streamri   s       r   _set_in_formatzDataset._set_in_format   s1    #I.	6x""7+66tYQ&QQr   Nc                     |rX j                   rIt        |       j                   k(  xs. t        |       j                   t         j                        z
  k(  }n[d}nX|r8t        |      dk  rd}nE j                  rt        |       j                  k(  nd}nt	         fd j
                  D              }|ry|st        y)z>Assures size of every row in dataset is of proper proportions.Tr   c              3   N   K   | ]  }t        |      j                  k(    y wr   )r'   width)r    xr   s     r   r"   z$Dataset._validate.<locals>.<genexpr>  s     DA3q6TZZ/Ds   "%F)r   r'   rf   rk   allrb   r	   )r   r   r!   safetyis_valids   `    r   rs   zDataset._validate   s    zzH

* JHc$2G2G.H!HI 
  3x!|8<CH3DDDH''r   c                 x    t         j                        } fd} j                  rn|r=|D cg c]0  }t        t        t	         j                   ||                        2 }}|S t         j                        g|D cg c]
  } ||       c}z   }|S |D cg c]
  } ||       }}|S c c}w c c}w c c}w )z=Packages Dataset into lists of dictionaries for transmission.c                     j                   rJ| j                         } j                   D ]+  \  }}|| D cg c]
  } ||       } } || |         | |<   - t        |       S c c}w r   )re   r   r   )r   r!   callbackcellr   s       r   
format_rowz$Dataset._package.<locals>.format_row  so    hhj%)%5%5 6MC{:=>$x~>>#+CH#5C6 9 ?s   A#)r   rb   r`   dictr   )r   dictsrb   r   r   datas   `     r   _packagezDataset._package  s     TZZ 
	 <<RWX3T#dllJsO"DEFXX
  T\\*+%.P3z#.PP  055JsO5D5 Y.P5s   5B- B2B7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`.

        )rc   r$   s    r   _get_headerszDataset._get_headers)  s     ~~r   c                 Z    | j                  |       |rt        |      | _        yd| _        y)zValidating headers setter.N)rs   r   rc   )r   
collections     r   _set_headerszDataset._set_headers1  s$    z"!*-DN!DNr   c                 "    | j                         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           	         d}|syt        |t              st        |      t        |d   t              r2| j                          |D ]  }| j	                  t        |              yt        |d   t              rj| j                          t        |d   j                               | _        |D ]3  }| j	                  t        t        |j                                            5 y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   keysr`   values)r   pickleerror_detailsr   s       r   	_set_dictzDataset._set_dictH  s    H 	
 &$' $M22 fQi&IIK &CH%& q	4(IIKq	 01DL 5CSZZ\ 2345 $M22r   c                     t        |      }t        |      dk(  r1t        |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}   rb   )r   r!   s     r   
_clean_colzDataset._clean_colq  sC    
 3is8q=WSVZ8s3q64::./C
r   c                 ,    t        | j                        S )zfThe number of rows currently in the :class:`Dataset`.
           Cannot be directly modified.
        )r'   rb   r$   s    r   rk   zDataset.height}  s    
 4::r   c                     	 t        | j                  d         S # t        $ r) 	 t        | j                        cY S # t        $ r Y Y yw xY ww xY w)ziThe number of columns currently in the :class:`Dataset`.
           Cannot be directly modified.
        r   )r'   rb   
IndexErrorr`   	TypeErrorr$   s    r   r   zDataset.width  sO    	tzz!}%% 	4<<(( 	s)    	A;A	AAAAc                     t        |      }|st        |      }t        j                  |      }t	        |d      st        d| d      t        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   ri   streamfmts         r   loadzDataset.load  s|     !+"6*F!!&)sL)#gfX5I$JKK#gfX5I$J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   ri   r   s       r   exportzDataset.export  sI     !!&)sL)#gfX5I$JKKs~~d-f--r   c                 .   | j                  |       t        |      | j                  k  rE| j                  j	                         D ](  \  }}t        |      }|j                  | ||             * | j                  j                  |t        ||             y)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)	rs   r'   r   rf   itemsr   r<   rb   r   )r   rF   r   r   ro   funcs         r   r<   zDataset.insert  sz     	ss8djj !2288: +	T3i

3S	*+ 	

%St!45r   c                 @    | j                  | j                  ||       y)zzAdds a row to the end of the :class:`Dataset`.
        See :method:`Dataset.insert` for additional documentation.
        r   r   N)r<   rk   r   s      r   r>   zDataset.rpush  s    
 	DKKSt4r   c                 ,    | j                  d||       y)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                 (    | j                  ||       y)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                 6    |D ]  }| j                  ||        y)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  s!    
  	#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                 "    | j                         S )r   )r   r$   s    r   popzDataset.pop  s     yy{r   c                 B    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   rg   zDataset.get  s$     eS!;788r   c                    |g }t        |      r8|| j                  | j                  <   t        t	        || j
                              }| j                  |      }| j                  |       | j                  rJ|s
t               |r | j                  dk(  rt        |      rt        | j                  j                  ||       | j                  rN| j                  rBt        | j
                        D ])  \  }}|j                  |||          || j
                  |<   + y|D cg c]  }t        |g       c}| _        yc c}w )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   )callablerf   r   r   r}   rb   r   rs   r`   r   rk   r'   r	   r<   ru   r   )r   rF   r!   headerr.   r   s         r   
insert_colzDataset.insert_col
  s   $ ;C C=03D!!$**-s3

+,Cooc"3<<#o% DKK1,S''LLv.;;4::#DJJ/ $3

5#a&) #

1$
 144#se*4DJ4s   D;c                 @    | j                  | j                  ||       y)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_col;  s    
 	

C7r   c                 ,    | j                  d||       y)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_colB  s    
 	3v.r   c                 B    ||f}| j                   j                  |       y)z4Adds a separator to :class:`Dataset` at given index.N)rd   rD   )r   rF   textseps       r   insert_separatorzDataset.insert_separatorI  s!     dm$r   c                     | j                   s| j                  r| j                  nd}n| j                  r| j                  dz   nd}| j                  ||       y)z=Adds a :ref:`separator <separators>` to the :class:`Dataset`.r   r   N)r`   rk   r   )r   r   rF   s      r   append_separatorzDataset.append_separatorO  sA     ||#';;DKKAE)-T[[1_!EeT*r   c                 (    | j                  ||       y)zvAdds a column to the :class:`Dataset`.
        See :method:`Dataset.insert_col` for additional documentation.
        N)r   r   s      r   
append_colzDataset.append_colZ  s    
 	sF#r   c                 F    | j                   D cg c]  }||   	 c}S c c}w )z@Returns the column from the :class:`Dataset` at the given index.)rb   )r   rF   r   s      r   get_colzDataset.get_cola  s      '+jj1sE
111s   c                     t        |t              r0|| j                  v r| j                  j                  |      }nt        ||| j
                  k  r| j                  j                  ||f       yt        )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.
        T)	rO   rP   r`   rF   rm   r   re   rD   r   )r   r!   handlers      r   add_formatterzDataset.add_formatterj  sh     c3dll"ll((-;#+##S'N3  &%r   c                     t        |       }|j                  D cg c]  }|j                  |      s| c}|_        |S c c}w )zReturns a new instance of the :class:`Dataset`, excluding any rows
        that do not contain the given :ref:`tags <tags>`.
        )r   rb   rT   )r   rS   _dsetr   s       r   filterzDataset.filter  s9     T
&+kkFsS[[5EsF Gs   ??c                    t        |t              r| j                  st        t	        | j
                  t        |      |      }t        | j                  | j                        }|D ]0  }| j                  D cg c]  }||   	 }}|j                  |       2 |S | j                  r| j                  |   }t	        | j
                  t        |      |      }t        | j                  | j                        }|D ]?  }| j                  r| j                  D cg c]  }||   	 }}n|}|j                  |       A |S c c}w c c}w )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.
        )rn   reverse)r`   ra   r   )
rO   rP   r`   r   sortedr   r   r\   ra   rD   )r   r!   r   _sortedr   rI   rn   r   s           r   sortzDataset.sort  s    c3<<##TYYJsOWMGDLL

CE &,0LL9StCy99%&$  ||ll3'TYYJsOWMGDLL

CE &<<04=49=C=C%& # : >s   8D?Ec                 2   t               }| j                  d   g| | j                  d      z   }||_        t        | j                        D ]J  \  }}|| j                  d   k(  r|g| j                  |      z   }t	        |      }|j                  |       L |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\   r`   ru   r   r   rD   )r   r   new_headersrF   columnrow_datas         r   _transpose_with_headerszDataset._transpose_with_headers  s    
 	 ||A'$t||A*??#&t||4 
	'ME6a( x$,,u"55H8}HLLXL&
	' r   c                     t               }t        dt        | j                  d               D ]%  }| j	                  |      }|j                  |       ' |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'   rb   r   rD   )r   r   rF   r  s       r   _transpose_without_headersz"Dataset._transpose_without_headers  sS    
 	 1c$**Q-01 	'E||E*HLLXL&	' r   c                 `    | sy| j                   | j                         S | j                         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)r`   r  r  r$   s    r   	transposezDataset.transpose  s2     <<2244//11r   c                 $   t        |t              sy| j                  |j                  k7  rt        t	        |       }|j
                  D cg c]  }| }}|j
                  D cg c]  }| }}|j                  |       ||_        |S c c}w c c}w )zStack two :class:`Dataset` instances together by
        joining at the row level, and return new combined
        ``Dataset`` instance.N)rO   r\   r   r	   r   rb   r   )r   otherr   r   rows_to_stack
other_rowss         r   stackzDataset.stack  s    
 %)::$## T
(-444%*[[1cc1
1Z(# 51s   
	B#	Bc                    t        |t              sy| j                  s|j                  r| j                  r|j                  st        | j                  |j                  k7  rt
        	 | j                  |j                  z   }t               }| j                  D ]  }|j                  | |           |j                  D ]  }|j                  ||           ||_        |S # t        $ r d}Y lw xY w)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\   r`   r   rk   r	   r   r   )r   r	  r   r   r   s        r   
stack_colszDataset.stack_cols  s     %)<<5==<<u}}##;;%,,&##	,,6K 	ll 	/Ff.	/ mm 	0Fv/	0 $  	K	s   (C   C.-C.c                     t               }| j                  D cg c]-  }t        |      |v r|j                  t        |            r,|/ c}| j                  dd yc c}w )ziRemoves all duplicate rows from the :class:`Dataset` object
        while maintaining the original order.N)rR   rb   rL   add)r   seenr   s      r   remove_duplicateszDataset.remove_duplicates  sL     u::
eCjD.@DHHUSVZDXC


1 
s   AAAc                 0    t               | _        d| _        y)zARemoves all content and headers from the :class:`Dataset` object.N)r   rb   rc   r$   s    r   r   zDataset.wipe"  s    V
r   c                    | sy|t        t        | j                              }|t        | j                        }|D cg c]  }|t        | j                        v s| }}|D cg c]  }|| j                  v s| }}t	               }t        |      |_        g |_        t        | j
                        D ]{  \  }}g }|j                  D ]E  }|| j                  v r0| j                  j                  |      }	|j                  ||	          At         ||v sa|j                  t        |             } |S c c}w c c}w )zkReturns a new instance of the :class:`Dataset`,
        including only specified rows and columns.
        Nr   )r   r  rk   r`   r\   rb   ru   rF   rD   rm   r   )
r   r   colsr   r   r   row_nodata_rowrn   ro   s
             r   subsetzDataset.subset'  s'    <dkk*+D<%D  $AseDKK.@'@AA%)D6Vt||-CDD	 T
$TZZ0 
	0KFCH}} #$,,&,,,,S1COOCH-"N# ~X/
	0 + BDs   D6D6&D;:D;)NNF)Tr   )r   )NN)r~   )F)6rU   rV   rW   rX   r   r(   r/   r2   r4   r+   r   r   r   rs   r   r   r   rZ   r`   r   r   r   r   rk   r   r   r   r<   r>   rA   rD   r   r   r   r   rg   r   r   r   r   r   r   r   r   r   r   r  r  r  r  r  r  r   r  r   r   r   r\   r\   g   s4   ,\)"=% &&G2GR26" |\2G%3N Iy)D
    ,
. 6(5+#
9/5b8/%	+$2,#J02,B

%r   r\   c                   R    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y)Databookz(A book of :class:`Dataset` objects.
    Nc                     |xs g | _         y r   	_datasets)r   setss     r   r   zDatabook.__init__S  s    r   c                 \    	 d| j                   j                         z  S # t        $ r Y yw xY w)Nz<%s databook>z<databook object>rw   r$   s    r   r+   zDatabook.__repr__V  s1    	'"djj&6&6&899 	'&	'rz   c                     g | _         y)z@Removes all :class:`Dataset` objects from the :class:`Databook`.Nr  r$   s    r   r   zDatabook.wipe\  s	    r   c                     | j                   S r   r  r$   s    r   sheetszDatabook.sheets`  s    ~~r   c                 f    t        |t              r| j                  j                  |       yt        )z5Adds given :class:`Dataset` to the :class:`Databook`.N)rO   r\   r  rD   r   )r   datasets     r   	add_sheetzDatabook.add_sheetc  s$    gw'NN!!'*$$r   c                     g }| j                   D ].  }|j                  |j                  |j                         d       0 |S )z(Packages :class:`Databook` for delivery.)ra   r   )r  rD   ra   r   )r   	collectordsets      r   r   zDatabook._packagej  sE    	NN 	D 	
 r   c                 ,    t        | j                        S )zDThe number of the :class:`Dataset` objects within :class:`Databook`.)r'   r  r$   s    r   sizezDatabook.sizeu  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
   r,  r   s         r   r   zDatabook.loadz  sd     !+"6*F!!&)sM*#gfX5G$H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
   r.  r   s       r   r   zDatabook.export  sI     !!&)sM*#gfX5I$JKKst.v..r   r   )rU   rV   rW   rX   r   r+   r   r"  r%  r   rZ   r*  r   r   r   r   r   r  r  O  sC    $'%	 # #&
/r   r  c                 r   t        |       } d}t        j                         D ]`  }	 |j                  |       r-|j                  }	 t        | d      r| j                  d        |S 	 t        | d      sP| j                  d       b |S # t        $ r Y -w xY w# t        | d      r| j                  d       w w xY w)zMReturn format name of given stream (file-like object, string, or bytestring).Nseekr   )r   r   formatsdetectra   r   r0  ry   )r   	fmt_titler   s      r   r   r     s    V$FI! 		zz&!II	 vv&A " vv&A	   		 vv&A 's)   B$B	BBBB B6Nc                 :     t               j                  | |fi |S zIReturn dataset of given stream (file-like object, string, or bytestring).)r\   r   r   r   ri   s      r   r   r     s     79>>&&3F33r   c                 :     t               j                  | |fi |S r5  )r  r   r6  s      r   r,  r,    s     8:??664V44r   r   )rX   r   operatorr   
exceptionsr   r   r   r	   r
   r1  r   utilsr   	__title__
__author____license____copyright____docformat__r   r\   r  r   r   r,  register_builtinsr   r   r   <module>rA     s        "	
>"E8 E8Pe ePH/ H/V"45    r   