§
    Ëãßc©’  ã                   ó"  — d Z ddlZddlmZ ddlmZ ddlmZ ddlm	Z
 ddlmZ dd	lmZ dd
lmZ g d¢Zej        ZdddddddddddddddœZe
j        Zd„ Z ed¦  «         G d„ d¦  «        ¦   «         Z G d„ de
j        ¦  «        Z G d„ de¦  «        Zd„ Z ed¦  «        	 	 d$d„¦   «         Z ed¦  «        	 	 d$d„¦   «         Z ed¦  «        	 	 d%d„¦   «         Zd „ Z ed¦  «        	 	 d%d!„¦   «         Z  ed¦  «        	 	 d&d#„¦   «         Z!dS )'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_legacy_print_mode)ÚrecordÚrecarrayÚformat_parserÚ
fromarraysÚfromrecordsÚ
fromstringÚfromfileÚarrayú>ú<ú=Úsú|)ÚbÚlÚnÚBÚLÚNÚSr   r   r   r   r   ÚIÚic                 óX   — d„ t          | ¦  «                             ¦   «         D ¦   «         S )z@Find duplication in a list, return a list of duplicated elementsc                 ó$   — g | ]\  }}|d k    ¯|‘ŒS ©r   © )Ú.0ÚitemÚcountss      ú4/usr/lib/python3/dist-packages/numpy/core/records.pyú
<listcomp>z"find_duplicate.<locals>.<listcomp>P   s-   € ð ð ð áˆD�&Ø�AŠ:ˆ:ð 	àˆ:ˆ:ó    )r   Úitems)Úlists    r(   Úfind_duplicater-   N   s5   € ðð å# D™MœM×/Ò/Ñ1Ô1ðñ ô ð r*   Únumpyc                   ó.   — e Zd ZdZdd„Zd	d„Zd„ Zd„ ZdS )
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')])

    FNc                 óˆ   — |                       ||¦  «         |                      ||¦  «         |                      |¦  «         d S ©N)Ú_parseFormatsÚ_setfieldnamesÚ_createdtype)ÚselfÚformatsÚnamesÚtitlesÚalignedÚ	byteorders         r(   Ú__init__zformat_parser.__init__“   sH   € Ø×Ò˜7 GÑ,Ô,Ð,Ø×Ò˜E 6Ñ*Ô*Ð*Ø×Ò˜)Ñ$Ô$Ð$Ð$Ð$r*   c                 óª  ‡— |€t          d¦  «        ‚t          |t          ¦  «        r-t          j        d„ t          |¦  «        D ¦   «         |¦  «        }nt          j        ||¦  «        }|j        Š‰€t          j        d|fg|¦  «        }|j        Š|j        }ˆfd„|D ¦   «         | _        ˆfd„|D ¦   «         | _	        t          |¦  «        | _        dS )z Parse the field formats NzNeed formats argumentc                 óB   — g | ]\  }}d                       |¦  «        |f‘ŒS )zf{})Úformat)r%   r    Úformat_s      r(   r)   z/format_parser._parseFormats.<locals>.<listcomp>Ÿ   s+   € ÐQÐQÐQ±
