
    eg                         d Z ddlZddlZddlZddlZddlZdZ	 ddlZ e	ed      s:ddl
Zej                  j                  e_        ej                  j                  e_        dZddZ G d de      Z e       Z G d	 d
e      Zy#  dZdZY *xY w)a  
MetaArray.py -  Class encapsulating ndarray with meta data
Copyright 2010  Luke Campagnola
Distributed under MIT/X11 license. See license.txt for more information.

MetaArray is an array class based on numpy.ndarray that allows storage of per-axis meta data
such as axis values, names, units, column names, etc. It also enables several
new methods for slicing and indexing the array based on this meta data. 
More info at http://www.scipy.org/Cookbook/MetaArray
    NTGroupFc                    i }g d}| | |d<   |||d<   |||d<   |ng |d<   |D ]d  }t        |      t        k7  rt        |      t        k7  r|g}i }t        dt	        |            D ]  }||   |||   <    |d   j                  |       f |S )zNConvenience function for generating axis descriptions when defining MetaArrays)nameunitstitler   valuesr   colsr   )typelisttuplerangelenappend)	r   r	   r   r   ax
cNameOrderccolis	            ?/usr/lib/python3/dist-packages/pyqtgraph/metaarray/MetaArray.pyaxisr   %   s    	B+J6
876
 	#AAw$47e#3CC1SV_ *%&qTJqM"*vJc"	# I    c                       e Zd ZdZd Zd Zy)sliceGeneratorz7Just a compact way to generate tuples of slice objects.c                     |S N selfargs     r   __getitem__zsliceGenerator.__getitem__<       
r   c                     |S r   r   r   s     r   __getslice__zsliceGenerator.__getslice__>   r!   r   N)__name__
__module____qualname____doc__r    r#   r   r   r   r   r   :   s    Ar   r   c                   (   e Zd ZdZdZdZeegZe	d        Z
 eg d      ZdGdZd ZdHdZd	 Zed
        Zed        Ze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!dHdZ"d Z#d Z$d Z%d Z&d Z'd  Z(dHd!Z)d" Z*d# Z+d$ Z,dId%Z-d& Z.d' Z/dHd(Z0d) Z1d* Z2d+ Z3d, Z4d- Z5d. Z6d/ Z7d0 Z8d1 Z9d2 Z:d3 Z;dHd4Z<dHd5Z=dHd6Z>dHd7Z?d8 Z@d9 ZAe	d:        ZBdJd;ZCdKd<ZDdLd=ZEd> ZFe	dJd?       ZGe	dJd@       ZHdA ZIdB ZJdC ZKdD ZLdLdEZMdHdFZNy)M	MetaArraya  N-dimensional array with meta data such as axis titles, units, and column names.
  
    May be initialized with a file name, a tuple representing the dimensions of the array,
    or any arguments that could be passed on to numpy.array()
  
    The info argument sets the metadata for the entire array. It is composed of a list
    of axis descriptions where each axis may have a name, title, units, and a list of column 
    descriptions. An additional dict at the end of the axis list may specify parameters
    that apply to values in the entire array.
  
    For example:
        A 2D array of altitude values for a topographical map might look like
            info=[
        {'name': 'lat', 'title': 'Lattitude'}, 
        {'name': 'lon', 'title': 'Longitude'}, 
        {'title': 'Altitude', 'units': 'm'}
      ]
        In this case, every value in the array represents the altitude in feet at the lat, lon
        position represented by the array index. All of the following return the 
        value at lat=10, lon=5:
            array[10, 5]
            array['lon':5, 'lat':10]
            array['lat':10][5]
        Now suppose we want to combine this data with another array of equal dimensions that
        represents the average rainfall for each location. We could easily store these as two 
        separate arrays or combine them into a 3D array with this description:
            info=[
        {'name': 'vals', 'cols': [
          {'name': 'altitude', 'units': 'm'}, 
          {'name': 'rainfall', 'units': 'cm/year'}
        ]},
        {'name': 'lat', 'title': 'Lattitude'}, 
        {'name': 'lon', 'title': 'Longitude'}
      ]
        We can now access the altitude values with array[0] or array['altitude'], and the
        rainfall values with array[1] or array['rainfall']. All of the following return
        the rainfall value at lat=10, lon=5:
            array[1, 10, 5]
            array['lon':5, 'lat':10, 'val': 'rainfall']
            array['rainfall', 'lon':5, 'lat':10]
        Notice that in the second example, there is no need for an extra (4th) axis description
        since the actual values are described (name and units) in the column info for the first axis.
    2Nc                 H     t         fdt        j                  D              S )Nc              3   6   K   | ]  }t        |        y wr   )
isinstance).0tvars     r   	<genexpr>z'MetaArray.isNameType.<locals>.<genexpr>~   s     C!:c1%Cs   )anyr)   	nameTypes)r0   s   `r   
isNameTypezMetaArray.isNameType|   s    Cy/B/BCCCr   )__eq____ne____le____lt____ge____gt__c                 N   t         j                  |        t        j                  dt        d       d| _        |Fd | _         | j                  |fi | |j                  dd      r| j                  t        d|z        || _
        t        |d      r8|j                  d	      r'|j                  | _
        |j                         | _        nJt        |t              rt!        j"                  ||
      | _        nt!        j$                  |||      | _        | j'                          y )Nz}MetaArray is deprecated and will be removed in 0.14. Available though https://pypi.org/project/MetaArray/ as its own package.   )
