o

���g���@sX
dZd
dl
Z
d
dlmZ
d
dlmZ
ddlmZ
ddlm	Z

dd	lmZ
d
d
l
mZ
ddlmZ
gd�
Ze
jZd
ddd
ddddd
dddddd�ZejZdd�Zed�
Gdd�d��
ZGdd�dej�ZGdd�de�Zdd�Zed�
		d-d d!�
�
Zed�
		d-d"d#�
�
Zed�
		d.d$d%�
�
Zd&d'�Zed�
		d.d(d)�
�
Z ed�
		*d/d+d,�
�
Z!dS)0a�
Record Arrays
=============
Record arrays expose the fields of structured arrays as properties.

Most commonly, ndarrays contain elements of a single type, e.g. floats,
integers, bools etc.  However, it is possible for elements to be combinations
of these using structured types, such as::

  >>> a = np.array([(1, 2.0), (1, 2.0)], dtype=[('x', np.int64), ('y', np.float64)])
  >>> a
  array([(1, 2.), (1, 2.)], dtype=[('x', '<i8'), ('y', '<f8')])

Here, each element consists of two fields: x (and int), and y (a float).
This is known as a structured array.  The different fields are analogous
to columns in a spread-sheet.  The different fields can be accessed as
one would a dictionary::

  >>> a['x']
  array([1, 1])

  >>> a['y']
  array([2., 2.])

Record arrays allow us to access fields as properties::

  >>> ar = np.rec.array(a)

  >>> ar.x
  array([1, 1])

  >>> ar.y
  array([2., 2.])

�N)
�Counter)
�nullcontext�)
�
set_module�
)
�numeric)
�numerictypes)
�	os_fspath)
�_get_legacy_print_mode)�record�recarray�
format_parser�
fromarrays�fromrecords�
fromstring�fromfile�array�
>�
<�
=�
s�
|)�
b�
l�
n�
B�
L�
N�
Srrrrr�
I�
ic

Csd
d�t|�
�
�D�
S)z@Find duplication in a list, return a list of duplicated elementsc
Ssg|]
\}
}|dkr|
�qS�
r�)�.0�item�countsr"r"�E/home/arjun/.local/lib/python3.10/site-packages/numpy/core/records.py�
<listcomp>Ps

�z"find_duplicate.<locals>.<listcomp>)r�items)
�listr"r"r&�find_duplicateNs
�r*�numpyc@s4eZ
dZd
Zddd�
Zd
dd�
Zdd	�Zd
d�ZdS)r
a�
    Class to convert formats, names, titles description to a dtype.

    After constructing the format_parser object, the dtype attribute is
    the converted data-type:
    ``dtype = format_parser(formats, names, titles).dtype``

    Attributes
    ----------
    dtype : dtype
        The converted data-type.

    Parameters
    ----------
    formats : str or list of str
        The format description, either specified as a string with
        comma-separated format descriptions in the form ``'f8, i4, a5'``, or
        a list of format description strings  in the form
        ``['f8', 'i4', 'a5']``.
    names : str or list/tuple of str
        The field names, either specified as a comma-separated string in the
        form ``'col1, col2, col3'``, or as a list or tuple of strings in the
        form ``['col1', 'col2', 'col3']``.
        An empty list can be used, in that case default field names
        ('f0', 'f1', ...) are used.
    titles : sequence
        Sequence of title strings. An empty list can be used to leave titles
        out.
    aligned : bool, optional
        If True, align the fields by padding as the C-compiler would.
        Default is False.
    byteorder : str, optional
        If specified, all the fields will be changed to the
        provided byte-order.  Otherwise, the default byte-order is
        used. For all available string specifiers, see `dtype.newbyteorder`.

    See Also
    --------
    dtype, typename, sctype2char

    Examples
    --------
    >>> np.format_parser(['<f8', '<i4', '<a5'], ['col1', 'col2', 'col3'],
    ...                  ['T1', 'T2', 'T3']).dtype
    dtype([(('T1', 'col1'), '<f8'), (('T2', 'col2'), '<i4'), (('T3', 'col3'), 'S5')])

    `names` and/or `titles` can be empty lists. If `titles` is an empty list,
    titles will simply not appear. If `names` is empty, default field names
    will be used.

    >>> np.format_parser(['f8', 'i4', 'a5'], ['col1', 'col2', 'col3'],
    ...                  []).dtype
    dtype([('col1', '<f8'), ('col2', '<i4'), ('col3', '<S5')])
    >>> np.format_parser(['<f8', '<i4', '<a5'], [], []).dtype
    dtype([('f0', '<f8'), ('f1', '<i4'), ('f2', 'S5')])

    FNcCs&|�|
