HEX
Server: Apache
System: Linux pdx1-shared-a1-38 6.6.104-grsec-jammy+ #3 SMP Tue Sep 16 00:28:11 UTC 2025 x86_64
User: mmickelson (3396398)
PHP: 8.1.31
Disabled: NONE
$ pwd: /lib/python3/dist-packages/numpy/core/__pycache__/
Upload Files
File: //lib/python3/dist-packages/numpy/core/__pycache__/records.cpython-310.pyc
o

6��aP��@s8dZddlZddlZddlmZddlmZddlmZ	ddlm
Zddlm
Z
dd	lmZdd
lmZgd�Ze	jZdd
ddd
ddddd
ddddd�ZejZdd�Zed�Gdd�d��ZGdd�dej�ZGdd�de�Zdd�Z		d+dd�Z		d+d d!�Z		d,d"d#�Zd$d%�Z 		d,d&d'�Z!		(d-d)d*�Z"dS).a�
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�)�numeric)�numerictypes)�	os_fspath)�
set_module)�get_printoptions)�record�recarray�
format_parser�
fromarrays�fromrecords�
fromstring�fromfile�array�>�<�=�s�|)�b�l�n�B�L�N�Srrrrr�I�icCsdd�t|���D�S)z@Find duplication in a list, return a list of duplicated elementscSsg|]
\}}|dkr|�qS�r�)�.0�item�countsr!r!�4/usr/lib/python3/dist-packages/numpy/core/records.py�
<listcomp>Qs
�z"find_duplicate.<locals>.<listcomp>)r�items)�listr!r!r%�find_duplicateOs
�r)�numpyc@s4eZdZdZd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�|durtd��t|t�rt�dd�t|�D�|�}nt�||�}|j��dur4t�d|fg|�}|j�|j}�fdd�|D�|_�fdd�|D�|_	t
|�|_dS)z Parse the field formats NzNeed formats argumentcSsg|]\}}d�|�|f�qS)zf{})�format)r"r�format_r!r!r%r&��z/format_parser._parseFormats.<locals>.<listcomp>�f1c�g|]}�|d�qS�rr!�r"�key��fieldsr!r%r&��cr:r r!r<r>r!r%r&�r@)�
ValueError�
isinstancer(�sb�dtype�	enumerater?r1�
_f_formats�_offsets�len�_nfields)r/r0r3rD�keysr!r>r%r,�s 
�zformat_parser._parseFormatscCs�|r,t|�ttfvrnt|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 %scS�g|]}|���qSr!��strip�r"rr!r!r%r&��z0format_parser._setfieldnames.<locals>.<listcomp>NcSsg|]}d|�qS)zf%dr!�r"rr!r!r%r&�rPzDuplicate field names: %scSrLr!rMrOr!r!r%r&�rP)�typer(�tuplerB�str�split�	NameError�reprrI�_names�rangerHr)rA�_titles)r/r1r2�_dupr!r!r%r-�s*
�
"�zformat_parser._setfieldnamescCsDt�|j|j|j|jd��}|durt|d}|�|�}||_dS)N)r1r0�offsetsr2r)rCrDrXrFrGrZ�_byteorderconv�newbyteorder)r/r4rDr!r!r%r.�s�

zformat_parser._createdtype)FN)F)�__name__�
__module__�__qualname__�__doc__r5r,r-r.r!r!r!r%rXs
:
$rcsTeZdZdZdZdZ�fdd�Z�fdd�Zdd�Zd	d
�Zdd�Zd
d�Z	�Z
S)r
zEA data-type scalar that allows field access as attribute lookup.
    r*cs t�ddkr|��St���S�N�legacy�1.13)r	�__str__�super�__repr__�r/��	__class__r!r%rh�s