stacklevelFreadAllDataTzFile read failed: %s
implementsr)   dtype)rA   copy)object__init__warningswarnDeprecationWarning_isHDF_datareadFileget	Exception_infohasattrr?   asarrayr-   r   npemptyarray	checkInfo)r   datainforA   filerB   kwargss          r   rD   zMetaArray.__init__   s    W1	

 DJDMM$)&)zz-.4::3E 6 =>>DJl+0L!ZZ
!\\^
D%(XXd%8
XXd%dC
 	r   c           
      `   | j                   }|9| j                  y t        | j                  dz         D cg c]  }i  c}| _         y 	 t	        |      }t        |      | j                  dz   k  r/|j                  i g| j                  dz   t        |      z
  z         n&t        |      | j                  dz   kD  rt        d      t        t        |            D ]  }t        ||   t              s||   i ||<   nt        d      || j                  k  rd||   v rt        ||   d         t        u r"t        j                  ||   d         ||   d<   n,t        ||   d         t        j                  urt        d      ||   d   j                  dk7  s%||   d   j                  d   | j                  |   k7  rAt        d|t        ||   d   j                        t        | j                  |   f      fz        || j                  k  s4d	||   v s=t        ||   d	   t              st	        ||   d	         ||   d	<   t        ||   d	         | j                  |   k7  st        d
|t        ||   d	         | j                  |   fz         || _         y c c}w #  t        d      xY w)N   z*Info must be a list of axis specificationsz5Info parameter must be list of length ndim+1 or less.z'Axis specification must be Dict or Noner   z0Axis values must be specified as list or ndarrayr   zJValues array for axis %d has incorrect shape. (given %s, but should be %s)r	   zSLength of column list for axis %d does not match data. (given %d, but should be %d))rM   rI   r   ndimr   rL   r   extendr-   dictr
   rP   rR   ndarrayshapestr)r   rU   r   s      r   rS   zMetaArray.checkInfo   s   zz<zz!*/		A*>?Qb?
NDz 4y499Q;&RD$))A+c$i"789TTYYq[( WXX3t9% R!$q'40Aw"$Q'(QRRtyy=Xa%8DGH-.$6,.HHT!WX5F,GQ)d1gh/0

B'(Z[[Awx(--2d1gh6G6M6Ma6PTXT^T^_`Ta6a'(t)*CQ0A0G0G,H#tzzZ[}N^J_(`)a b btyy=VtAw%6%d1gfot<*.tAwv*?Q476?+tzz!}<'(})*CQ,@$**Q-(P)Q R R%R( DJ? @
N LMMs   	J	J   J-c                     |dgS |dk(  S )Nr)   r   )r   r   s     r   r?   zMetaArray.implements   s    <= ;&&r   c           
         | j                  |      }| j                  |   }t        |      | j                  k(  rDt	        j
                  |D cg c]#  }t        |t        t        j                  f       % c}      r|S g }| j                  d   j                         }t        dt        |            D ]  }t        ||         t        t        fv st        ||   t        j                        r%|j                  | j                  |||                `| j                  |||         }d }d }	|D ]i  }
|
dk(  rCd|vrg |d<   |d   j                  ||
          d||
   v r||
   d   |d<   d||
   v sB||
   d   }	K|
dk(  r||
   }V|
|vr||
   ||
<   ||
   ||
<   k d|vs|	|	|	|d<   |	t!        |      dz   t!        |	      z   |d<   ||d<    |j                  |       t#        ||      S c c}w )Nr   r	   r   r   z: rU   )_interpretIndexesrI   r   rZ   rP   allr-   slicer]   rM   rB   r   r
   r   r   