|�
|�
||�
|�|�

dS�
N)�
_parseFormats�_setfieldnames�_createdtype)�self�formats�names�titles�aligned�	byteorderr"r"r&�__init__�s


zformat_parser.__init__cs�|
d
urtd�
�
t
|
t�rt�dd�t|
�
D�
|�}nt�|
|�}|j��d
ur4t�d|fg
|�}|j�|j}�f
dd�|D�
|_�f
dd�|D�
|_	t
|�
|_d
S)z Parse the field formats NzNeed formats argumentc
Ssg|]\}
}d�|
�
|f�qS)
zf{})
�format)r#r �format_r"r"r&r'��z/format_parser._parseFormats.<locals>.<listcomp>�f1c
�g|]}
�|
d�qS�
r
r"�r#�key�
�fieldsr"r&r'��c
r;r!r"r=r?r"r&r'�rA)�
ValueError�
isinstancer)�sb�dtype�	enumerater@r2�
_f_formats�_offsets�len�_nfields)r0r1r4rE�keysr"r?r&r-�s 





�







zformat_parser._parseFormatscCs�|
r,t|
�
t
tfvrnt|
t�r|
�d
�
}
ntdt|
�
�
�
dd�|
d|j�D�
|_	ng|_	|j	dd�t
t|j	�
|j�D�
7_	t|j	�
}|rOt
d|�
�
|r_dd�|d|j�D�
|_ng|_g}|jt|�
kr||jdg
|jt|�
7_dSdS)	zQconvert input field names into a list and assign to the _names
        attribute �
,zillegal input names %sc
S�g|]}
|
���qSr"�
�strip�r#rr"r"r&r'��z0format_parser._setfieldnames.<locals>.<listcomp>Nc
Ssg|]}
d|
�qS)
zf%dr"�r#r r"r"r&r'�rQzDuplicate field names: %sc
SrMr"rNrPr"r"r&r'�rQ)�typer)�tuplerC�str�split�	NameError�reprrJ�_names�rangerIr*rB�_titles)r0r2r3�_dupr"r"r&r.�s*





�




"
�zformat_parser._setfieldnamescCsDt�
|j|j|j|jd
��
}|
du
rt|
d}
|�|
�
}||_
dS)N)r2r1�offsetsr3r
)rDrErYrGrHr[�_byteorderconv�newbyteorder)r0r5rEr"r"r&r/�s




�



zformat_parser._createdtype)FN)
F)�__name__�
__module__�__qualname__�__doc__r6r-r.r/r"r"r"r&r
Ws
:
$r
csTeZ
dZd
ZdZdZ
�f
dd�Z�f
dd�Zdd�Zd	d
�Zdd�Zd
d�Z	�Z
S)rzEA data-type scalar that allows field access as attribute lookup.
    r+c

st�d
k
r	|�
�St���S�N�q)r
�__str__�super�__repr__�
r0�
�	__class__r"r&rh�s




zrecord.__repr__c

s t�d
k
rt
|���
St���Srd)r
rUr$rgrfrirjr"r&rf�s




zrecord.__str__cCs�|
d
vrtj
�||
�Sztj
�||
�WSty


Yn
wtj
�|d�j}|�|
d�}|rW|j|dd��}z|j}WntyF