zrecord.__repr__cs$t�ddkr
t|���St���Src)r	rTr#rgrfrirjr!r%rf�s
zrecord.__str__cCs�|dvrtj�||�Sztj�||�WStyYnwtj�|d�j}|�|d�}|rW|j|dd��}z|j}WntyF|YSw|jdurU|�	|j
|jf�S|Std|��)N��setfield�getfieldrDrD��%'record' object has no attribute '%s')�nt�void�__getattribute__�AttributeErrorr?�getrnrDr1�viewrk)r/�attr�	fielddict�res�obj�dtr!r!r%rs�s,�
�
�zrecord.__getattribute__cCsv|dvr
td|��tj�|d�j}|�|d�}|r'|j|g|dd��R�St||d�r5tj�|||�Std|��)NrlzCannot set '%s' attributerDrorp)	rtrqrrrsr?rurm�getattr�__setattr__)r/rw�valrxryr!r!r%r}s�zrecord.__setattr__cCs<tj�||�}t|tj�r|jjdur|�|j|jf�S|Sr+)rqrr�__getitem__rBrDr1rvrk�r/�indxrzr!r!r%rszrecord.__getitem__cs@�jj}tdd�|D��}d|���fdd�|D�}d�|�S)zPretty-print all fields.css�|]}t|�VqdSr+)rH�r"�namer!r!r%�	<genexpr>(s�z record.pprint.<locals>.<genexpr>z%% %ds: %%scsg|]}�|t�|�f�qSr!)r|r���fmtr/r!r%r&*r8z!record.pprint.<locals>.<listcomp>�
)rDr1�max�join)r/r1�maxlen�rowsr!r�r%�pprint$s

z
record.pprint)r_r`rarbrhrfrsr}rr��
__classcell__r!r!rjr%r
�s
r
csbeZdZdZdZdZ			ddd�Zd	d
�Zdd�Zd
d�Z�fdd�Zdd�Z	ddd�Z
�ZS)ra-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*NrF�Cc	Csh|dur
t�|�}n	t||||
|	�j}|dur$tj||t|f|d�}
|
Stj||t|f||||d�}
|
S)N)�order)�buffer�offset�stridesr�)rCrDr�ndarray�__new__r
)�subtype�shaperD�bufr�r�r0r1r2r4r3r��descrr/r!r!r%r��s��zrecarray.__new__cCs,|jjtur|jjdur|j|_dSdSdSr+)rDrRr
r1)r/rzr!r!r%�__array_finalize__�s�zrecarray.__array_finalize__c
Cs�zt�||�WStyYnwt�|d�j}z
||dd�}Wnttfy7}ztd|�|�d}~ww|j|�}|jj	durXt
|jjtj
�rV|j|jj|jfd�S|S|�t�S)NrDrozrecarray has no attribute %s�rD)�objectrsrtr�r?�	TypeError�KeyErrorrnrDr1�
issubclassrRrqrrrv)r/rwrxry�erzr!r!r%rs�s$���

zrecarray.__getattribute__c
Cs|dkrt|jtj�r|jdurt�t|f�}||jv}z	t	�
|||�}Wnty<t�
|d�jp4i}||vr:�Yn&wt�
|d�jpEi}||vrL|S|rbzt	�||�Wntya|YSwz
||dd�}Wnttfy�}ztd|�|�d}~ww|j|g|�R�S)NrDroz record array has no attribute %s)r�rRrqrrr1rCrDr
�__dict__r�r}�	Exceptionr�rsr?�__delattr__r�r�rtrm)r/rwr~�newattr�retrxryr�r!r!r%r}�s> 
�������zrecarray.__setattr__csjt��|�}t|t�r3|jjdur-|�t|��}t|jjt	j
�r+|j|jj|jfd�S|S|jtd�S|S)Nr�)rR)rgrrBr�rDr1rvrRr�rqrrr�rjr!r%r�s
zrecarray.__getitem__cCs�|j}|jjtust|jjtj�s#|jturt�tj|f�}d}d}nd}d}|jdks1|jdkr;tj	|d|dd	�}nd
t
|j�f}ddt|�}t�d
dkrVd|}||||fS)Nz
rec.array(zrec.array(%s,%sdtype=%s)zarray(z)array(%s,%sdtype=%s).view(numpy.recarray)rr;z, rK)�	separator�prefix�suffixz[], shape=%sr�� rdre)
rDrRr
r�rqrrrC�sizer��array2stringrWrHr	)r/�
repr_dtyper�r��lst�lfr!r!r%rhs"
�zrecarray.__repr__cCs|t|t�rt�|d�j}||}t�|d�j}||dd�}|dur5|j|�}|jjdur0|S|�t�S|j	|g|�R�S)NrDro)
rB�intr�rsr1r?rnrDrvrm)r/rwr~r1rxryrzr!r!r%�field/s


zrecarray.field)
NNrNNNNNFr�r+)r_r`rarbr�r�rsr}rrhr�r�r!r!rjr%r5sj
�"!!rcCs |dkrtjdtdd�dS|S)Nrz�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_NoneAs�r�FcCs8dd�|D�}t|�}|dur|dj}nt|t�r|f}|dur,|dur,dd�|D�}|dur6t�|�}n	t|||||�j}|j}	t|�t|�krNt	d��|dj}
t|
�}|dkrb|d|�}t
|�D]\}}
||j}|
jd|
j|�}||kr�t	d|��qft||�}t
t|��D]
}||||	|<q�|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')])
    cSsg|]}t�|��qSr!)rC�asarray)r"�xr!r!r%r&}szfromarrays.<locals>.<listcomp>NrcSsg|]}|j�qSr!r�)r"rzr!r!r%r&�sz>mismatch between the number of fields and the number of arraysz array-shape mismatch in array %d)r�r�rBr�rCrDrr1rHrArE�ndimrrY)�	arrayListrDr�r0r1r2r3r4r�rX�d0�nn�krz�	testshape�_arrayrr!r!r%r