°°7�%—,’,˜q‘/”/ 7Ð+ÐQÐQÐQr*   Úf1c                 ó,   •— g | ]}‰|         d          ‘ŒS ©r   r$   ©r%   ÚkeyÚfieldss     €r(   r)   z/format_parser._parseFormats.<locals>.<listcomp>©   s!   ø€ Ð:Ð:Ð:¨c˜6 #œ; qœ>Ð:Ð:Ð:r*   c                 ó,   •— g | ]}‰|         d          ‘ŒS r#   r$   rC   s     €r(   r)   z/format_parser._parseFormats.<locals>.<listcomp>ª   s!   ø€ Ð8Ð8Ð8¨C˜ œ QœÐ8Ð8Ð8r*   )Ú
ValueErrorÚ
isinstancer,   ÚsbÚdtypeÚ	enumeraterE   r7   Ú
_f_formatsÚ_offsetsÚlenÚ_nfields)r5   r6   r9   rJ   ÚkeysrE   s        @r(   r2   zformat_parser._parseFormats˜   så   ø€ ð ˆ?ÝÐ4Ñ5Ô5Ð5Ý�g�tÑ$Ô$ð 	/Ý”HØQÐQ½iÈÑ>PÔ>PÐQÑQÔQØñô ˆEˆEõ
 ”H˜W gÑ.Ô.ˆEØ”ˆØˆ>Ý”H˜t U˜m˜_¨gÑ6Ô6ˆEØ”\ˆFØŒ{ˆØ:Ð:Ð:Ð:°TÐ:Ñ:Ô:ˆŒØ8Ð8Ð8Ð8°4Ð8Ñ8Ô8ˆŒÝ˜D™	œ	ˆŒˆˆr*   c                 óÎ  — |r‡t          |¦  «        t          t          fv rnJt          |t          ¦  «        r|                     d¦  «        }nt          dt          |¦  «        z  ¦  «        ‚d„ |d| j        …         D ¦   «         | _	        ng | _	        | xj	        d„ t          t          | j	        ¦  «        | j        ¦  «        D ¦   «         z  c_	        t          | j	        ¦  «        }|rt          d|z  ¦  «        ‚|rd„ |d| j        …         D ¦   «         | _        n	g | _        g }| j        t          |¦  «        k    r+| xj        dg| j        t          |¦  «        z
  z  z  c_        dS dS )zQconvert input field names into a list and assign to the _names
        attribute ú,zillegal input names %sc                 ó6   — g | ]}|                      ¦   «         ‘ŒS r$   ©Ústrip©r%   r   s     r(   r)   z0format_parser._setfieldnames.<locals>.<listcomp>¹   s    € ÐDÐDÐD¨˜1Ÿ7š7™9œ9ÐDÐDÐDr*   Nc                 ó   — g | ]}d |z  ‘ŒS )zf%dr$   )r%   r    s     r(   r)   z0format_parser._setfieldnames.<locals>.<listcomp>Á   s.   € ð Að Að A a˜ ™	ð Að Að Ar*   zDuplicate field names: %sc                 ó6   — g | ]}|                      ¦   «         ‘ŒS r$   rT   rV   s     r(   r)   z0format_parser._setfieldnames.<locals>.<listcomp>É   s    € ÐFÐFÐF¨!˜AŸGšG™IœIÐFÐFÐFr*   )Útyper,   ÚtuplerH   ÚstrÚsplitÚ	NameErrorÚreprrO   Ú_namesÚrangerN   r-   rG   Ú_titles)r5   r7   r8   Ú_dups       r(   r3   zformat_parser._setfieldnames­   s„  € ð ð 
	Ý�E‰{Œ{�t¥U˜mÐ+Ð+ØÝ˜E¥3Ñ'Ô'ð HØŸš CÑ(Ô(��åÐ 8½4À¹;¼;Ñ FÑGÔGÐGàDÐD¨e°N°T´]°NÔ.CÐDÑDÔDˆDŒKˆKàˆDŒKð 	ˆŒð Að A­5µ°T´[Ñ1AÔ1AØ15´ñ,@ô ,@ð Añ Aô Añ 	AˆŒõ ˜dœkÑ*Ô*ˆØð 	AÝÐ8¸4Ñ?Ñ@Ô@Ð@àð 	ØFÐF¨v°n°t´}°nÔ/EÐFÑFÔFˆDŒLˆLàˆDŒLØˆFàŒ=�3˜v™;œ;Ò&Ð&ØˆLŒL˜T˜F d¤mµc¸&±k´kÑ&AÑBÑBˆLŒLˆLˆLð 'Ð&r*   c                 óÂ   — t          j        | j        | j        | j        | j        dœ¦  «        }|�(t          |d                  }|                     |¦  «        }|| _        d S )N)r7   r6   Úoffsetsr8   r   )rI   rJ   r_   rL   rM   ra   Ú_byteorderconvÚnewbyteorder)r5   r:   rJ   s      r(   r4   zformat_parser._createdtypeÑ   se   € Ý”Ø”[Ø”Ø”}Ø”lð	
ð 
ñ ô ˆð Ð Ý& y°¤|Ô4ˆIØ×&Ò& yÑ1Ô1ˆEàˆŒ
ˆ
ˆ
r*   )FN)F)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r;   r2   r3   r4   r$   r*   r(   r   r   W   si   € € € € € ð8ð 8ðt%ð %ð %ð %ð
"ð "ð "ð "ð*"Cð "Cð "CðHð ð ð ð r*   r   c                   óL   ‡ — e Zd ZdZd Z dZˆ fd„Zˆ fd„Zd„ Zd„ Zd„ Zd„ Z	ˆ xZ
S )	r   zEA data-type scalar that allows field access as attribute lookup.
    r.   c                 ó�   •— t          ¦   «         dk    r|                      ¦   «         S t          ¦   «                              ¦   «         S ©Néq   )r
   Ú__str__ÚsuperÚ__repr__©r5   Ú	__class__s    €r(   rq   zrecord.__repr__è   s8   ø€ Ý!Ñ#Ô# sÒ*Ð*Ø—<’<‘>”>Ð!Ý‰wŒw×ÒÑ!Ô!Ð!r*   c                 óª   •— t          ¦   «         dk    r!t          |                      ¦   «         ¦  «        S t          ¦   «                              ¦   «         S rm   )r
   r[   r&   rp   ro   rr   s    €r(   ro   zrecord.__str__í   s>   ø€ Ý!Ñ#Ô# sÒ*Ð*Ý�t—y’y‘{”{Ñ#Ô#Ð#Ý‰wŒw�ŠÑ Ô Ð r*   c                 óø  — |dv r t           j                             | |¦  «        S 	 t           j                             | |¦  «        S # t          $ r Y nw xY wt           j                             | d¦  «        j        }|                     |d ¦  «        }|rW | j        |d d…         Ž }	 |j        }n# t          $ r |cY S w xY w|j        �!| 	                    | j
        |j        f¦  «        S |S t          d|z  ¦  «        ‚)N©ÚsetfieldÚgetfieldrJ   rJ   é   ú%'record' object has no attribute '%s')ÚntÚvoidÚ__getattribute__ÚAttributeErrorrE   Úgetrx   rJ   r7   Úviewrs   )r5   ÚattrÚ	fielddictÚresÚobjÚdts         r(   r}   zrecord.__getattribute__ò   s)  € ØÐ4Ð4Ð4Ý”7×+Ò+¨D°$Ñ7Ô7Ð7ð	Ý”7×+Ò+¨D°$Ñ7Ô7Ð7øÝð 	ð 	ð 	ØˆDð	øøøå”G×,Ò,¨T°7Ñ;Ô;ÔBˆ	Ø�mŠm˜D $Ñ'Ô'ˆØð 	-Ø�$”-  R a R¤Ð)ˆCðØ”Y��øÝ!ð ð ð à�
�
�
ðøøøð ŒxÐ#Ø—x’x ¤°´Ð ;Ñ<Ô<Ð<ØˆJå ð "%Ø'+ñ",ñ -ô -ð -s#   ¦A Á
AÁAÂ&B. Â.B=Â<B=c                 ó\  — |dv rt          d|z  ¦  «        ‚t          j                             | d¦  «        j        }|                     |d ¦  «        }|r | j        |g|d d…         ¢R Ž S t          | |d ¦  «        r!t          j                             | ||¦  «        S t          d|z  ¦  «        ‚)Nrv   zCannot set '%s' attributerJ   ry   rz   )	r~   r{   r|   r}   rE   r   rw   ÚgetattrÚ__setattr__)r5   r�   Úvalr‚   rƒ   s        r(   rˆ   zrecord.__setattr__  sÆ   € ØÐ4Ð4Ð4Ý Ð!<¸tÑ!CÑDÔDÐDÝ”G×,Ò,¨T°7Ñ;Ô;ÔBˆ	Ø�mŠm˜D $Ñ'Ô'ˆØð 	1Ø �4”= Ð/ s¨2¨A¨2¤wÐ/Ð/Ð/Ð/å�t˜T 4Ñ(Ô(ð 1Ý”w×*Ò*¨4°°sÑ;Ô;Ð;å$ð &)Ø+/ñ&0ñ 1ô 1ð 1r*   c                 óÔ   — t           j                             | |¦  «        }t          |t           j        ¦  «        r-|j        j        �!|                     | j        |j        f¦  «        S |S r1   )r{   r|   Ú__getitem__rH   rJ   r7   r€   rs   )r5   Úindxr„   s      r(   r‹   zrecord.__getitem__  sZ   € ÝŒg×!Ò! $¨Ñ-Ô-ˆõ �c�2œ7Ñ#Ô#ð 	¨¬	¬Ð(CØ—8’8˜Tœ^¨S¬YÐ7Ñ8Ô8Ð8ð ˆJr*   c                 ó¢   ‡ ‡— ‰ j         j        }t          d„ |D ¦   «         ¦  «        }d|z  Šˆˆ fd„|D ¦   «         }d                     |¦  «        S )zPretty-print all fields.c              3   ó4   K  — | ]}t          |¦  «        V — Œd S r1   )rN   )r%   Únames     r(   ú	<genexpr>z record.pprint.<locals>.<genexpr>'  s(   è è € Ð1Ð1 4•S˜‘Y”YÐ1Ð1Ð1Ð1Ð1Ð1r*   z%% %ds: %%sc                 ó:   •— g | ]}‰|t          ‰|¦  «        fz  ‘ŒS r$   )r‡   )r%   r�   Úfmtr5   s     €€r(   r)   z!record.pprint.<locals>.<listcomp>)  s-   ø€ ÐDÐDÐD°d��t�W T¨4Ñ0Ô0Ð1Ñ1ÐDÐDÐDr*   ú
)rJ   r7   ÚmaxÚjoin)r5   r7   ÚmaxlenÚrowsr’   s   `   @r(   Úpprintzrecord.pprint#  sb   øø€ ð ”
Ô ˆÝÐ1Ð1¨5Ð1Ñ1Ô1Ñ1Ô1ˆØ˜fÑ$ˆØDÐDÐDÐDÐD¸eÐDÑDÔDˆØ�yŠy˜‰ŒÐr*   )rg   rh   ri   rj   rq   ro   r}   rˆ   r‹   r˜   Ú__classcell__©rs   s   @r(   r   r   ß   s£   ø€ € € € € ðð ð
 €HØ€Jð"ð "ð "ð "ð "ð
!ð !ð !ð !ð !ð
-ð -ð -ð21ð 1ð 1ðð ð ðð ð ð ð ð ð r*   r   c                   óX   ‡ — e Zd ZdZd Z dZ	 	 	 dd„Zd„ Zd	„ Zd
„ Zˆ fd„Zd„ Z	dd„Z
ˆ xZS )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           	      ó  — |�t          j        |¦  «        }nt          ||||
|	¦  «        j        }|€&t                               | |t
          |f|¬¦  «        }n(t                               | |t
          |f||||¬¦  «        }|S )N)Úorder)ÚbufferÚoffsetÚstridesrž   )rI   rJ   r   ÚndarrayÚ__new__r   )ÚsubtypeÚshaperJ   Úbufr    r¡   r6   r7   r8   r:   r9   rž   Údescrr5   s                 r(   r£   zrecarray.__new__¢  sŠ   € ð ÐÝ”H˜U‘O”OˆEˆEå! '¨5°&¸'À9ÑMÔMÔSˆEàˆ;Ý—?’? 7¨EµF¸E°?È%�?ÑPÔPˆDˆDå—?’? 7¨EµF¸E°?Ø-0¸Ø.5¸Uð #ñ Dô DˆDð ˆr*   c                 ód   — | j         j        t          ur| j         j        �| j         | _         d S d S d S r1   )rJ   rY   r   r7   )r5   r„   s     r(   Ú__array_finalize__zrecarray.__array_finalize__³  s8   € ØŒ:Œ?¥&Ð(Ð(¨T¬ZÔ-=Ð-Ið œˆDŒJˆJˆJð )Ð(Ð-IÐ-Ir*   c                 ó  — 	 t                                | |¦  «        S # t          $ r Y nw xY wt                               | d¦  «        j        }	 ||         d d…         }n,# t
          t          f$ r}t          d|z  ¦  «        |‚d }~ww xY w | j        |Ž }|j        j	        �Mt          |j        j        t          j        ¦  «        r'|                     | j        j        |j        f¬¦  «        S |S |                     t          ¦  «        S )NrJ   ry   zrecarray has no attribute %s©rJ   )Úobjectr}   r~   r¢   rE   Ú	TypeErrorÚKeyErrorrx   rJ   r7   Ú
issubclassrY   r{   r|   r€   )r5   r�   r‚   rƒ   Úer„   s         r(   r}   zrecarray.__getattribute__¹  s  € ð	Ý×*Ò*¨4°Ñ6Ô6Ð6øÝð 	ð 	ð 	ØˆDð	øøøõ ×,Ò,¨T°7Ñ;Ô;ÔBˆ	ð	OØ˜D”/ " 1 "Ô%ˆCˆCøÝ�8Ð$ð 	Oð 	Oð 	OÝ Ð!?À$Ñ!FÑGÔGÈQÐNøøøøð	OøøøàˆdŒm˜SÐ!ˆð Œ9Œ?Ð&Ý˜#œ)œ.­"¬'Ñ2Ô2ð DØ—x’x t¤z¤¸¼	Ð&B�xÑCÔCÐCØˆJà—8’8�GÑ$Ô$Ð$s$   ‚ �
*©*ÁA ÁBÁ0BÂBc                 ó–  — |dk    rAt          |j        t          j        ¦  «        r"|j        �t          j        t          |f¦  «        }|| j        v}	 t           
                    | ||¦  «        }t                               | d¦  «        j        pi }||vr|S |r/	 t                               | |¦  «         nJ# t          $ r |cY S w xY wn7# t          $ r* t                               | d¦  «        j        pi }||vr‚ Y nw xY w	 ||         d d…         }n,# t           t"          f$ r}t%          d|z  ¦  «        |‚d }~ww xY w | j        |g|¢R Ž S )NrJ   ry   z record array has no attribute %s)r¯   rY   r{   r|   r7   rI   rJ   r   Ú__dict__r¬   rˆ   r¢   r}   rE   Ú__delattr__Ú	Exceptionr­   r®   r~   rw   )r5   r�   r‰   ÚnewattrÚretr‚   rƒ   r°   s           r(   rˆ   zrecarray.__setattr__Û  s¥  € ð �7Š?ˆ?�z¨#¬(µB´GÑ<Ô<ˆ?ÀÄÐAVÝ”(�F C˜=Ñ)Ô)ˆCà˜dœmÐ+ˆð	Ý×$Ò$ T¨4°Ñ5Ô5ˆCõ  ×0Ò0°°wÑ?Ô?ÔFÐLÈ"ˆIØ˜9Ð$Ð$Ø�
Øð ðÝ×&Ò& t¨TÑ2Ô2Ð2Ð2øÝ ð ð ð Ø�J�J�Jðøøøðøõ ð 	ð 	ð 	Ý×0Ò0°°wÑ?Ô?ÔFÐLÈ"ˆIØ˜9Ð$Ð$Øð %Ð$ð	øøøð	Ø˜D”/ " 1 "Ô%ˆCˆCøÝ�8Ð$ð 	ð 	ð 	Ý Ø2°TÑ9ñô àðøøøøð	øøøð ˆtŒ}˜SÐ' 3Ð'Ð'Ð'Ð's<   ÁC ÂB5 Â5CÃCÃ1C<Ã;C<Ä D ÄD:Ä"D5Ä5D:c                 ó   •— t          ¦   «                              |¦  «        }t          |t          ¦  «        r–|j        j        �o|                     t          | ¦  «        ¦  «        }t          |j        j        t          j
        ¦  «        r'|                     | j        j        |j        f¬¦  «        S |S |                     t          ¬¦  «        S |S )Nr«   )rY   )rp   r‹   rH   r¢   rJ   r7   r€   rY   r¯   r{   r|   )r5   rŒ   r„   rs   s      €r(   r‹   zrecarray.__getitem__ü  s§   ø€ Ý‰gŒg×!Ò! $Ñ'Ô'ˆõ �c�7Ñ#Ô#ð 
	ØŒyŒÐ*Ø—h’h�t D™zœzÑ*Ô*�Ý˜cœiœn­b¬gÑ6Ô6ð HØŸ8š8¨4¬:¬?¸C¼IÐ*F˜8ÑGÔGÐGØ�
à—x’x¥W�xÑ-Ô-Ð-ð ˆJr*   c                 óà  — | j         }| j         j        t          u s$t          | j         j        t          j        ¦  «        s3|j        t          u r t          j         t          j        |f¦  «        }d}d}nd}d}| j        dk    s| j        dk    rt          j	        | d|d¬	¦  «        }nd
t          | j        ¦  «        ›�}ddt          |¦  «        z  z   }t          ¦   «         dk    rd|z   }||||fz  S )Nz
rec.array(zrec.array(%s,%sdtype=%s)zarray(z)array(%s,%sdtype=%s).view(numpy.recarray)r   rB   z, rR   )Ú	separatorÚprefixÚsuffixz
[], shape=r“   ú rn   )rJ   rY   r   r¯   r{   r|   rI   Úsizer¥   Úarray2stringr^   rN   r
   )r5   Ú
repr_dtyperº   r’   ÚlstÚlfs         r(   rq   zrecarray.__repr__  s  € à”Zˆ
ØŒ:Œ?�fÐ$Ð$­J°t´z´ÍÌÑ,PÔ,PÐ$ð Œ¥&Ð(Ð(ÝœX¥r¤w°
Ð&;Ñ<Ô<�
Ø!ˆFØ,ˆCˆCð
 ˆFØ=ˆCð Œ9�qŠ=ˆ=˜DœJ¨$Ò.Ð.Ý”/Ø ¨V¸CðAñ Aô AˆCˆCð /õ
 %)¨¬Ñ$4Ô$4Ð$4Ð6ˆCà�#•c˜&‘k”k‘/Ñ!ˆÝ!Ñ#Ô# sÒ*Ð*Ø�r‘ˆBØ�c˜2˜zÐ*Ñ*Ð*r*   c                 ó`  — t          |t          ¦  «        r(t                               | d¦  «        j        }||         }t                               | d¦  «        j        }||         d d…         }|€2 | j        |Ž }|j        j        �|S |                     t          ¦  «        S  | j	        |g|¢R Ž S )NrJ   ry   )