|YSw|jdu
rU|�	|j
|jf�
S|Std|
�
�
)N��setfield�getfieldrErEr�%'record' object has no attribute '%s')�nt�void�__getattribute__�AttributeErrorr@�getrnrEr2�viewrk)r0�attr�	fielddict�res�obj�dtr"r"r&rr�s,





�





�



�zrecord.__getattribute__cCsv|
d
vr
td|
�
�
t
j�|d�j}|�|
d�}|r'|j|g
|dd��
R�St||
d�r5t
j�||
|�Std|
�
�
)NrlzCannot set '%s' attributerErro)	rsrprqrrr@rtrm�getattr�__setattr__)r0rv�valrwrxr"r"r&r|
s







�zrecord.__setattr__cCs<tj
�||
�}t|tj
�r|jjdu
r|�|j|jf�
S|Sr,)rprq�__getitem__rCrEr2rurk�r0�indxryr"r"r&r~
s

zrecord.__getitem__c
s@�
jj
}
td
d�|
D�
�
}d|���
fdd�|
D�
}d�|�
S)zPretty-print all fields.c
ss�|]}
t|
�
V
qdSr,)
rI�r#�namer"r"r&�	<genexpr>'
s�z record.pprint.<locals>.<genexpr>z%% %ds: %%sc
sg|]}
�|
t�
|
�f�qSr")
r{r���fmtr0r"r&r')
r9z!record.pprint.<locals>.<listcomp>�

)rEr2�max�join)r0r2�maxlen�rowsr"r�r&�pprint#
s