_axisSlicer_   r)   )r   indnIndarU   	extraInfor   newInfor   colNameks              r   r    zMetaArray.__getitem__   s   %%c*JJtt9		!vv4PC:cE2::+>??PQ JJrN'')	q#d)$ 	5ADG}-DGRZZ1PDOOAtAw78//!T!W5  2AF{!202If-!&)00<"gaj018G1DIg.!WQZ/&-aj&8Gf&qzI-+21:IaL'.qz	!2 *|".07If-".03D	D0@3w<0OIf-04If-=	5@ 	I&&Q Qs   (G/c                 ,    t        | j                        S r   )r   r^   r   s    r   rZ   zMetaArray.ndim   s    4::r   c                 .    | j                   j                  S r   )rI   r^   rp   s    r   r^   zMetaArray.shape       zzr   c                 .    | j                   j                  S r   )rI   rA   rp   s    r   rA   zMetaArray.dtype  rr   r   c                 ,    t        | j                        S r   )r   rI   rp   s    r   __len__zMetaArray.__len__  s    4::r   c                 0    | j                  t        |       S r   )r    rf   )r   argss     r   r#   zMetaArray.__getslice__  s    t--r   c                 l    | j                  |      }	 || j                  |<   y #  t        | ||        xY wr   )rd   rI   print)r   rh   valri   s       r   __setitem__zMetaArray.__setitem__  s;    %%c*	"DJJt	$c"s   # 3c                 `    || j                   v rt        | j                  |      S t        |      r   )wrapMethodsgetattrrI   AttributeError)r   attrs     r   __getattr__zMetaArray.__getattr__  s,    4###4::t,, &&r   c                 &    | j                  d|      S )Nr5   _binopr   bs     r   r5   zMetaArray.__eq__      {{8Q''r   c                 &    | j                  d|      S )Nr6   r   r   s     r   r6   zMetaArray.__ne__  r   r   c                 &    | j                  d|      S )N__sub__r   r   s     r   r   zMetaArray.__sub__"      {{9a((r   c                 &    | j                  d|      S )N__add__r   r   s     r   r   zMetaArray.__add__%  r   r   c                 &    | j                  d|      S )N__mul__r   r   s     r   r   zMetaArray.__mul__(  r   r   c                 &    | j                  d|      S )N__div__r   r   s     r   r   zMetaArray.__div__+  r   r   c                 &    | j                  d|      S )N__truediv__r   r   s     r   r   zMetaArray.__truediv__.  s    {{=!,,r   c                 :   t        |t              r|j                         }| j                         } t        ||      |      }|j                  |j                  k7  r&t        d|j                  d|j                  d      t        || j                               S )NzVBinary operators with MetaArray must return an array of the same shape (this shape is z, result shape was )rc   )r-   r)   rO   r~   r^   rL   infoCopy)r   opr   rj   r   s        r   r   zMetaArray._binop1  s    a#		ALLNGArN177agg  QR  QX  QX  Z[  Za  Za  b  c  c11r   c                     t        | j                  t        j                        r| j                  S t        j                  | j                        S r   )r-   rI   rP   r]   rR   rp   s    r   rO   zMetaArray.asarray:  s1    djj"**-::88DJJ''r   c                 d    || j                         S | j                         j                  |      S r   )rO   astype)r   rA   s     r   	__array__zMetaArray.__array__@  s*    =<<>!<<>((//r   c                     | j                  |      }d| j                  |   v r| j                  |   d   S t        dt        |      |fz        )z%Return the list of values for an axisr   z,Array axis %s (%d) has no associated values.)_interpretAxisrM   rL   r_   r   r   r   s      r   
axisValueszMetaArray.axisValuesG  sP      &tzz"~%::b>(++JcRViY[_\]]r   c                 $    | j                  |      S )zSynonym for axisValues())r   r   r   s     r   xvalszMetaArray.xvalsO  s    t$$r   c                 F    | j                  |      }d| j                  |   v S )Nr   r   rM   r   s      r   axisHasValueszMetaArray.axisHasValuesS  s%      &4::b>))r   c                 F    | j                  |      }d| j                  |   v S )Nr	   r   r   s      r   axisHasColumnszMetaArray.axisHasColumnsW  s%      &B''r   c                 R    | j                   | j                  |         }d|v r|d   S y)zReturn the units for axisr   NrM   r   r   s      r   	axisUnitszMetaArray.axisUnits[  s1    ZZ++D12b=g; r   c                 p    | j                   | j                  |         }d|v r|d   D ]  }|d   |k(  s y y)Nr	   r   TFr   )r   r   r   r   r   s        r   	hasColumnzMetaArray.hasColumna  sI    ZZ++D12R<Z  V9#  r   c                 R   |hi }t        | j                        D ]L  }d| j                  |   v r#| j                  |   d   D cg c]  }|d   	 }}ng }||| j                  |      <   N |S | j	                  |      }| j                  |   d   D cg c]  }|d   	 c}S c c}w c c}w )zxReturn a list of column names for axis. If axis is not specified, then return a dict of {axisName: (column names), ...}.r	   r   )r   rZ   rM   axisNamer   )r   r   retr   r   r	   s         r   listColumnszMetaArray.listColumnsi  s    <C499% -TZZ]*/3zz!}V/DE!AfIEDED(,DMM!$%- J&&t,D'+zz$'7'?@!AfI@@ F As   BB$c                 T    | j                   | j                  |         }|d   |   d   S )Nr	   r   r   )r   r   r   r   s       r   
columnNamezMetaArray.columnNamex  s.    ZZ++D12&z#v&&r   c                 @    | j                   |   j                  d|      S )Nr   )rM   rK   )r   ns     r   r   zMetaArray.axisName|  s    zz!}  ++r   c                     | j                   | j                  |         }d|v r<|d   D ]  }|d   |k(  s|d   c S  t        dt        |      dt        |            t        dt        |      z        )z#Return the units for column in axisr	   r   r   zAxis z has no column named z!Axis %s has no column definitions)rM   r   rL   r_   )r   r   columnr   r   s        r   columnUnitszMetaArray.columnUnits  sz    ZZ++D12R<Z &V9&W:%& D	3v;WXX?#d)KLLr   c                     | |   }|j                         }t        |      t        k(  r!t        d      g|z  }|j	                  |       n)t        |t              rt        ||      f}nt        d      | t        |         S )zReturn this object with all records sorted along axis using key as the index to the values to compare. Does not yet modify meta info.Nzaxis must be type (int, str))	argsortr
   intrf   r   r-   r_   	TypeErrorr   )r   r   keykeyListorderrh   s         r   rowsortzMetaArray.rowsort  su     s)!:;-$CJJuc"u%'C:;;E#Jr   c                 T   t        | j                        }| j                  |      }||xx   dz  cc<   t        t	        |      | j
                  | j                        }t        d      g| j                  z  }t        dd      ||<   | |t	        |      <   d||<   ||t	        |      <   |S )zPReturn this object with val appended along axis. Does not yet combine meta info.rY   )rU   rA   Nrb   )	r   r^   r   r)   r   rM   rA   rf   rZ   )r   rz   r   sr   rh   s         r   r   zMetaArray.append  s     ""4(	$1eAhTZZtzzBT{mDII%$rND	%*D	%*r   c                 |    | j                  |      }t        t        j                  | ||      | j                        S )z[Return the concatenation along axis of this object and val. Does not yet combine meta info.rc   )r   r)   rP   concatenaterM   )r   rz   r   s      r   r[   zMetaArray.extend  s2     ""4(c48tzzJJr   c                     |t        j                  | j                        S t        j                  | j                  | j                  |               S )z8Return a deep copy of the axis meta info for this object)rB   deepcopyrM   r   r   s     r   r   zMetaArray.infoCopy  s=    <==,,==D,?,?,E!FGGr   c                 h    t        | j                  j                         | j                               S Nrc   )r)   rI   rB   r   rp   s    r   rB   zMetaArray.copy  s     *AAr   c                 j   t        |t              s@t        |t              r-t        |      dkD  rt        |d   t              rt        |      }n|f}t	        d       g| j
                  z  }d}t        dt        |            D ]&  }| j                  ||   ||      \  }}}|||<   |s%d}( t        |      S )Nr   TF)r-   r   r   r   rf   rZ   r   _interpretIndex)r   rh   ri   numOkr   r   indexisNameds           r   rd   zMetaArray._interpretIndexes  s    #u%#t$SA*SVU:SCj fd}TYY&qS" 	A%)%9%9#a&!U%K"T5'DJ		
 T{r   c                 T    t        |t        t        f      r| j                  |      S |S r   )r-   r_   r   _getAxisr   s     r   r   zMetaArray._interpretAxis  s$    dS%L)==&&Kr   c                    t        |      t        u r|st        d      ||dfS t        j	                  |      r"|st        d      || j                  ||      dfS t        |      t        u rt        j	                  |j                        s t        j	                  |j                        rI| j                  |j                        }t        j	                  |j                        r| j                  ||j                        }nt        |j                  t              st        |j                  t              rd| j                  |   v r|j                  | j                  |      |j                  k  }nh|j                  | j                  |      |j                  k\  }n=| j                  |      |j                  k\  | j                  |      |j                  k  z  }|}nt        |j                  t              st        |j                  t              r:|j                  |j                  }nt        |j                  |j                        }nt        |j                        t        u r{g }|j                  D ]i  }t        |      t        u r|j!                  |       &t        j	                  |      r"|j!                  | j                  ||             ]|j                  } n n|j                  }||dfS ||dfS t        |      t        u r(|D cg c]  }| j#                  |||      d    }}||dfS |st        d      ||dfS c c}w )Nz7string and integer indexes may not follow named indexesFr   TrY   )r
   r   rL   r)   r4   	_getIndexrf   startstopr   r-   floatsteprM   r   r   r   r   )	r   rh   posr   r   r   maskr   indLists	            r   r   zMetaArray._interpretIndex  s    9 YZZe$$$ YZZS1599#Y%##CII.)2F2Fsxx2P**3995 ''1 NN4:E !51Z%5PW_cgcmcmnrcsWsxx'#zz$/#((:)#zz$/388; $