Ms80


�
r
c	sD|dur(|dur(tj|td���fdd�t�jd�D�}t|||||||d�S|dur4t�t|f�}	n	t|||||�j}	z	tj||	d�}
WnHt	t
fy�t|�}|dur[t|�}t
|t�rc|f}t|�dkrmt
d��t||	�}t|j�D]
}t||�||<qwtjd	td
d�|YSw|dur�|
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�cs"g|]
}t��d|f����qS).)rCr�tolistrQ�rzr!r%r&�s"zfromrecords.<locals>.<listcomp>���)r0r�r1r2r3r4rzCan 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 errorror�)rCrr�rYr�r
rDr
rr�rAr�rHrBr�rr�rSr�r�r�rv)�recListrDr�r0r1r2r3r4�arrlistr��retvalr�r�ryr!r�r%r�s@+
�

��
rc	Csx|dur|durtd��|durt�|�}	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�rCrDr�itemsizer�rHr)�
datastringrDr�r�r0r1r2r3r4r�r�r�r!r!r%r�s7rc
Cs>|��}z|�dd�|��|W|�|d�S|�|d�w)Nrro)�tell�seek)�fd�posr!r!r%�get_remaining_sizeHs
r�c	Csl|dur|durtd��t|�}|durd}nt|t�r|f}t|d�r)t|�}	ntt|�d�}	|	�z}|dkr=|�|d�t	|�}
|durKt
�|�}n	t|||||�j}|j
}t
�|�jtjd�}
|
|}|dkr�t|�}|
|||�d	�<t|�}t
�|�jtjd�}
|
|}||
kr�td
��t||�}|�|j�}||kr�td��Wd�|S1s�wY|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�rbrrr�r�z:Not enough bytes left in file for specified shape and typez%Didn't read as many bytes as expected)r�r�rBr��hasattrr�openrr�r�rCrDrr�r�prodrq�intpr(�indexrSrArr��data�IOError)r�rDr�r�r0r1r2r3r4�ctxr�r�r��	shapeprod�	shapesize�nbytesr��
nbytesreadr!r!r%rPsN-


�
�
� � rTcCs�t|td�tf�st|d�r|dur|durtd��i}|dur&t�|�}n|dur4t|||||	�j}n|||||	d�}|durQ|durHtd��t|||||d�St|t	�rbt
||f||d�|��St|ttf�r�t|dttf�r}t
|f||d	�|��St|f||d	�|��St|t�r�|dur�|j|kr�|�|�}n|}|
r�|��}|St|d�r�t||||d
�St|t�r�|dur�|j|kr�|�|�}n|}|
r�|��}|�t�St|dd�}
|
dus�t|
t�s�td��t�|�}|dur�|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)r0r1r2r3r4z"Must define a shape if obj is None)r�r�r�)r�r�r)rDr�)rDr�r��__array_interface__zUnknown input type)rBrRrTr�rArCrDrr�bytesrr(rSrr
rv�copyrr�r|�dictr)rzrDr�r�r�r0r1r2r3r4r��kwds�new�	interfacer!r!r%r�sfT���







r)NNNNNFN)NNrNNNFN)
NNrNNNNFNT)#rb�osr��collectionsr�
contextlibr�rrCrrq�numpy.compatr�numpy.core.overridesr�
arrayprintr	�__all__r�r]�
sctypeDict�numfmtr)rrrr
rr�r
rrr�rrr!r!r!r%�<module>sj#�	U
�]
�T
�J
�c�
@ Telegram