z
record.pprint)r`rarbrcrhrfrrr|r~r��
__classcell__r"r"rjr&r�s


rcsbeZ
dZd
ZdZdZ
			ddd�
Zd	d
�Zdd�Zd
d�Z�f
dd�Zdd�Z	ddd�
Z
�ZS)ra-Construct an ndarray that allows field access using attributes.

    Arrays may have a data-types containing fields, analogous
    to columns in a spread sheet.  An example is ``[(x, int), (y, float)]``,
    where each entry in the array is a pair of ``(int, float)``.  Normally,
    these attributes are accessed using dictionary lookups such as ``arr['x']``
    and ``arr['y']``.  Record arrays allow the fields to be accessed as members
    of the array, using ``arr.x`` and ``arr.y``.

    Parameters
    ----------
    shape : tuple
        Shape of output array.
    dtype : data-type, optional
        The desired data-type.  By default, the data-type is determined
        from `formats`, `names`, `titles`, `aligned` and `byteorder`.
    formats : list of data-types, optional
        A list containing the data-types for the different columns, e.g.
        ``['i4', 'f8', 'i4']``.  `formats` does *not* support the new
        convention of using types directly, i.e. ``(int, float, int)``.
        Note that `formats` must be a list, not a tuple.
        Given that `formats` is somewhat limited, we recommend specifying
        `dtype` instead.
    names : tuple of str, optional
        The name of each column, e.g. ``('x', 'y', 'z')``.
    buf : buffer, optional
        By default, a new array is created of the given shape and data-type.
        If `buf` is specified and is an object exposing the buffer interface,
        the array will use the memory from the existing buffer.  In this case,
        the `offset` and `strides` keywords are available.

    Other Parameters
    ----------------
    titles : tuple of str, optional
        Aliases for column names.  For example, if `names` were
        ``('x', 'y', 'z')`` and `titles` is
        ``('x_coordinate', 'y_coordinate', 'z_coordinate')``, then
        ``arr['x']`` is equivalent to both ``arr.x`` and ``arr.x_coordinate``.
    byteorder : {'<', '>', '='}, optional
        Byte-order for all fields.
    aligned : bool, optional
        Align the fields in memory as the C-compiler would.
    strides : tuple of ints, optional
        Buffer (`buf`) is interpreted according to these strides (strides
        define how many bytes each array element, row, column, etc.
        occupy in memory).
    offset : int, optional
        Start reading buffer (`buf`) from this offset onwards.
    order : {'C', 'F'}, optional
        Row-major (C-style) or column-major (Fortran-style) order.

    Returns
    -------
    rec : recarray
        Empty array of the given shape and type.

    See Also
    --------
    core.records.fromrecords : Construct a record array from data.
    record : fundamental data-type for `recarray`.
    format_parser : determine a data-type from formats, names, titles.

    Notes
    -----
    This constructor can be compared to ``empty``: it creates a new record
    array but does not fill it with data.  To create a record array from data,
    use one of the following methods:

    1. Create a standard ndarray and convert it to a record array,
       using ``arr.view(np.recarray)``
    2. Use the `buf` keyword.
    3. Use `np.rec.fromrecords`.

    Examples
    --------
    Create an array with two fields, ``x`` and ``y``:

    >>> x = np.array([(1.0, 2), (3.0, 4)], dtype=[('x', '<f8'), ('y', '<i8')])
    >>> x
    array([(1., 2), (3., 4)], dtype=[('x', '<f8'), ('y', '<i8')])

    >>> x['x']
    array([1., 3.])

    View the array as a record array:

    >>> x = x.view(np.recarray)

    >>> x.x
    array([1., 3.])

    >>> x.y
    array([2, 4])

    Create a new, empty record array:

    >>> np.recarray((2,),
    ... dtype=[('x', int), ('y', float), ('z', int)]) #doctest: +SKIP
    rec.array([(-1073741821, 1.2249118382103472e-301, 24547520),
           (3471280, 1.2134086255804012e-316, 0)],
          dtype=[('x', '<i4'), ('y', '<f8'), ('z', '<i4')])

    r+Nr
F�
Cc	Csh|du
r
t�
|�
}n	t||||
|	�j
}|dur$tj||
t|f|d
�}
|
Stj||
t|f||||d�}
|
S)N)
�order)�buffer�offset�stridesr�)rDrEr
�ndarray�__new__r)�subtype�shaperE�bufr�r�r1r2r3r5r4r��descrr0r"r"r&r��
s

�

�zrecarray.__new__cCs,|jj
tu
r|jjdu
r|j|_dSdSdSr,)rErSrr2)r0ryr"r"r&�__array_finalize__�
s
�zrecarray.__array_finalize__c
Cs�zt�
||
�WSty


Yn
wt�
|d
�j}z
||
dd�}Wnttfy7
}
ztd|
�
|�d}~w
w|j|�}|jj	du
rXt
|jjtj
�rV|j|jj|jfd�
S|S|�t�
S)NrErzrecarray has no attribute %s�
rE)�objectrrrsr�r@�	TypeError�KeyErrorrnrEr2�
issubclassrSrprqru)r0rvrwrx�
eryr"r"r&rr�
s$


�



��




zrecarray.__getattribute__c
Cs
|
d
krt|j
tj�r|jdu
rt�t|f�
}|
|jv
}z	t	�
||
|�}Wnty<


t�
|d
�jp4i}|
|v
r:�Yn&wt�
|d
�jpEi}|
|v
rL|S|rbzt	�||
�
Wntya


|YSwz
||
dd�}Wnttfy�
}
ztd|
�
|�d}~w
w|j|g
|�
R�S)NrErz record array has no attribute %s)r�rSrprqr2rDrEr�__dict__r�r|�	Exceptionr�rrr@�__delattr__r�r�rsrm)r0rvr}�newattr�retrwrxr�r"r"r&r|�
s> 







��





�



����zrecarray.__setattr__csjt��
|
�
}t|t�r3|jjdu
r-|�t|�
�
}t|jjt	j
�r+|j|jj|jfd
�
S|S|jtd�
S|S)Nr�)
rS)rgr~rCr�rEr2rurSr�rprqrrjr"r&r~�
s






zrecarray.__getitem__c
Cs�|j}
|jj
tust|jj
tj�s#|
j
turt�tj|
f�
}
d
}d}nd}d}|jdks1|jdkr;tj	|d|dd	�}nd
t
|j�
f
}ddt|�
}t�d
k
rTd|}||||
fS)Nz
rec.array(zrec.array(%s,%sdtype=%s)zarray(z)array(%s,%sdtype=%s).view(numpy.recarray)r
r<z, rL)�	separator�prefix�suffixz[], shape=%sr��
 re)
rErSrr�rprqrD�sizer��array2stringrXrIr
)r0�
repr_dtyper�r��lst�lfr"r"r&rh
s"







�



zrecarray.__repr__cCs|t|
t
�rt�|d
�j}||
}
t�|d
�j}||
dd�}|dur5|j|�}|jjdu
r0|S|�t�
S|j	|g
|�
R�S)NrEr)
rC�intr�rrr2r@rnrErurm)r0rvr}r2rwrxryr"r"r&�field.s









zrecarray.field)
NNr
NNNNNFr�r,)r`rarbrcr�r�rrr|r~rhr�r�r"r"rjr&r4
s
j