rH   Úintr¢   r}   r7   rE   rx   rJ   r€   rw   )r5   r�   r‰   r7   r‚   rƒ   r„   s          r(   Úfieldzrecarray.field.  s­   € Ý�d�CÑ Ô ð 	Ý×,Ò,¨T°7Ñ;Ô;ÔAˆEØ˜”;ˆDå×,Ò,¨T°7Ñ;Ô;ÔBˆ	à˜Œo˜b˜q˜bÔ!ˆàˆ;Ø�$”- Ð%ˆCØŒyŒÐ*Ø�
Ø—8’8�GÑ$Ô$Ð$à �4”= Ð+ sÐ+Ð+Ð+Ð+r*   )
NNr   NNNNNFrœ   r1   )rg   rh   ri   rj   r£   r©   r}   rˆ   r‹   rq   rÄ   r™   rš   s   @r(   r   r   4  sÁ   ø€ € € € € ðfð fðT €HØ€JàHLØ15Ø58ðð ð ð ð"$ð $ð $ð%ð %ð %ðD(ð (ð (ðBð ð ð ð ð"+ð +ð +ðB,ð ,ð ,ð ,ð ,ð ,ð ,ð ,r*   r   c                 óN   — | dk    rt          j        dt          d¬¦  «         d S | 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¥   s    r(   Ú_deprecate_shape_0_as_NonerÌ   @  s=   € Ø�‚z€zÝŒðNõ  að		)ñ 	)ô 	)ð 	)ð
 ˆtàˆr*   z	numpy.recFc                 ó´  — d„ | D ¦   «         } t          |¦  «        }|€| d         j        }nt          |t          ¦  «        r|f}|€|€d„ | D ¦   «         }|�t	          j        |¦  «        }nt          |||||¦  «        j        }|j        }	t          |¦  «        t          | ¦  «        k    rt          d¦  «        ‚|d         j        }