4 0CHH <DAQTWT\T\A\] E  #.*SXXs2Kxx' # %chh 9 #((^t+E XX "7c>!LLO&11!4!LLa)@A %(HHE!"  HHE eT** S%((#Y$GJK!t++AsE:1=KGK%(( YZZe$$ Ls   Mc                     t        dt        | j                              D ]"  }| j                  |   }d|v s|d   |k(  s |c S  t        d|d| j                        )Nr   r   zNo axis named z	.
  info=)r   r   rM   rL   )r   r   r   r   s       r   r   zMetaArray._getAxis#  sZ    q#djj/* 	A::a=D~$v,$"6	 $

KLLr   c                     | j                   |   }|>d|v r:t        dt        |d               D ]  }d|d   |   v s|d   |   d   |k(  s|c S  t        d||| j                   fz        )Nr	   r   r   z)Axis %d has no column named %s.
  info=%s)rM   r   r   rL   )r   r   r   r   r   s        r   r   zMetaArray._getIndex*  s    ZZ>fl1c"V*o. RZ]*r&z!}V/D/LH DdTXT^T^G__``r   c                 F    t        j                  | j                  |         S r   )rB   r   rM   )r   r   s     r   	_axisCopyzMetaArray._axisCopy2  s    }}TZZ]++r   c                 d   d| j                   |   v sd| j                   |   v r~| j                  |      }d|v rEt        j                  |d         |   }t	        |t        j
                        rt        |      }||d<   d|v rt        j                  |d         |   |d<   |S | j                   |   }|S )Nr	   r   )rM   r   rP   rR   r-   r]   r   )r   r   r	   r   sls        r   rg   zMetaArray._axisSlice5  s    TZZ]"h$**Q-&?"B|XXbj)$/b"**-bB6
2~!xx85d;8 	 AB	r   c                    d}g }d}t        t        | j                        dz
        D ]w  }| j                  |   }d}d|v r|dt        |d         z  z  }n|d|z  z  }d|v r|dt        |d         z  z  }|j	                  |       t        |      |kD  smt        |      }y t        t        | j                  t        | j                        dz
              D ]Z  }| j                  |   }||   }|d	d
|t        |      z
  dz   t        t        | j                  |               z
  z  | j                  |   fz  z  }d|v rh| j                  |   dkD  rQ|d   d   }|d|z  z  }| j                  |   dkD  r)|d   d   }|d|||z
  | j                  |   dz
  z  fz  z  }n|dz  }n|dz  }d|v r|dz  }g }	t        t        |d               D ]E  }