�"!!rc

Cs |d
krtj
dtdd�
dS|S)Nr
z�Passing `shape=0` to have the shape be inferred is deprecated, and in future will be equivalent to `shape=(0,)`. To infer the shape and suppress this warning, pass `shape=None` instead.��
�
stacklevel)�warnings�warn�
FutureWarning)
r�r"r"r&�_deprecate_shape_0_as_None@s


�r�z	numpy.recFcCs0
d
d�|D�
}t|�
}|dur|dj
}nt|t�r|f
}|dur,|
dur,dd�|D�
}|
du
r6t�|
�
}n	t|||||�j}|j}	t|�
t|�
krNt	d�
�
|dj
}
t|
�
}|dkrb|d|�}t
||�}t|�
D]*\}
}||
j}|j
d|j|�}|	|
}||kr�t	d|
�d|�d	��
�
|||<qk|S)
a�Create a record array from a (flat) list of arrays

    Parameters
    ----------
    arrayList : list or tuple
        List of array-like objects (such as lists, tuples,
        and ndarrays).
    dtype : data-type, optional
        valid dtype for all arrays
    shape : int or tuple of ints, optional
        Shape of the resulting array. If not provided, inferred from
        ``arrayList[0]``.
    formats, names, titles, aligned, byteorder :
        If `dtype` is ``None``, these arguments are passed to
        `numpy.format_parser` to construct a dtype. See that function for
        detailed documentation.

    Returns
    -------
    np.recarray
        Record array consisting of given arrayList columns.

    Examples
    --------
    >>> x1=np.array([1,2,3,4])
    >>> x2=np.array(['a','dd','xyz','12'])
    >>> x3=np.array([1.1,2,3,4])
    >>> r = np.core.records.fromarrays([x1,x2,x3],names='a,b,c')
    >>> print(r[1])
    (2, 'dd', 2.0) # may vary
    >>> x1[1]=34
    >>> r.a
    array([1, 2, 3, 4])

    >>> x1 = np.array([1, 2, 3, 4])
    >>> x2 = np.array(['a', 'dd', 'xyz', '12'])
    >>> x3 = np.array([1.1, 2, 3,4])
    >>> r = np.core.records.fromarrays(
    ...     [x1, x2, x3],
    ...     dtype=np.dtype([('a', np.int32), ('b', 'S3'), ('c', np.float32)]))
    >>> r
    rec.array([(1, b'a', 1.1), (2, b'dd', 2. ), (3, b'xyz', 3. ),
               (4, b'12', 4. )],
              dtype=[('a', '<i4'), ('b', 'S3'), ('c', '<f4')])
    c
Ssg|]}
t�
|
�
�qSr")rD�asarray)r#�
xr"r"r&r'}szfromarrays.<locals>.<listcomp>Nr
c
Ssg|]}
|
j�qSr"r�)r#ryr"r"r&r'�sz>mismatch between the number of fields and the number of arrayszarray-shape mismatch in array z ("z"))
r�r�rCr�rDrEr
r2rIrBrrF�ndim)�	arrayListrEr�r1r2r3r4r5r�rY�d0�nn�_array�
kry�	testshaper�r"r"r&rLs61


















