U
|
P ±dk ã @ s4 d Z ddlZddlZddlmZ ddlmZmZmZ g Z dddhZ
|
dZ e e d Z d
|
Zd Zd Zd dddZdZdd Zdd Zdd Zdd Zdd Zd d Zd d Zd d! Zd"d# Zd?d$d%Z d&d' Z d(d) Z efd*d+Z efd,d-Z d.d/ Z!efd0d1Z"d@d3d4Z#dAed6d7d8Z$dBed6d:d;Z%dCd=d>Z&dS )Daþ
|
Binary serialization
|
|
NPY format
|
==========
|
|
A simple format for saving numpy arrays to disk with the full
|
information about them.
|
|
The ``.npy`` format is the standard binary file format in NumPy for
|
persisting a *single* arbitrary NumPy array on disk. The format stores all
|
of the shape and dtype information necessary to reconstruct the array
|
correctly even on another machine with a different architecture.
|
The format is designed to be as simple as possible while achieving
|
its limited goals.
|
|
The ``.npz`` format is the standard format for persisting *multiple* NumPy
|
arrays on disk. A ``.npz`` file is a zip file containing multiple ``.npy``
|
files, one for each array.
|
|
Capabilities
|
------------
|
|
- Can represent all NumPy arrays including nested record arrays and
|
object arrays.
|
|
- Represents the data in its native binary form.
|
|
- Supports Fortran-contiguous arrays directly.
|
|
- Stores all of the necessary information to reconstruct the array
|
including shape and dtype on a machine of a different
|
architecture. Both little-endian and big-endian arrays are
|
supported, and a file with little-endian numbers will yield
|
a little-endian array on any machine reading the file. The
|
types are described in terms of their actual sizes. For example,
|
if a machine with a 64-bit C "long int" writes out an array with
|
"long ints", a reading machine with 32-bit C "long ints" will yield
|
an array with 64-bit integers.
|
|
- Is straightforward to reverse engineer. Datasets often live longer than
|
the programs that created them. A competent developer should be
|
able to create a solution in their preferred programming language to
|
read most ``.npy`` files that they have been given without much
|
documentation.
|
|
- Allows memory-mapping of the data. See `open_memmap`.
|
|
- Can be read from a filelike stream object instead of an actual file.
|
|
- Stores object arrays, i.e. arrays containing elements that are arbitrary
|
Python objects. Files with object arrays are not to be mmapable, but
|
can be read and written to disk.
|
|
Limitations
|
-----------
|
|
- Arbitrary subclasses of numpy.ndarray are not completely preserved.
|
Subclasses will be accepted for writing, but only the array data will
|
be written out. A regular numpy.ndarray object will be created
|
upon reading the file.
|
|
.. warning::
|
|
Due to limitations in the interpretation of structured dtypes, dtypes
|
with fields with empty names will have the names replaced by 'f0', 'f1',
|
etc. Such arrays will not round-trip through the format entirely
|
accurately. The data is intact; only the field names will differ. We are
|
working on a fix for this. This fix will not require a change in the
|
file format. The arrays with such structures can still be saved and
|
restored, and the correct dtype may be restored by using the
|
``loadedarray.view(correct_dtype)`` method.
|
|
File extensions
|
---------------
|
|
We recommend using the ``.npy`` and ``.npz`` extensions for files saved
|
in this format. This is by no means a requirement; applications may wish
|
to use these file formats but use an extension specific to the
|
application. In the absence of an obvious alternative, however,
|
we suggest using ``.npy`` and ``.npz``.
|
|
Version numbering
|
-----------------
|
|
The version numbering of these formats is independent of NumPy version
|
numbering. If the format is upgraded, the code in `numpy.io` will still
|
be able to read and write Version 1.0 files.
|
|
Format Version 1.0
|
------------------
|
|
The first 6 bytes are a magic string: exactly ``\x93NUMPY``.
|
|
The next 1 byte is an unsigned byte: the major version number of the file
|
format, e.g. ``\x01``.
|
|
The next 1 byte is an unsigned byte: the minor version number of the file
|
format, e.g. ``\x00``. Note: the version of the file format is not tied
|
to the version of the numpy package.
|
|
The next 2 bytes form a little-endian unsigned short int: the length of
|
the header data HEADER_LEN.
|
|
The next HEADER_LEN bytes form the header data describing the array's
|
format. It is an ASCII string which contains a Python literal expression
|
of a dictionary. It is terminated by a newline (``\n``) and padded with
|
spaces (``\x20``) to make the total of
|
``len(magic string) + 2 + len(length) + HEADER_LEN`` be evenly divisible
|
by 64 for alignment purposes.
|
|
The dictionary contains three keys:
|
|
"descr" : dtype.descr
|
An object that can be passed as an argument to the `numpy.dtype`
|
constructor to create the array's dtype.
|
"fortran_order" : bool
|
Whether the array data is Fortran-contiguous or not. Since
|
Fortran-contiguous arrays are a common form of non-C-contiguity,
|
we allow them to be written directly to disk for efficiency.
|
"shape" : tuple of int
|
The shape of the array.
|
|
For repeatability and readability, the dictionary keys are sorted in
|
alphabetic order. This is for convenience only. A writer SHOULD implement
|
this if possible. A reader MUST NOT depend on this.
|
|
Following the header comes the array data. If the dtype contains Python
|
objects (i.e. ``dtype.hasobject is True``), then the data is a Python
|
pickle of the array. Otherwise the data is the contiguous (either C-
|
or Fortran-, depending on ``fortran_order``) bytes of the array.
|
Consumers can figure out the number of bytes by multiplying the number
|
of elements given by the shape (noting that ``shape=()`` means there is
|
1 element) by ``dtype.itemsize``.
|
|
Format Version 2.0
|
------------------
|
|
The version 1.0 format only allowed the array header to have a total size of
|
65535 bytes. This can be exceeded by structured arrays with a large number of
|
columns. The version 2.0 format extends the header size to 4 GiB.
|
`numpy.save` will automatically save in 2.0 format if the data requires it,
|
else it will always use the more compatible 1.0 format.
|
|
The description of the fourth element of the header therefore has become:
|
"The next 4 bytes form a little-endian unsigned int: the length of the header
|
data HEADER_LEN."
|
|
Format Version 3.0
|
------------------
|
|
This version replaces the ASCII string (which in practice was latin1) with
|
a utf8-encoded string, so supports structured types with any unicode field
|
names.
|
|
Notes
|
-----
|
The ``.npy`` format, including motivation for creating it and a comparison of
|
alternatives, is described in the
|
:doc:`"npy-format" NEP <neps:nep-0001-npy-format>`, however details have
|
evolved with time and this document is more current.
|
|
é N)Ú safe_eval)Ú isfileobjÚ os_fspathÚpickleÚdescrÚ fortran_orderÚshapes NUMPYé é@ i é )z<HÚlatin1)ú<Ir )r Úutf8)©é r ©r r ©é r i' c C s | dkrd}t || f d S )N)r r r Nz>we only support format version (1,0), (2,0), and (3,0), not %s)Ú
|
ValueError)ÚversionÚmsg© r úGd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/lib/format.pyÚ_check_versionÄ s r c C s@ | dk s| dkrt d|dk s(|dkr0t dtt| |g S )a
|
Return the magic string for the given file format version.
|
|
Parameters
|
----------
|
major : int in [0, 255]
|
minor : int in [0, 255]
|
|
Returns
|
-------
|
magic : str
|
|
Raises
|
------
|
ValueError if the version cannot be formatted.
|
r éÿ z&major version must be 0 <= major < 256z&minor version must be 0 <= minor < 256)r Ú MAGIC_PREFIXÚbytes)ÚmajorÚminorr r r ÚmagicÉ s
|
r c C sP t | td}|dd
tkr8d}t|t|dd
f |dd
\}}||fS )z³ Read the magic string to get the version of the file format.
|
|
Parameters
|
----------
|
fp : filelike object
|
|
Returns
|
-------
|
major : int
|
minor : int
|
z magic stringNéþÿÿÿz4the magic string is not correct; expected %r, got %r)Ú _read_bytesÚ MAGIC_LENr r )ÚfpZ magic_strr r r r r r Ú
|
read_magicß s r$ c sL j d k rdS jd k r0t fdd jD S jd k rDt jS dS d S )NTc 3 s | ]}t | V qd S ©N)Ú _has_metadata)Ú.0Úk©Údtr r Ú <genexpr>ö s z _has_metadata.<locals>.<genexpr>F)ÚmetadataÚnamesÚanyZsubdtyper& Úbaser) r r) r r& ò s
|
|
|
|
r& c C s2 t | rtjdtdd | jdk r(| jS | jS dS )a´
|
Get a serializable descriptor from the dtype.
|
|
The .descr attribute of a dtype object cannot be round-tripped through
|
the dtype() constructor. Simple types, like dtype('float32'), have
|
a descr which looks like a record array with one field with '' as
|
a name. The dtype() constructor interprets this as a request to give
|
a default name. Instead, we construct descriptor that can be passed to
|
dtype().
|
|
Parameters
|
----------
|
dtype : dtype
|
The dtype of the array that will be written to disk.
|
|
Returns
|
-------
|
descr : object
|
An object that can be passed to `numpy.dtype()` in order to
|
replicate the input dtype.
|
|
zlmetadata on a dtype may be saved or ignored, but will raise if saved when read. Use another form of storage.r ©Ú
|
stacklevelN)r& ÚwarningsÚwarnÚ UserWarningr- r Ústr©Údtyper r r Údtype_to_descrü s þ
|
r8 c C s t | trt | ¡S t | tr<t| d }t || d f¡S g }g }g }g }d}| D ]¬}t|dkrv|\}} t| }n |\}} }
|
t t| |
|
f¡}|dko®|jtjko®|j dk} | söt |trÂ|nd|f\} }|
|
| ¡ |
|
|¡ |
|
|¡ |
|
|¡ ||j 7 }qTt |||||d¡S )a.
|
Returns a dtype based off the given description.
|
|
This is essentially the reverse of `dtype_to_descr()`. It will remove
|
the valueless padding fields created by, i.e. simple fields like
|
dtype('float32'), and then convert the description to its corresponding
|
dtype.
|
|
Parameters
|
----------
|
descr : object
|
The object retrieved by dtype.descr. Can be passed to
|
`numpy.dtype()` in order to replicate the input dtype.
|
|
Returns
|
-------
|
dtype : dtype
|
The dtype constructed by the description.
|
|
r r r Ú N)r- ÚformatsÚtitlesÚoffsetsÚitemsize) Ú
|
isinstancer5 Únumpyr7 ÚtupleÚdescr_to_dtypeÚlenÚtypeZvoidr- Úappendr= ) r r* r; r- r: r< ÚoffsetÚfieldÚnameZ descr_strr Zis_padÚtitler r r rA s8
|
|
|
|
|
|
|
|
|
|
ÿrA c C sH d| j i}| jjr d|d< n| jjr.d|d< nd|d< t| j|d< |S )a Get the dictionary of header metadata from a numpy.ndarray.
|
|
Parameters
|
----------
|
array : numpy.ndarray
|
|
Returns
|
-------
|
d : dict
|
This has the appropriate entries for writing its string representation
|
to the header of the file.
|
r Fr Tr )r ÚflagsÚ c_contiguousÚ f_contiguousr8 r7 )ÚarrayÚdr r r Úheader_data_from_array_1_0X s
|
|
|
rN c C s® ddl }|dk stt| \}}| |¡} t| d }tt| |¡ | t }z t| | ||| ¡ }W n, |j
|
k
|
r d ||¡}t |dY nX || d| d S )zO
|
Takes a stringified header, and attaches the prefix and padding to it
|
r Nr z'Header length {} too big for version={}ó ó
|
) ÚstructÚAssertionErrorÚ_header_size_infoÚencoderB Ú ARRAY_ALIGNr" Úcalcsizer ÚpackÚerrorÚformatr ) Úheaderr rQ ÚfmtÚencodingZhlenZpadlenZ header_prefixr r r r Ú _wrap_headert s
|
r] c C sx z t | dW S tk
|
r Y nX zt | d}W n tk
|
rD Y nX tjdtdd |S t | d} tjdtdd | S )zT
|
Like `_wrap_header`, but chooses an appropriate version given the contents
|
r r z>Stored array in format 2.0. It can only beread by NumPy >= 1.9r r0 r z@Stored array in format 3.0. It can only be read by NumPy >= 1.17)r] r ÚUnicodeEncodeErrorr2 r3 r4 )rZ Úretr r r Ú_wrap_header_guess_version s& ÿ
|
ÿr` c C s° dg}t | ¡ D ] \}}| d|t|f ¡ q| d¡ d |¡}|d }|dt|dkr~ttt||d rrd nd nd 7 }|d
|
krt|}n
|
t||}| |¡ d
|
S ) aÀ Write the header for an array and returns the version used
|
|
Parameters
|
----------
|
fp : filelike object
|
d : dict
|
This has the appropriate entries for writing its string representation
|
to the header of the file.
|
version : tuple or None
|
None means use oldest that works. Providing an explicit version will
|
raise a ValueError if the format does not allow saving this data.
|
Default: None
|
Ú{z
|
'%s': %s, Ú}r9 r ú r r éÿÿÿÿN)
|
ÚsortedÚitemsrD ÚreprÚjoinrB ÚGROWTH_AXIS_MAX_DIGITSr` r] Úwrite)r# rM r rZ ÚkeyÚvaluer r r r Ú_write_array_header¤ s"
|
|
|
þÿþ
|
|
rm c C s t | |d dS )zð Write the header for an array using the 1.0 format.
|
|
Parameters
|
----------
|
fp : filelike object
|
d : dict
|
This has the appropriate entries for writing its string
|
representation to the header of the file.
|
r N©rm ©r# rM r r r Úwrite_array_header_1_0Ç s
|
rp c C s t | |d dS )aQ Write the header for an array using the 2.0 format.
|
The 2.0 format allows storing very large structured arrays.
|
|
.. versionadded:: 1.9.0
|
|
Parameters
|
----------
|
fp : filelike object
|
d : dict
|
This has the appropriate entries for writing its string
|
representation to the header of the file.
|
r Nrn ro r r r Úwrite_array_header_2_0Ô s rq c C s t | d|dS )a²
|
Read an array header from a filelike object using the 1.0 file format
|
version.
|
|
This will leave the file object located just after the header.
|
|
Parameters
|
----------
|
fp : filelike object
|
A file object or something with a `.read()` method like a file.
|
|
Returns
|
-------
|
shape : tuple of int
|
The shape of the array.
|
fortran_order : bool
|
The array data will be written out directly if it is either
|
C-contiguous or Fortran-contiguous. Otherwise, it will be made
|
contiguous before writing it out.
|
dtype : dtype
|
The dtype of the file's data.
|
max_header_size : int, optional
|
Maximum allowed size of the header. Large headers may not be safe
|
to load securely and thus require explicitly passing a larger value.
|
See :py:meth:`ast.literal_eval()` for details.
|
|
Raises
|
------
|
ValueError
|
If the data is invalid.
|
|
r ©r Úmax_header_size©Ú_read_array_header©r# rs r r r Úread_array_header_1_0ã s
|
! ÿrw c C s t | d|dS )aÏ
|
Read an array header from a filelike object using the 2.0 file format
|
version.
|
|
This will leave the file object located just after the header.
|
|
.. versionadded:: 1.9.0
|
|
Parameters
|
----------
|
fp : filelike object
|
A file object or something with a `.read()` method like a file.
|
max_header_size : int, optional
|
Maximum allowed size of the header. Large headers may not be safe
|
to load securely and thus require explicitly passing a larger value.
|
See :py:meth:`ast.literal_eval()` for details.
|
|
Returns
|
-------
|
shape : tuple of int
|
The shape of the array.
|
fortran_order : bool
|
The array data will be written out directly if it is either
|
C-contiguous or Fortran-contiguous. Otherwise, it will be made
|
contiguous before writing it out.
|
dtype : dtype
|
The dtype of the file's data.
|
|
Raises
|
------
|
ValueError
|
If the data is invalid.
|
|
r rr rt rv r r r Úread_array_header_2_0 s
|
# ÿrx c C sz ddl }ddlm} g }d}| || j¡D ]B}|d }|d }|rZ||jkrZ|dkrZq,n
|
| |¡ ||jk}q,| |¡S )a6 Clean up 'L' in npz header ints.
|
|
Cleans up the 'L' in strings representing integers. Needed to allow npz
|
headers produced in Python2 to be read in Python3.
|
|
Parameters
|
----------
|
s : string
|
Npy file header.
|
|
Returns
|
-------
|
header : str
|
Cleaned up header.
|
|
r N)ÚStringIOFr ÚL) ÚtokenizeÚiory Úgenerate_tokensÚreadlineÚNAMErD ÚNUMBERÚ
|
untokenize)Úsr{ ry ÚtokensZlast_token_was_numberÚtokenÚ
|
token_typeZ token_stringr r r Ú_filter_header. s ÿþ
|
r c
|
C sè ddl }t |¡}|dkr(td |¡|\}}t| | |¡d}| ||¡d }t| |d} | |¡} t | |krtdt | d|dkrt
|
| } z t | }
|
W n6 t k
|
rÚ } zd } t| | ¡| W 5 d} ~ X Y nX t |
|
tsød
|
} t| |
|
¡t|
|
¡ kr$t|
|
¡ } d } t| | ¡t |
|
d trLtd d |
|
d D sbd} t| |
|
d ¡t |
|
d tsd} t| |
|
d ¡zt|
|
d }W n< tk
|
rÔ } z d} t| |
|
d ¡| W 5 d} ~ X Y nX |
|
d |
|
d |fS )z#
|
see read_array_header_1_0
|
r NzInvalid version {!r}zarray header lengthz array headerzHeader info length (zä) is large and may not be safe to load securely.
|
To allow loading, adjust `max_header_size` or fully trust the `.npy` file using `allow_pickle=True`.
|
For safety against large resource use or crashes, sandboxing may be necessary.r zCannot parse header: {!r}z Header is not a dictionary: {!r}z.Header does not contain the correct keys: {!r}r c s s | ]}t |tV qd S r% )r> Úint)r' Úxr r r r+ s z%_read_array_header.<locals>.<genexpr>zshape is not valid: {!r}r z'fortran_order is not a valid bool: {!r}r z+descr is not a valid dtype descriptor: {!r})rQ rS Úgetr rY r! rV ÚunpackÚdecoderB r r Ú SyntaxErrorr> ÚdictÚ EXPECTED_KEYSÚkeysre r@ ÚallÚboolrA Ú TypeError)r# r rs rQ ZhinfoZ hlength_typer\ Z hlength_strÚ header_lengthrZ rM Úer r r7 r r r ru Q sR
|
|
ÿ "
|
ÿ&ru Tc C s t | t| t|| |jdkr(d}ntd|j d}|jjrr|sLtd|dkrXi }tj || fddi| n|j
|
j rÈ|j
|
j sÈt | r|j | ¡ n.tj|dd d
|
g|d d D ]}| | d ¡¡ q°nBt | rÜ| | ¡ n.tj|dd d
|
g|d d D ]}| | d ¡¡ qôdS )a'
|
Write an array to an NPY file, including a header.
|
|
If the array is neither C-contiguous nor Fortran-contiguous AND the
|
file_like object is not a real file object, this function will have to
|
copy data in memory.
|
|
Parameters
|
----------
|
fp : file_like object
|
An open, writable file object, or similar object with a
|
``.write()`` method.
|
array : ndarray
|
The array to write to disk.
|
version : (int, int) or None, optional
|
The version number of the format. None means use the oldest
|
supported version that is able to store the data. Default: None
|
allow_pickle : bool, optional
|
Whether to allow writing pickled data. Default: True
|
pickle_kwargs : dict, optional
|
Additional keyword arguments to pass to pickle.dump, excluding
|
'protocol'. These are only useful when pickling objects in object
|
arrays on Python 3 to Python 2 compatible format.
|
|
Raises
|
------
|
ValueError
|
If the array cannot be persisted. This includes the case of
|
allow_pickle=False and array being an object array.
|
Various other errors
|
If the array contains Python objects as part of its dtype, the
|
process of pickling them may raise various errors if the objects
|
are not picklable.
|
|
r i r z5Object arrays cannot be saved when allow_pickle=FalseNÚprotocolr Z external_loopZbufferedZ zerosize_okÚF)rI Ú
|
buffersizeÚorderÚC)r rm rN r= Úmaxr7 Ú hasobjectr r ÚdumprI rK rJ r ÚTZtofiler? Znditerrj Útobytes)r# rL r Ú allow_pickleÚ pickle_kwargsr Úchunkr r r Ú write_array s< $
|
þ
|
þ
|
r¢ F©rs c
|
C s| |rd}t | }t| t| ||d\}}}t|dkr>d}ntjj|tjd}|jr¶|sbt d|dkrni }zt
|
j | f|} W n2 t k
|
r² }
|
zt d|
|
f |
|
W 5 d}
|
~
|
X Y nX nÂt | rÐtj| ||d } ntj||d} |jdkrRttt|j } td|| D ]J} t| || } t| |j }t| |d
|
}tj||| d | | | |
< q|rr|ddd
| _| ¡ } n|| _| S ) a¨
|
Read an array from an NPY file.
|
|
Parameters
|
----------
|
fp : file_like object
|
If this is not a real file object, then this may take extra memory
|
and time.
|
allow_pickle : bool, optional
|
Whether to allow writing pickled data. Default: False
|
|
.. versionchanged:: 1.16.3
|
Made default False in response to CVE-2019-6446.
|
|
pickle_kwargs : dict
|
Additional keyword arguments to pass to pickle.load. These are only
|
useful when loading object arrays saved on Python 2 when using
|
Python 3.
|
max_header_size : int, optional
|
Maximum allowed size of the header. Large headers may not be safe
|
to load securely and thus require explicitly passing a larger value.
|
See :py:meth:`ast.literal_eval()` for details.
|
This option is ignored when `allow_pickle` is passed. In that case
|
the file is by definition trusted and the limit is unnecessary.
|
|
Returns
|
-------
|
array : ndarray
|
The array from the data on disk.
|
|
Raises
|
------
|
ValueError
|
If the data is invalid, or allow_pickle=False and the file contains
|
an object array.
|
|
l r£ r r r6 z6Object arrays cannot be loaded when allow_pickle=FalseNz]Unpickling a python object failed: %r
|
You may need to pass the encoding= option to numpy.load)r7 Úcountz
|
array datard )r$ r ru rB r? ÚmultiplyÚreduceÚint64r r r ÚloadÚ UnicodeErrorr ZfromfileZndarrayr= Ú BUFFER_SIZEÚminÚranger r! Z
|
frombufferr Z transpose)r# r r rs r r r r7 r¤ rL ÚerrZmax_read_countÚiZ
|
read_countÚ read_sizeÚdatar r r Ú
|
read_arrayÚ sT ' ÿ þþ ÿ
|
r± úr+c C s t | rtdd|krt| t |¡}|jr<d}t|tt|||d}tt | |d } t
|
| || | ¡ }
|
W 5 Q R X nXtt | dD} t | }t| t | ||d\}}}|jrÈd}t|| ¡ }
|
W 5 Q R X |räd} nd } |d
|
krôd }tj| ||| ||
|
d } | S ) a
|
Open a .npy file as a memory-mapped array.
|
|
This may be used to read an existing file or create a new one.
|
|
Parameters
|
----------
|
filename : str or path-like
|
The name of the file on disk. This may *not* be a file-like
|
object.
|
mode : str, optional
|
The mode in which to open the file; the default is 'r+'. In
|
addition to the standard file modes, 'c' is also accepted to mean
|
"copy on write." See `memmap` for the available mode strings.
|
dtype : data-type, optional
|
The data type of the array if we are creating a new file in "write"
|
mode, if not, `dtype` is ignored. The default value is None, which
|
results in a data-type of `float64`.
|
shape : tuple of int
|
The shape of the array if we are creating a new file in "write"
|
mode, in which case this parameter is required. Otherwise, this
|
parameter is ignored and is thus optional.
|
fortran_order : bool, optional
|
Whether the array should be Fortran-contiguous (True) or
|
C-contiguous (False, the default) if we are creating a new file in
|
"write" mode.
|
version : tuple of int (major, minor) or None
|
If the mode is a "write" mode, then this is the version of the file
|
format used to create the file. None means use the oldest
|
supported version that is able to store the data. Default: None
|
max_header_size : int, optional
|
Maximum allowed size of the header. Large headers may not be safe
|
to load securely and thus require explicitly passing a larger value.
|
See :py:meth:`ast.literal_eval()` for details.
|
|
Returns
|
-------
|
marray : memmap
|
The memory-mapped array.
|
|
Raises
|
------
|
ValueError
|
If the data or the mode is invalid.
|
OSError
|
If the file is not found or cannot be opened correctly.
|
|
See Also
|
--------
|
numpy.memmap
|
|
zZFilename must be a string or a path-like object. Memmap cannot use existing file handles.Úwz6Array can't be memory-mapped: Python objects in dtype.)r r r ÚbÚrbr£ r r zw+r² )r7 r r ÚmoderE )r r r r? r7 r r r8 Úopenr rm Útellr$ ru Zmemmap) Úfilenamer¶ r7 r r r rs r rM r# rE r Zmarrayr r r Ú open_memmapD sL 7
|
ý ÿ ÿrº úran out of datac C s t }z:| |t| ¡}||7 }t|dks:t||kr>W qXW q tk
|
rT Y qX qt||krd}t|||t|f n|S dS )a+
|
Read from file-like object until size bytes are read.
|
Raises ValueError if not EOF is encountered before size bytes are read.
|
Non-blocking objects only supported if they derive from io objects.
|
|
Required as e.g. ZipExtFile in python 2.6 can return less data than
|
requested.
|
r z)EOF: reading %s, expected %d bytes got %dN)r ÚreadrB ÚBlockingIOErrorr )r# ÚsizeÚerror_templater° Úrr r r r r! ¯ s r! )N)NTN)FN)r² NNFN)r» )'Ú__doc__r? r2 Znumpy.lib.utilsr Z numpy.compatr r r Ú__all__r r rB r" rU rª ri rS Z_MAX_HEADER_SIZEr r r$ r& r8 rA rN r] r` rm rp rq rw rx r ru r¢ r± rº r! r r r r Ú<module> sX $
|
ý
|
$8
|
# $ '# A
|
Hÿ j ÿþ k
|