|d   |
   }t        |j                  d|
            }d|v r|d|d   z  z  }|	j	                  |       G |ddj                  |	      z   dz   z  }||dz   z  }] |t        | j                  d         z  }|S )N r   rY   r   z"%s"z%dr   z (%s)z%s[%d] :    r   z  values: [%grb   z ... %g] (step %g)]z  values: []r	   z
 columns: [z, 
)
r   r   rM   r_   r   minrZ   r^   rK   join)r   r   titlesmaxlr   r   axsv0v1colstrsr   r   css                r   
prettyInfozMetaArray.prettyInfoG  s   s4::q() 	 AABC|vBvJ//tax"}wR[!111MM#3x$3x	  s499c$**o&9:; 	AAB)C:s3x!(;c#djjQRmBT>U(U!VX\XbXbcdXe fffC2~::a=1$HaB?b11Czz!}q(\"-3rBG

STXYHY;Z6[[[s
>)C||#s2f:/ 'AV*Q-CSWWVQ/0B#~gG44NN2&' sTYYw//#55tOA3	4 	
SB  r   c                     | j                  t        j                        j                         d| j	                         S )Nz1
-----------------------------------------------
)viewrP   r]   __repr__r   rp   s    r   r   zMetaArray.__repr__u  s6    LPIIVXV`V`LaLjLjLlnrn}n}n  A  	Ar   c                 "    | j                         S r   )r   rp   s    r   __str__zMetaArray.__str__x  s    }}r   c                     t        | j                  |      }| ||g|i |S | j                         }| j                  |      }|j	                  |       t         ||g|i ||      S r   )r~   rI   r   r   popr)   )r   fnr   rw   kargsrU   s         r   axisCollapsingFnzMetaArray.axisCollapsingFn{  sn    TZZ$<d+T+U++==?D&&t,DHHTNR5t5u5DAAr   c                 0     | j                   d|g|i |S )Nmeanr   r   r   rw   r   s       r   r   zMetaArray.mean  s!    $t$$VTBDBEBBr   c                 0     | j                   d|g|i |S )Nr   r   r   s       r   r   zMetaArray.min  !    $t$$UDA4A5AAr   c                 0     | j                   d|g|i |S )Nmaxr   r   s       r   r   zMetaArray.max  r   r   c           	         t        |      dk(  rt        |d   d      r|d   }n|}|D cg c]  }| j                  |       }}|t        t	        t        |      t        | j
                                    z   }|D cg c]  }| j
                  |    }}|t        t	        t        |      | j                              z   }	 | j                  r9t        t        j                  | j                        j                  |      |      S t        | j                  j                  |      |      S c c}w c c}w #  t        |        xY w)NrY   r   __iter__rc   )r   rN   r   r   r   rM   rZ   rH   r)   rP   rR   rI   	transposery   )r   rw   r   r   	infoOrderr   rU   s          r   r  zMetaArray.transpose  s   t9>gd1gz:GEE389R$$R(99T%E
C

O"DEE	'01!

111U3u:tyy9::	{{ $**!5!?!?!FTRR !5!5e!<4HH :1	%Ls   D+<D0 AD5 %D5 5Ec                 &   t        |d      5 }|j                  d      }|dk(  r+|j                           | j                  |fi | d| _        n|j                  d       t        j                  |      }|j                  dd      s"t        j                  |d   |d   	      | _        d
|v r|d
   }nd}dt        |      z  }t        t        |      st        d|z        t        | |      } |||fi | d| _        ddd       y# 1 sw Y   yxY w)a  Load the data and meta info stored in *filename*
        Different arguments are allowed depending on the type of file.
        For HDF5 files:
        
            *writable* (bool) if True, then any modifications to data in the array will be stored to disk.
            *readAllData* (bool) if True, then all data in the array is immediately read from disk
                          and the file is closed (this is the default for files < 500MB). Otherwise, the file will
                          be left open and data will be read only as requested (this is 
                          the default for files >= 500MB).
        
        
        rb   s   HDF

Tr   r>   r^   r
   r@   versionrY   z_readData%sz:This MetaArray library does not support array version '%s'FN)openreadclose	_readHDF5rH   seekr)   	_readMetarK   rP   rQ   rI   r_   rN   rL   r~   )	r   filenamerW   fdmagicmetaver	rFuncNamerFuncs	            r   rJ   zMetaArray.readFile  s    (D! 	$RGGAJE,,
x262"
 **2.zz-6!#$w-tF|!LDJ$y/CC)CH4	y)4#$`cf$fggi0b$)&)#)	$ 	$ 	$s   C1DDc                 v    d}	 | j                         j                         }|dk(  rn||z  }*t        |      }|S )zRead meta array from the top of a file. Read lines until a blank line is reached.
        This function should ideally work for ALL versions of MetaArray.
        r   )readlinestripeval)r  r  liner   s       r   r  zMetaArray._readMeta  sH    
 ;;=&&(DrzDLD	 
 4j
r   c                    d}|d   D ]D  }d|v st        j                  |j                  |d         |d         |d<   ||d   z  }|d= |d= F |d   | _        |j	                  dd      sy |r't        j
                  ||d	   d
|d         }|| _        y t        j                  |j                         |d	         }|d   |_        || _        y )NrY   rU   
values_lenvalues_typer@   r   r>   Tr
   rr^   rA   moder^   )rP   