rc	sD
|d
ur(|
d
ur(tj
|td���f
dd�t�jd�
D�
}t|||||||d�S|
d
u
r4t�t|
f�
}	n	t|||||�j}	z	tj
||	d�}
WnHt	t
fy�


t|�
}|d
ur[t|�
}t
|t�rc|f
}t|�
dkrmt
d�
�
t||	�}t|j�
D]
}t||�
||<qwtjd	td
d�
|YSw|d
u
r�|
j|kr�||
_|
�t�
}
|
S)aCreate a recarray from a list of records in text form.

    Parameters
    ----------
    recList : sequence
        data in the same field may be heterogeneous - they will be promoted
        to the highest data type.
    dtype : data-type, optional
        valid dtype for all arrays
    shape : int or tuple of ints, optional
        shape of each array.
    formats, names, titles, aligned, byteorder :
        If `dtype` is ``None``, these arguments are passed to
        `numpy.format_parser` to construct a dtype. See that function for
        detailed documentation.

        If both `formats` and `dtype` are None, then this will auto-detect
        formats. Use list of tuples rather than list of lists for faster
        processing.

    Returns
    -------
    np.recarray
        record array consisting of given recList rows.

    Examples
    --------
    >>> r=np.core.records.fromrecords([(456,'dbe',1.2),(2,'de',1.3)],
    ... names='col1,col2,col3')
    >>> print(r[0])
    (456, 'dbe', 1.2)
    >>> r.col1
    array([456,   2])
    >>> r.col2
    array(['dbe', 'de'], dtype='<U3')
    >>> import pickle
    >>> pickle.loads(pickle.dumps(r))
    rec.array([(456, 'dbe', 1.2), (  2, 'de', 1.3)],
              dtype=[('col1', '<i8'), ('col2', '<U3'), ('col3', '<f8')])
    Nr�c
s"g|]
}
t�
�d|
f���
�qS)
.)rDr�tolistrR�
ryr"r&r'�s"zfromrecords.<locals>.<listcomp>���)r1r�r2r3r4r5rzCan only deal with 1-d array.zxfromrecords expected a list of tuples, may have received a list of lists instead. In the future that will raise an errorrr�)rDrr�rZr�rrErr
r�rBr�rIrCr�rr�rTr�r�r�ru)�recListrEr�r1r2r3r4r5�arrlistr��retvalr�r�rxr"r�r&r�s@,




�














��

rc	Csx|
d
ur|d
urtd�
�
|
d
u
rt
�|
�
}	n	t|||||�j}	|	j}
t|�
}|dvr2t|�
||
}t||	||d�}|S)a�Create a record array from binary data

    Note that despite the name of this function it does not accept `str`
    instances.

    Parameters
    ----------
    datastring : bytes-like
        Buffer of binary data
    dtype : data-type, optional
        Valid dtype for all arrays
    shape : int or tuple of ints, optional
        Shape of each array.
    offset : int, optional
        Position in the buffer to start reading from.
    formats, names, titles, aligned, byteorder :
        If `dtype` is ``None``, these arguments are passed to
        `numpy.format_parser` to construct a dtype. See that function for
        detailed documentation.


    Returns
    -------
    np.recarray
        Record array view into the data in datastring. This will be readonly
        if `datastring` is readonly.

    See Also
    --------
    numpy.frombuffer

    Examples
    --------
    >>> a = b'\x01\x02\x03abc'
    >>> np.core.records.fromstring(a, dtype='u1,u1,u1,S3')
    rec.array([(1, 2, 3, b'abc')],
            dtype=[('f0', 'u1'), ('f1', 'u1'), ('f2', 'u1'), ('f3', 'S3')])

    >>> grades_dtype = [('Name', (np.str_, 10)), ('Marks', np.float64),
    ...                 ('GradeLevel', np.int32)]
    >>> grades_array = np.array([('Sam', 33.3, 3), ('Mike', 44.4, 5),
    ...                         ('Aadi', 66.6, 6)], dtype=grades_dtype)
    >>> np.core.records.fromstring(grades_array.tobytes(), dtype=grades_dtype)
    rec.array([('Sam', 33.3, 3), ('Mike', 44.4, 5), ('Aadi', 66.6, 6)],
            dtype=[('Name', '<U10'), ('Marks', '<f8'), ('GradeLevel', '<i4')])

    >>> s = '\x01\x02\x03abc'
    >>> np.core.records.fromstring(s, dtype='u1,u1,u1,S3')
    Traceback (most recent call last)
       ...
    TypeError: a bytes-like object is required, not 'str'
    Nz2fromstring() needs a 'dtype' or 'formats' argument)Nr�)r�r�)r�rDrEr