t          |
¦  «        }|dk    r|d| …         }t          ||¦  «        }t          | ¦  «        D ]R\  }}||         j        }|j        d|j        |z
  …         }|	|         }||k    rt          d|› d|› d�¦  «        ‚|||<   ŒS|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                 ó6   — g | ]}t          j        |¦  «        ‘ŒS r$   )rI   Úasarray)r%   Úxs     r(   r)   zfromarrays.<locals>.<listcomp>}  s    € Ð2Ð2Ð2 1•”˜A‘”Ð2Ð2Ð2r*   Nr   c                 ó   — g | ]	}|j         ‘Œ
S r$   r«   )r%   r„   s     r(   r)   zfromarrays.<locals>.<listcomp>Š  s   € Ð2Ð2Ð2 �3”9Ð2Ð2Ð2r*   z>mismatch between the number of fields and the number of arrayszarray-shape mismatch in array z ("z"))rÌ   r¥   rH   rÃ   rI   rJ   r   r7   rN   rG   r   rK   Úndim)Ú	arrayListrJ   r¥   r6   r7   r8   r9   r:   r§   r_   Úd0ÚnnÚ_arrayÚkr„   Ú	testshaper�   s                    r(   r   r   L  s˜  € ðb 3Ð2¨	Ð2Ñ2Ô2€Iõ ' uÑ-Ô-€Eà€}Ø˜!”Ô"ˆˆÝ	�E�3Ñ	Ô	ð Ø�ˆà€˜5˜=ð 3Ð2¨	Ð2Ñ2Ô2ˆàÐÝ”˜‘”ˆˆå˜g u¨f°g¸yÑIÔIÔOˆØŒ[€Fõ ˆ5�z„z•S˜‘^”^Ò#Ð#Ýð +ñ ,ô ,ð 	,ð 
ˆqŒŒ€BÝ	ˆR‰Œ€BØ	ˆA‚v€vØ�d˜�s�d”ˆå�e˜UÑ#Ô#€Fõ ˜IÑ&Ô&ð ð ‰ˆˆ3Ø�1ŒXŒ]ˆØ”I˜n˜sœx¨"™}˜nÔ-ˆ	Ø�aŒyˆØ˜ÒÐÝÐL¸aÐLÐLÀDÐLÐLÐLÑMÔMÐMàˆˆt‰ˆà€Mr*   c           	      óR  ‡— |€Y|€Wt          j        | t          ¬¦  «        Šˆfd„t          ‰j        d         ¦  «        D ¦   «         }t          |||||||¬¦  «        S |�t          j        t          |f¦  «        }	nt          |||||¦  «        j        }		 t          j        | |	¬¦  «        }
|�|
j        |k    r||
_        nÎ# t          t          f$ rº t          |¦  «        }|€t          | ¦  «        }t          |t          ¦  «        r|f}t          |¦  «        dk    rt          d¦  «        ‚t          ||	¦  «        }t          |j        ¦  «        D ]}t#          | |         ¦  «        ||<   Œt%          j        dt(          d	¬
¦  «         |cY S w xY w|
                     t          ¦  «        }|S )a  Create 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                 ól   •— g | ]0}t          j        ‰d |f                              ¦   «         ¦  «        ‘Œ1S ).)rI   r   Útolist)r%   r    r„   s     €r(   r)   zfromrecords.<locals>.<listcomp>Ù  s7   ø€ ÐPÐPÐP°a•2”8˜C  Q œK×.Ò.Ñ0Ô0Ñ1Ô1ÐPÐPÐPr*   éÿÿÿÿ)r6   r¥   r7   r8   r9   r:   r   zCan 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 errorry   rÇ   )rI   r   r¬   r`   r¥   r   rJ   r   r   r­   rG   rÌ   rN   rH   rÃ   r   r½   rZ   rÉ   rÊ   rË   r€   )ÚrecListrJ   r¥   r6   r7   r8   r9   r:   Úarrlistr§   ÚretvalrÖ   r×   rƒ   r„   s                 @r(   r   r   «  sÜ  ø€ ðX €˜5˜=ÝŒh�w¥fÐ-Ñ-Ô-ˆØPÐPÐPÐP½5ÀÄÈ2ÄÑ;OÔ;OÐPÑPÔPˆÝ˜'¨7¸%ÀuØ!'°ÀIðOñ Oô Oð 	Oð ÐÝ”�& %˜Ñ)Ô)ˆˆå˜g u¨f°g¸yÑIÔIÔOˆð!Ý”˜'¨Ð/Ñ/Ô/ˆð* Ð ¤°Ò!6Ð!6Ø ˆFŒLøøõ+ •zÐ"ð ð ð å*¨5Ñ1Ô1ˆØˆ=Ý˜‘L”LˆEÝ�e�SÑ!Ô!ð 	Ø�HˆEÝˆu‰:Œ:˜Š>ˆ>ÝÐ<Ñ=Ô=Ð=Ý˜% Ñ'Ô'ˆÝ�v”{Ñ#Ô#ð 	*ð 	*ˆAÝ˜g aœjÑ)Ô)ˆF�1‰IˆIõ 	ŒðGå að	)ñ 	)ô 	)ð 	)ð ˆˆˆð%øøøð. �+Š+•hÑ
Ô
€Cà€Js   ÂB? Â?CF
Æ	F
c	                 ó  — |€|€t          d¦  «        ‚|�t          j        |¦  «        }	nt          |||||¦  «        j        }	|	j        }
t          |¦  «        }|dv rt          | ¦  «        |z
  |
z  }t          ||	| |¬¦  «        }|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­   rI   rJ   r   ÚitemsizerÌ   rN   r   )Ú
datastringrJ   r¥   r    r6   r7   r8   r9   r:   r§   rá   rÖ   s               r(   r   r      s›   € ðp €}˜˜ÝÐLÑMÔMÐMàÐÝ”˜‘”ˆˆå˜g u¨f°g¸yÑIÔIÔOˆàŒ~€Hõ ' uÑ-Ô-€Eà�
ÐÐÝ�Z‘” 6Ñ)¨hÑ6ˆå�e˜U¨
¸6ÐBÑBÔB€FØ€Mr*   c                 óè   — |                       ¦   «         }	 |                      dd¦  «         |                       ¦   «         |z
  |                      |d¦  «         S # |                      |d¦  «         w xY w)Nr   ry   )ÚtellÚseek)ÚfdÚposs     r(   Úget_remaining_sizerè   K  s]   € Ø
�'Š'‰)Œ)€CðØ
�Š��1‰ŒˆØ�wŠw‰yŒy˜3‰à
�Š��Q‰Œˆˆøˆ�Š��Q‰Œˆˆøøøs   –,A ÁA1c	                 óú  — |€|€t          d¦  «        ‚t          |¦  «        }|€d}nt          |t          ¦  «        r|f}t	          | d¦  «        rt          | ¦  «        }	nt          t          | ¦  «        d¦  «        }	|	5 } |dk    r|                      |d¦  «         t          | ¦  «        }
|�t          j        |¦  «        }nt          |||||¦  «        j        }|j        }t          j        |¦  «                             t           j        ¬¦  «        }||z  }|dk     rlt%          |¦  «        }|
| z  ||                     d	¦  «        <   t)          |¦  «        }t          j        |¦  «                             t           j        ¬¦  «        }||z  }||
k    rt+          d
¦  «        ‚t-          ||¦  «        }|                      |j        ¦  «        }||k    rt3          d¦  «        ‚	 ddd¦  «         n# 1 swxY 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   r   r«   rÜ   z:Not enough bytes left in file for specified shape and typez%Didn't read as many bytes as expected)r­   rÌ   rH   rÃ   Úhasattrr   Úopenr   rå   rè   rI   rJ   r   rá   r   Úprodr{   Úintpr,   ÚindexrZ   rG   r   rê   ÚdataÚOSError)ræ   rJ   r¥   r    r6   r7   r8   r9   r:   Úctxr½   r§   rá   Ú	shapeprodÚ	shapesizeÚnbytesrÖ   Ú
nbytesreads                     r(   r   r   T  sI  € ð\ €}˜˜ÝÐJÑKÔKÐKõ ' uÑ-Ô-€Eà€}ØˆˆÝ	�E�3Ñ	Ô	ð Ø�ˆåˆr�:ÑÔð (õ ˜"‰oŒoˆˆõ •9˜R‘=”= $Ñ'Ô'ˆà	ð C�Ø�AŠ:ˆ:Ø�GŠG�F˜AÑÔÐÝ! "Ñ%Ô%ˆàÐÝ”H˜U‘O”OˆEˆEå! '¨5°&¸'À9ÑMÔMÔSˆEà”>ˆå”H˜U‘O”O×(Ò(­r¬wÐ(Ñ7Ô7ˆ	Ø Ñ(ˆ	Ø�qŠ=ˆ=Ý˜‘K”KˆEØ%)¨i¨ZÑ%7ˆE�%—+’+˜b‘/”/Ñ"Ý˜%‘L”LˆEÝœ ™œ×,Ò,µ2´7Ð,Ñ;Ô;ˆIà˜XÑ%ˆà�DŠ=ˆ=ÝØPñRô Rð Rõ ˜% Ñ'Ô'ˆØ—[’[ ¤Ñ-Ô-ˆ
Ø˜ÒÐÝÐAÑBÔBÐBð  ð;Cð Cð Cñ Cô Cð Cð Cð Cð Cð Cð Cøøøð Cð Cð Cð Cð@ €Ms   Á?E$G0Ç0G4Ç7G4Tc                 ó*  — t          | t          d¦  «        t          f¦  «        st          | d¦  «        r|€|€t	          d¦  «        ‚i }|�t          j        |¦  «        }n#|�t          |||||	¦  «        j        }n|||||	dœ}| €%|€t	          d¦  «        ‚t          ||| ||¬¦  «        S t          | t          ¦  «        rt          | |f||dœ|¤ŽS t          | t          t          f¦  «        rBt          | d         t          t          f¦  «        rt          | f||d	œ|¤ŽS t          | f||d	œ|¤ŽS t          | t          ¦  «        r=|�!| j        |k    r|                      |¦  «        }n| }|
r|                     ¦   «         }|S t          | d¦  «        rt#          | |||¬
¦  «        S t          | t$          ¦  «        rU|�!| j        |k    r|                      |¦  «        }n| }|
r|                     ¦   «         }|                     t          ¦  «        S t'          | dd¦  «        }|�t          |t(          ¦  «        st	          d¦  «        ‚t          j        | ¦  «        } |� | j        |k    r|                      |¦  «        } |                      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)r6   r7   r8   r9   r:   z"Must define a shape if obj is None)r¦   r    r¡   )r¥   r    r   )rJ   r¥   )rJ   r¥   r    Ú__array_interface__zUnknown input type)rH   rY   r[   rì   rG   rI   rJ   r   r   Úbytesr   r,   rZ   r   r   r€   Úcopyr   r¢   r‡   Údictr   )r„   rJ   r¥   r    r¡   r6   r7   r8   r9   r:   rû   ÚkwdsÚnewÚ	interfaces                 r(   r   r   ¹  sÚ  € õj 
�C�$˜t™*œ*¥cÐ*Ñ	+Ô	+ð :­w°s¸JÑ/GÔ/Gð :Øˆ?˜u˜}Ýð 9ñ :ô :ð 	:ð €DØÐÝ”˜‘”ˆˆØ	Ð	Ý˜g u¨fØ% yñ2ô 2Ü27ð 	ˆð #ØØ Ø"Ø&ð	ð ˆð €{Øˆ=ÝÐAÑBÔBÐBÝ˜˜u¨#°fÀgÐNÑNÔNÐNå	�C�Ñ	Ô	ð %"Ý˜#˜uÐI¨E¸&ÐIÐIÀDÐIÐIÐIå	�C�$¥˜Ñ	'Ô	'ð ""Ý�c˜!”f�u¥d˜mÑ,Ô,ð 	EÝ˜sÐE¨%°uÐEÐEÀÐEÐEÐEå˜cÐD¨°eÐDÐD¸tÐDÐDÐDå	�C�Ñ	"Ô	"ð "ØÐ #¤)¨uÒ"4Ð"4Ø—(’(˜5‘/”/ˆCˆCàˆCØð 	Ø—(’(‘*”*ˆCØˆ
å	��jÑ	!Ô	!ð "Ý˜ 5°¸fÐEÑEÔEÐEå	�C�Ñ	!Ô	!ð "ØÐ #¤)¨uÒ"4Ð"4Ø—(’(˜5‘/”/ˆCˆCàˆCØð 	Ø—(’(‘*”*ˆCØ�xŠx�Ñ!Ô!Ð!õ ˜CÐ!6¸Ñ=Ô=ˆ	ØÐ¥J¨y½$Ñ$?Ô$?ÐÝÐ1Ñ2Ô2Ð2ÝŒh�s‰mŒmˆØÐ #¤)¨uÒ"4Ð"4Ø—(’(˜5‘/”/ˆCØ�xŠx�Ñ!Ô!Ð!r*   )NNNNNFN)NNr   NNNFN)
NNr   NNNNFNT)"rj   rÉ   Úcollectionsr   Ú
contextlibr   Ú r   rI   r   r{   Únumpy.compatr   Únumpy.core.overridesr	   Ú
arrayprintr
   Ú__all__r¢   re   Ú
sctypeDictÚnumfmtr-   r   r|   r   r   rÌ   r   r   r   rè   r   r   r$   r*   r(   ú<module>r	     sè  ðð"ð "ðF €€€Ø Ð Ð Ð Ð Ð Ø "Ð "Ð "Ð "Ð "Ð "à Ð Ð Ð Ð Ð Ø  Ð  Ð  Ð  Ð  Ð  Ø "Ð "Ð "Ð "Ð "Ð "Ø +Ð +Ð +Ð +Ð +Ð +Ø .Ð .Ð .Ð .Ð .Ð .ðð ð €ð Œ*€àØØØØØØØØØØØØØðð €ð( 
Œ€ðð ð ð €ˆGÑÔðDð Dð Dð Dð Dñ Dô Dñ ÔðDðNKð Kð Kð Kð KˆRŒWñ Kô Kð KðjI,ð I,ð I,ð I,ð I,ˆwñ I,ô I,ð I,ðX	ð 	ð 	ð €ˆKÑÔØ:>ØAEð[ð [ð [ñ Ôð[ð| €ˆKÑÔØEIØ6:ðQð Qð Qñ ÔðQðh €ˆKÑÔØEIØAEðHð Hð Hñ ÔðHðTð ð ð €ˆKÑÔØ;?Ø?Cðað að añ ÔðaðH €ˆKÑÔØGKØGKðQ"ð Q"ð Q"ñ ÔðQ"ð Q"ð Q"r*   