frombufferr
  rM   rK   memmapr^   rI   )r   r  r  mmapkwds	frameSizer   subarrs           r   
_readData1zMetaArray._readData1  s     	v, 	&Br!!}}RWWR5E-FbQ^N_`8R--	|$}%	& &\
xxt,YYrfCtG}UF 
 ]]2779DLAF=FL
r   c                    d }d}t        t        |d               D ]d  }|d   |   }	d|	v s|	d   dk(  r|t        d      |}(t        j                  |j                  |	d         |	d         |	d<   ||	d   z  }|	d= |	d= f |d   | _        |j                  d	d
      sy ||d   dk(  r1|rt        d      t        j                  |j                               }
nJ|r t        j                  ||d   d|d         }
n(t        j                  |j                         |d         }
|d   |
_        nA|rt        d      |d   |   }	g }g }t        |d         }d||<   t        j                  |      }d}	 	 |j                         }|dk7  rn|dk(  rnt        |      }|d   dk(  r(t        j                  |j                  |d               }n,t        j                  |j                  |d         |d         }|j                   ||d   z  k7  rt        d|z        t        |      }|d   ||<   ||_        |||   }|j"                  d}nt%        d|j"                  |z
        }|j&                  |j                  |   }n&t)        |j                  |   |j&                  |z
        }t        |d d        }t+        ||      ||<   ||kD  r=|j-                  |t/        |         j1                                n|j-                  |       ||d   z  }d|v r|j3                  |d          t        j4                  ||      }
t        |      dkD  rt        j6                  ||	d         |	d<   |	d= |	d= |d   | _        |
| _        y )NrY   rU   r  dynamicz?MetaArray has more than one dynamic axis! (this is not allowed)r  r@   r   r>   Tr
   rC   z1memmap not supported for arrays with dtype=objectr  r^   r  zSmemmap not supported for non-contiguous arrays. Use rewriteContiguous() to convert.r   r   r   r   	numFramesz.Wrong frame size in MetaArray file! (frame %d)xVals)r   )r   r   rL   rP   r!  r
  rM   rK   pickleloadsr"  r^   r   prodr  r  sizer   r   r   r   rf   r   r   rB   r[   r   rR   rI   )r   r  r  r#  subsetr$  dynAxisr%  r   r   r&  r+  frames
frameShaper   r  infrT   r^   dSlicedStartdStop	newSubsets                          r   
_readData2zMetaArray._readData2  s   	s4<() 	*AfaBr!l#y0*'(ijjG#%==L9I1JRTUbRc#dBxLL!11I<(=)	* &\
xxt, ?F|x'#$WXXbggi0YYrfCtT[}]F]]2779DLIF=FL  uvvfg&BEFd7m,J"#Jw
+IA;;=Dt|  2: 4j <8+!<<E
(;<D==U)<DLQD99	C,< <<#$TWX$XYY Z(!$[!1g"
%#G_F||+!"!$Qq(8!9{{* $

7 3 #DJJw$7q I $VAYI).vu)=Ig&v~d5+;&<&A&A&CDMM$'S%%c>LLW.] ^ ^^F9F5z1}!xxR5FG8< =!&\

r   c                    d|v r||d   }|du r|du rt        d      t        s!	 |dk(  sJ |dk7  sJ | j                  |       y |$t        j                  |      j
                  }|dk  }|du rd}nd}t        j                  ||      }|j                  d	   }	 |j                  d
      }|t        j                  kD  r2t        dt        |      dt        t        j                        d       t        j                  |d         }	|	| _        |s|s|d   | _        || _        y |d   d d  | _        |j%                          y #  t        d|z        xY w#  Y xY w)Nr  Tz:Incompatible arguments: readAllData=True and writable=TrueFzKThe file '%s' is HDF5-formatted, but the HDF5 library (h5py) was not found.g    eͽAr+r  r)   utf-8z6Warning: This file was written with MetaArray version z, but you are using version z. (Will attempt to read anyway)rU   rT   )rL   	HAVE_HDF5_readHDF5Remoteosstatst_sizeh5pyFileattrsdecoder)   r  ry   r_   readHDF5MetarM   rI   	_openFiler  )
r   fileNamer>   writabler   r/  r   fr  r  s
             r   r  zMetaArray._readHDF5P  s   e 3.K$8t#3XYYz&"e+++$$X.
 778$,,D%<KtDDIIh%ggk"	**W%C """  NQ  RU  NV  X[  \e  \m  \m  Xn  o  p%%ai0
;6DJDN61DJGGI;z mpx xyy 	s   E E EEc                    t        t        dd       }|dk(  rt        d      |Oddlm} |j                  d      }|j                  d	       |t        _        |j                  d
      t        _	        t        j                  j                  |      }|j                         j                         | _        |j                  j                         | _        y )N_hdf5ProcessFzremote read failedr<   )multiprocessz/usr/bin/python)
executableT)deferGetattrzpyqtgraph.metaarray)rV   )r~   r)   rL   r   rM  ProcesssetProxyOptionsrL  _import_h5py_metaarrayrO   	_getValuerI   rM   )r   rH  procmpmas        r   r>  zMetaArray._readHDF5Remote|  s     y.$75=011<- ::)::;D  d 3%)I"(,5J(KI%&&00h0?ZZ\++-
XX'')
r   c                     | j                   j                         }|rd}nd}|t        d      t        j                  | j
                  j                  || j                  | j                  |      S )Nr;  r  z[This dataset uses chunked storage; it can not be memory-mapped. (store using mappable=True))r  offsetrA   r^   r   )	id
get_offsetrL   rP   r"  rV   r  rA   r^   )rT   rI  offr   s       r   mapHDF5ArrayzMetaArray.mapHDF5Array  s_    gg  "DD;yzzyy$))"4"4S

Z^ZdZdkoppr   c           	      &   i }| j                   D ]R  }| j                   |   }t        |t              r|j                         }t        |t              r	 t        |      }|||<   T | D ]  }| |   }t        |t        j                        rt        j                  |      }nXt        |t        j                        r|rt        j                  |      }n&|d d  }n t        dt	        t        |            z        |||<    | j                   d   }	 |j                  d      }|d= |dk(  r|S |dk(  s|dk(  r9d gt        |      z  }|D ]  }||   |t        |      <    |dk(  rt!        |      }|S t        d|z        #  t        d|z        xY w#  Y rxY w)	NzCan not evaluate string: "%s"z$Don't know what to do with type '%s'
_metaType_r<  r\   r   r   zDon't understand metaType '%s')rD  r-   bytesrE  r_   r  rL   rB  r   r)   rF  Datasetr]  r
   r   r   r   )rootr#  rT   rn   rz   objtypd2s           r   rF  zMetaArray.readHDF5Meta  s     		A**Q-C#u%jjl#s#Ks)C DG		  	Aq'C#tzz*,,S1C.#005Ca&C FTRUY WXXDG	 jj&	**W%C &=KF]cWnD	!B %!!W3q6
%g~2YI<sBCCCK#$Cc$IJJ$	s   E9F 9F	Fc                     t         du r | j                  |fi |S t        du r | j                  |fi |S t	        d      )a  Write this object to a file. The object can be restored by calling MetaArray(file=fileName)
        opts:
            appendAxis: the name (or index) of the appendable axis. Allows the array to grow.
            appendKeys: a list of keys (other than "values") for metadata to append to on the appendable axis.
            compression: None, 'gzip' (good compression), 'lzf' (fast compression), etc.
            chunks: bool or tuple specifying chunk shape
        FTzJh5py is required for writing .ma hdf5 files, but it could not be imported.)USE_HDF5writeMar=  	writeHDF5rL   )r   rH  optss      r   writezMetaArray.write  sL     u4<<1D11$!4>>(3d33hiir   c                     t        j                  |d      }|j                  d   t        j                  k7  rt        d|z        |d= | j                  |d| j                         |j                          y)zdUsed to re-write meta info to the given file.
        This feature is only available for HDF5 files.r;  r)   OThe file %s was created with a different version of MetaArray. Will not modify.rU   N)	rB  rC  rD  r)   r  rL   writeHDF5MetarM   r  )r   rH  rJ  s      r   	writeMetazMetaArray.writeMeta  sc     IIh%77;9#4#44mpxxyyfI1fdjj1		r   c                    | j                   }t        |t              r|\  }}nd }|dd}|||d<   |j                  dd       }|H| j	                  |      }| j
                  D cg c]  }t        d|       }}d||<   t        |      |d<   nb| j
                  D cg c]  }t        d|       }}t        | j                        D ]  }	d| j                  |	   v sd||	<    t        |      |d<   |D ]  }
|
|v s||
   ||
<    |j                  d	d
      rd d d}d
}|[t        | j
                        }| j	                  |      }d ||<   t        j                  j                  |      rd}t        |      |d<   nd |d<   |rt        j                  |d      }|j                   d   t"        j$                  k7  rt'        d|z        |d   }t        |j
                        }|xx   | j
                  |   z  cc<   |j)                  t        |             t+        d       gt-        |j
                        z  }t+        | j
                  |    d       ||<   | j/                  t0        j2                        |t        |      <   dg}|j5                  |j                  dg              |d   t7        |         }|D ]~  }||v rk||   }| j                  |   |   }t        |j
                        }|dxx   |j
                  d   z  cc<   |j)                  |       |||j
                  d    d  rt9        d|z         |j;                          y t        j                  |d      }t"        j$                  |j                   d<    |j<                  dd| j/                  t0        j2                        i| t        |d   t              rd|d<   d|v r|d=  | j>                  |d| j                  fi | |j;                          y c c}w c c}w )NT)compressionchunkscompression_opts
appendAxisi rY   rr  r	   mappableF)rr  rq  maxshaper;  r)   rm  rT   r   
appendKeysrU   r   zPCannot append to axis info key "%s"; this key is not present in the target file.w)rT   ) defaultCompressionr-   r   rK   r   r^   r   r   rZ   rM   r   r?  pathexistsrB  rC  rD  r)   r  rL   resizerf   r   r   rP   r]   r[   r_   r   r  create_datasetrn  )r   rH  rj  compcoptsdsOptsappAxisxr   r   rn   r   maxShaper   rJ  rT   r^   r   axKeysaxInfor   vv2s                          r   ri  zMetaArray.writeHDF5  s   &&dE"KD%E  
 ).F%& ((<.))'2G*.**5Q#fa.5B5BwK$RyF8
 +/**5Q#fa.5B5499% TZZ]*BqE  %RyF8  	$ADy Gq		$
 88J&#F DJJ'H$$W-BHRLww~~h'!&xF:!%F:		(D)Aww{#y'8'88 qt| |}} V9D$E"IB'IKKe%+TZZ0BDJJrN?D1BrF"ii

3DrO ZFMM$((<45vYs2w'F 	~&=sAB,B ME!H+HHHUO')Arxx{lm$#$vy|$|}}	~ GGI		(C(A#,#4#4AGGK AJ$))BJJ*?J6J
 &*E2#'x 'z*Dq&$**??GGIa 6 6s   $O9O>c           	         t        |t        j                        r+d|j                  dd  z   |d<    |j                  |fd|i| y t        |t
              st        |t              r{|j                  |      }t        |t
              rd|j                  d<   nd|j                  d<   t        t        |            D ]#  } | j                  |t        |      ||   fi | % y t        |t              rN|j                  |      }d|j                  d<   |j                         D ]  \  }} | j                  |||fi |  y t        |t              sDt        |t               s4t        |t        j"                        st        |t        j$                        r||j                  |<   y 	 t'        |      |j                  |<   y #  t)        d	t        t+        |            d
t        |      d        xY w)Nr   rY   rv  rT   r   r_  r   r\   z!Can not store meta data of type 'z' in HDF5. (key is 'z'))r-   rP   r]   r^   r}  r   r   create_grouprD  r   r   rn  r_   r\   itemsr   r   integerfloatingreprry   r
   )	r   rb  r   rT   r  grr   rn   r  s	            r   rn  zMetaArray.writeHDF5MetaH  s   dBJJ'!(4::ab>!9F:D:4:6:d#z$'>""4(B$%)/&)0&3t9% B"""2s1vtAwA&ABd#""4(B%+BHH\"

 71"""2q!6v67c"ju&=DRTR\R\A]aklprtr}r}a~#DJJt#':

4 WZ[_`d[eWfhklphqrss   $F= =0G-c                    | j                   t        | j                        | j                         t        j
                  d}g }|]t        j                  |      r| j                  |      }|d   |   }d|d<   d|v r$t        |d   j                        |d<   |d   }|d= nd}|d   D ]X  }d|v s|j                  |d   j                                t        |d         |d<   t        |d   j                        |d<   |d= Z |sDt        j                  j                  |       xs" t        j                  |      j                  d	k(  }||rBt!        |d
      }|j#                  t        |      dz          |D ]  }|j#                  |        nt!        |d      }| j                  t$        k7  r.| j'                  t(        j*                        j                         }	n2t-        j.                  | j'                  t(        j*                              }	|Kt        |	      | j                   |   d}