�itemsizer�rIr)�
datastringrEr�r�r1r2r3r4r5r�r�r�r"r"r&rs8



rc

Cs>|��}
z|�
d
d�
|��|
W|�
|
d
�
S|�
|
d
�
w)Nr
r)�tell�seek)�fd�posr"r"r&�get_remaining_sizeKs




r�c	Csl
|
d
ur|d
urtd�
�
t
|�
}|d
urd}nt|t�r|f
}t|d�r)t|�
}	ntt|�
d�}	|	�z}|dkr=|�|d�
t	|�
}
|
d
u
rKt
�|
�
}n	t|||||�j}|j
}t
�|�
jtjd�
}
|
|}|dkr�t|�
}|
|||�d	�
<t|�
}t
�|�
jtjd�
}
|
|}||
kr�td
�
�
t||�}|�|j�
}||kr�td�
�
Wd
�
|S1s�w



Y
|S)a�Create an array from binary file data

    Parameters
    ----------
    fd : str or file type
        If file is a string or a path-like object then that file is opened,
        else it is assumed to be a file object. The file object must
        support random access (i.e. it must have tell and seek methods).
    dtype : data-type, optional
        valid dtype for all arrays
    shape : int or tuple of ints, optional
        shape of each array.
    offset : int, optional
        Position in the file to start reading from.
    formats, names, titles, aligned, byteorder :
        If `dtype` is ``None``, these arguments are passed to
        `numpy.format_parser` to construct a dtype. See that function for
        detailed documentation

    Returns
    -------
    np.recarray
        record array consisting of data enclosed in file.

    Examples
    --------
    >>> from tempfile import TemporaryFile
    >>> a = np.empty(10,dtype='f8,i4,a5')
    >>> a[5] = (0.5,10,'abcde')
    >>>
    >>> fd=TemporaryFile()
    >>> a = a.newbyteorder('<')
    >>> a.tofile(fd)
    >>>
    >>> _ = fd.seek(0)
    >>> r=np.core.records.fromfile(fd, formats='f8,i4,a5', shape=10,
    ... byteorder='<')
    >>> print(r[5])
    (0.5, 10, 'abcde')
    >>> r.shape
    (10,)
    Nz0fromfile() needs a 'dtype' or 'formats' argument)
r��readinto�rbr
rr�r�z:Not enough bytes left in file for specified shape and typez%Didn't read as many bytes as expected)r�r�rCr��hasattrr�openr	r�r�rDrEr
r�r�prodrp�intpr)�indexrTrBrr��data�OSError)r�rEr�r�r1r2r3r4r5�ctxr�r�r��	shapeprod�	shapesize�nbytesr��
nbytesreadr"r"r&rTsN.


















�



