ó £áSc@`sÛddlmZmZmZdgZddlZddlZddlZddl m Z m Z m Z ddl mZmZe Zddd d gZd d gZidd 6dd 6d d 6d d6Zde fd„ƒYZdS(i(tdivisiontabsolute_importtprint_functiontmemmapNi(tuint8tndarraytdtype(tlongt basestringtrtcsr+sw+treadonlyt copyonwritet readwritetwritecB`s>eZdZdZeddddd„Zd„Zd„ZRS( s  Create a memory-map to an array stored in a *binary* file on disk. Memory-mapped files are used for accessing small segments of large files on disk, without reading the entire file into memory. Numpy's memmap's are array-like objects. This differs from Python's ``mmap`` module, which uses file-like objects. This subclass of ndarray has some unpleasant interactions with some operations, because it doesn't quite fit properly as a subclass. An alternative to using this subclass is to create the ``mmap`` object yourself, then create an ndarray with ndarray.__new__ directly, passing the object created in its 'buffer=' parameter. This class may at some point be turned into a factory function which returns a view into an mmap buffer. Parameters ---------- filename : str or file-like object The file name or file object to be used as the array data buffer. dtype : data-type, optional The data-type used to interpret the file contents. Default is `uint8`. mode : {'r+', 'r', 'w+', 'c'}, optional The file is opened in this mode: +------+-------------------------------------------------------------+ | 'r' | Open existing file for reading only. | +------+-------------------------------------------------------------+ | 'r+' | Open existing file for reading and writing. | +------+-------------------------------------------------------------+ | 'w+' | Create or overwrite existing file for reading and writing. | +------+-------------------------------------------------------------+ | 'c' | Copy-on-write: assignments affect data in memory, but | | | changes are not saved to disk. The file on disk is | | | read-only. | +------+-------------------------------------------------------------+ Default is 'r+'. offset : int, optional In the file, array data starts at this offset. Since `offset` is measured in bytes, it should normally be a multiple of the byte-size of `dtype`. When ``mode != 'r'``, even positive offsets beyond end of file are valid; The file will be extended to accommodate the additional data. The default offset is 0. shape : tuple, optional The desired shape of the array. If ``mode == 'r'`` and the number of remaining bytes after `offset` is not a multiple of the byte-size of `dtype`, you must specify `shape`. By default, the returned array will be 1-D with the number of elements determined by file size and data-type. order : {'C', 'F'}, optional Specify the order of the ndarray memory layout: C (row-major) or Fortran (column-major). This only has an effect if the shape is greater than 1-D. The default order is 'C'. Attributes ---------- filename : str Path to the mapped file. offset : int Offset position in the file. mode : str File mode. Methods ------- close Close the memmap file. flush Flush any changes in memory to file on disk. When you delete a memmap object, flush is called first to write changes to disk before removing the object. Notes ----- The memmap object can be used anywhere an ndarray is accepted. Given a memmap ``fp``, ``isinstance(fp, numpy.ndarray)`` returns ``True``. Memory-mapped arrays use the Python memory-map object which (prior to Python 2.5) does not allow files to be larger than a certain size depending on the platform. This size is always < 2GB even on 64-bit systems. Examples -------- >>> data = np.arange(12, dtype='float32') >>> data.resize((3,4)) This example uses a temporary file so that doctest doesn't write files to your directory. You would use a 'normal' filename. >>> from tempfile import mkdtemp >>> import os.path as path >>> filename = path.join(mkdtemp(), 'newfile.dat') Create a memmap with dtype and shape that matches our data: >>> fp = np.memmap(filename, dtype='float32', mode='w+', shape=(3,4)) >>> fp memmap([[ 0., 0., 0., 0.], [ 0., 0., 0., 0.], [ 0., 0., 0., 0.]], dtype=float32) Write data to memmap array: >>> fp[:] = data[:] >>> fp memmap([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.]], dtype=float32) >>> fp.filename == path.abspath(filename) True Deletion flushes memory changes to disk before removing the object: >>> del fp Load the memmap and verify data was stored: >>> newfp = np.memmap(filename, dtype='float32', mode='r', shape=(3,4)) >>> newfp memmap([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.]], dtype=float32) Read-only memmap: >>> fpr = np.memmap(filename, dtype='float32', mode='r', shape=(3,4)) >>> fpr.flags.writeable False Copy-on-write memmap: >>> fpc = np.memmap(filename, dtype='float32', mode='c', shape=(3,4)) >>> fpc.flags.writeable True It's possible to assign to copy-on-write array, but values are only written into the memory copy of the array, and not written to disk: >>> fpc memmap([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.]], dtype=float32) >>> fpc[0,:] = 0 >>> fpc memmap([[ 0., 0., 0., 0.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.]], dtype=float32) File on disk is unchanged: >>> fpr memmap([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.]], dtype=float32) Offset into a memmap: >>> fpo = np.memmap(filename, dtype='float32', mode='r', offset=16) >>> fpo memmap([ 4., 5., 6., 7., 8., 9., 10., 11.], dtype=float32) gYÀsr+itCc C`sQddl}ddl}yt|}Wn@tk rh|tkritdtttjƒƒƒ‚qinXt|dƒr‡|} t } n+t ||dkrŸdp¢|dƒ} t } |dkrÙ|dkrÙtdƒ‚n| j dd ƒ| jƒ} t|ƒ} | j} |dkrY| |}|| rC| jƒtd ƒ‚n|| }|f}n<t|tƒst|f}nd }x|D]}||9}qWt||| ƒ}|dksÍ|d kr| |kr| j |d dƒ| jtjjd ƒƒ| jƒn|dkr|j}n!|dkr7|j}n |j}|||j}||8}||8}|j| jƒ|d|d|ƒ}tj ||d| d|d|d|ƒ}||_!||_"||_#t|t$ƒrõ|j%j&|ƒ|_'nEt|dƒr1t|j(t$ƒr1|j%j&|j(ƒ|_'n d|_'| rM| jƒn|S(Nismode must be one of %streadR R tbsw+sshape must be givenis?Size of available data is not a multiple of the data-type size.isr+ttaccesstoffsetRtbuffertordertname()tmmaptos.pathtmode_equivalentstKeyErrortvalid_filemodest ValueErrortlisttkeysthasattrtFalsetopentTruetNonetseekttellt dtypedescrtitemsizetcloset isinstancettupleRRtnptcompattasbytestflusht ACCESS_COPYt ACCESS_READt ACCESS_WRITEtALLOCATIONGRANULARITYtfilenoRt__new__t_mmapRtmodeRtpathtabspathtfilenameR(tsubtypeR:RR7RtshapeRRtostfidtown_filetflentdescrt_dbytestbytestsizetktacctstarttmmtself((sK/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/numpy/core/memmap.pyR5Ãsv    ! %           $        $     cC`s|t|dƒrTtj||ƒrT|j|_|j|_|j|_|j|_n$d|_d|_d|_d|_dS(NR6(R R,tmay_share_memoryR6R:RR7R$(RItobj((sK/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/numpy/core/memmap.pyt__array_finalize__s!      cC`s5|jdk r1t|jdƒr1|jjƒndS(sÜ Write any changes in the array to the file on disk. For further information, see `memmap`. Parameters ---------- None See Also -------- memmap R/N(tbaseR$R R/(RI((sK/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/numpy/core/memmap.pyR/!s!N( t__name__t __module__t__doc__t__array_priority__RR$R5RLR/(((sK/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/numpy/core/memmap.pyRs © Q (t __future__RRRt__all__twarningstsystnumpyR,tnumericRRRt numpy.compatRRR'Rtwriteable_filemodesRR(((sK/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/numpy/core/memmap.pyts