t1        |      |
d<   |j#                  dt        |
      z   dz          |j#                  |	       |j3                          y)zWrite an old-style .ma file)r^   r
   rU   r  NrU   r)  r  r   r  rb   r   wbz

ab)r   r*  r+  r   )r^   r_   rA   r   r)   r  r4   r   r   tostringr   r?  rz  r{  r@  rA  r	  rk  rC   r   rP   r]   r,  dumpsr   r  )r   rH  rt  newFiler  axstrsr   dynXValsr  dataStr	frameInfos              r   rh  zMetaArray.writeMad  s3   

3tzz?4==?^g^o^op !##J/!00<
 fj)B(B|2~$'8(:(:$;=!h<xL v, 	!B2~bl3356#&vbz?< $'8(:(:$;=!xL	! 77>>(33Z2778;L;T;TXY;YG h%BHHSY'(  h%B::ii

+446Gll499RZZ#89G!"7|J9OPI#%)(^	'"HHT#i.(-.


r   c                    | j                   dkD  rt        d      |t        |d      }d}d| j                  d   v rNdj	                  | j                  d   d   D cg c]  }|d	   	 c}      d
z   }|j                  |       n||z  }t        d| j                  d         D ]G  }dj	                  | dd|f   D cg c]  }d|z  	 c}      d
z   }|j                  |       C||z  }I |j                          y|S c c}w c c}w )zGWrite 2D array to CSV file or return the string if no filename is givenr<   z CSV Export is only for 2D arraysNrx  r   r	   r   ,r   r   rY   z%g)	rZ   rL   r	  rM   r   rk  r   r^   r  )r   rH  rV   r   r  r   rows          r   writeCsvzMetaArray.writeCsv  s   99q=>??#&DTZZ]"TZZ]6-BC!F)CDtKA#

1qDJJqM* 	CDCL9q$(9:TAA#

1q	 JJLJ D :s   D<D
)NNNNFr   )r   )F)FN)NF)Or$   r%   r&   r'   r  ry  r_   r   r3   staticmethodr4   setr}   rD   rS   r?   r    propertyrZ   r^   rA   ru   r#   r{   r   r5   r6   r   r   r   r   r   r   rO   r   r   r   r   r   r   r   r   r   r   r   r   r   r[   r   rB   rd   r   r   r   r   r   rg   r   r   r   r   r   r   r   r  rJ   r  r'  r9  r  r>  r]  rF  rk  ro  ri  rn  rh  r  r   r   r   r)   r)   C   s   *X G  eID D
 RSK6%N'-'^          .'(())))-2(0^%*(A',	M KHB&N%`Ma,$,\ABCBB*"$H  *aF*X*& q q ,D ,D\j	cJ85nr   r)   )NNNN)r'   rB   r?  r,  rE   numpyrP   rg  rB  rN   h5py.highlevel	highlevelr   ra  r=  r   rC   r   SLICERr)   r   r   r   <module>r     s   	  	     4!^^))
~~--I*V  
	n nGHIs   A	B B