�
� � rTcCs�
t|t
d
�
tf�st|d�r|d
ur|
d
urtd�
�
i}|
d
u
r&t�|
�
}
n|d
u
r4t|||||	�j}
n|||||	d�}|d
urQ|d
urHtd�
�
t||
|||d�St|t	�rbt
||
f||d�|�
�
St|ttf�r�t|dttf�r}t
|f
|
|d	�|�
�
St|f
|
|d	�|�
�
St|t�r�|
d
u
r�|j|
kr�|�|
�
}n|}|
r�|��}|St|d�r�t||
||d
�St|t�r�|
d
u
r�|j|
kr�|�|
�
}n|}|
r�|��}|�t�
St|dd
�}
|
d
us�t|
t�s�td�
�
t�|�
}|
d
u
r�|j|
kr�|�|
�
}|�t�
S)
a�

    Construct a record array from a wide-variety of objects.

    A general-purpose record array constructor that dispatches to the
    appropriate `recarray` creation function based on the inputs (see Notes).

    Parameters
    ----------
    obj : any
        Input object. See Notes for details on how various input types are
        treated.
    dtype : data-type, optional
        Valid dtype for array.
    shape : int or tuple of ints, optional
        Shape of each array.
    offset : int, optional
        Position in the file or buffer to start reading from.
    strides : tuple of ints, optional
        Buffer (`buf`) is interpreted according to these strides (strides
        define how many bytes each array element, row, column, etc.
        occupy in memory).
    formats, names, titles, aligned, byteorder :
        If `dtype` is ``None``, these arguments are passed to
        `numpy.format_parser` to construct a dtype. See that function for
        detailed documentation.
    copy : bool, optional
        Whether to copy the input object (True), or to use a reference instead.
        This option only applies when the input is an ndarray or recarray.
        Defaults to True.

    Returns
    -------
    np.recarray
        Record array created from the specified object.

    Notes
    -----
    If `obj` is ``None``, then call the `~numpy.recarray` constructor. If
    `obj` is a string, then call the `fromstring` constructor. If `obj` is a
    list or a tuple, then if the first object is an `~numpy.ndarray`, call
    `fromarrays`, otherwise call `fromrecords`. If `obj` is a
    `~numpy.recarray`, then make a copy of the data in the recarray
    (if ``copy=True``) and use the new formats, names, and titles. If `obj`
    is a file, then call `fromfile`. Finally, if obj is an `ndarray`, then
    return ``obj.view(recarray)``, making a copy of the data if ``copy=True``.

    Examples
    --------
    >>> a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    array([[1, 2, 3],
           [4, 5, 6],
           [7, 8, 9]])

    >>> np.core.records.array(a)
    rec.array([[1, 2, 3],
               [4, 5, 6],
               [7, 8, 9]],
        dtype=int32)

    >>> b = [(1, 1), (2, 4), (3, 9)]
    >>> c = np.core.records.array(b, formats = ['i2', 'f2'], names = ('x', 'y'))
    >>> c
    rec.array([(1, 1.0), (2, 4.0), (3, 9.0)],
              dtype=[('x', '<i2'), ('y', '<f2')])

    >>> c.x
    rec.array([1, 2, 3], dtype=int16)

    >>> c.y
    rec.array([ 1.0,  4.0,  9.0], dtype=float16)

    >>> r = np.rec.array(['abc','def'], names=['col1','col2'])
    >>> print(r.col1)
    abc

    >>> r.col1
    array('abc', dtype='<U3')

    >>> r.col2
    array('def', dtype='<U3')
    Nr�zIMust define formats (or dtype) if object is None, string, or an open file)r1r2r3r4r5z"Must define a shape if obj is None)r�r�r�)r�r�r
)rEr�)rEr�r��__array_interface__zUnknown input type)rCrSrUr�rBrDrEr
r�bytesrr)rTrrru�copyrr�r{�dictr)ryrEr�r�r�r1r2r3r4r5r��kwds�new�	interfacer"r"r&r�sfU






�
�



�






























r)NNNNNFN)NNr
NNNFN)
NNr
NNNNFNT)"rcr��collectionsr�
contextlibr�_utilsr�rrDrrp�numpy.compatr	�
arrayprintr
�__all__r�r^�
sctypeDict�numfmtr*r
rqrrr�rrrr�rrr"r"r"r&�<module>
sr#


















�	
U

�^

�T

�J	

�d

