o
    éôjÓ  ã                   @   s`  U d dl Zd dlZd dlZd dlmZ d dlmZmZm	Z	m
Z
mZmZmZmZmZmZmZ d dlZd dlZd dlmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z) eee*e+e+e+f ee*e+e+e+e+f f Z,ee, Z-eee*e*f  Z.g d¢Z/e-e0d< e	ee*e+f e+f Z1de-de1fd	d
„Z2e2e/ƒZ3	dºdee de4de+fdd„Z5				d»de*dee* dee* dee* dee* dee* dee* dedefdd„Z6de*de+defdd„Z7				d»dee de*dee& dee& deee"  dee* deee&  d eee!  defd!d"„Z8de*de+defd#d$„Z9					d¼de*d%e*dee* dee* dee d&ee d'eee*  d(eee  dee* dee* deee&  defd)d*„Z:d+ededefd,d-„Z;d+ededefd.d/„Z<d0eeeeee"e&f d1e	e*e*f ddfd2d3„Z=d4ed1e	e*e*f ddfd5d6„Z>d7eej? dee+ fd8d9„Z@dºd:eAd;e4de+fd<d=„ZB	>	?		?d½d:eAd@eAdAe4dBe4dCe4de+fdDdE„ZC	>			?d¾d:eAd@eAdAe4dBe4dCe4de+fdFdG„ZDdHeejEef dIe4dejEfdJdK„ZF	dºde*dLe+dMee+ dNedOe4de"fdPdQ„ZGdRe"dSe"dMee+ de!fdTdU„ZHde*dVe jIdRee de fdWdX„ZJde*dYe+dZee dRe def
d[d\„ZKde*dVejId]ee defd^d_„ZLd]ee*eMf deMfd`da„ZN		d¿dbe*d]edee* dcee+ def
ddde„ZO	dÀde*dcejPdee* defdfdg„ZQdhedefdidj„ZRdkedle*defdmdn„ZSde*de&fdodp„ZT	dÀdVe+dqeeee*e+df   dreee*  de%fdsdt„ZU	u	dÁde*dVe+dqeeee*e+df   de*dreee*  de&fdvdw„ZV	dÀdVe+dqeeee*e+df   dreee*  de%fdxdy„ZW	u	dÁde*dVe+dqeeee*e+df   de*dreee*  de&fdzd{„ZXd|e%de%fd}d~„ZYd|e%de%fdd€„ZZdYe+d�e%de%fd‚dƒ„Z[	udÂde*d„e%de*de&fd…d†„Z\d‡ee*eMf de*fdˆd‰„Z]	u	dÁde*dVe+dqeeee*e+df   de*dŠeee*  de&fd‹dŒ„Z^	dºdhed�e4dee*ee*ee f f fdŽd�„Z_d�e#j`de*fd‘d’„Zad“e%de*fd”d•„Zbd–e&de*fd—d˜„Zcd“e"de*fd™dš„Zd	dÃdked›e*d�e4dee*ee*ee f f fdœd�„ZedÂd+ed›e*de*fdždŸ„Zfd0ejgjhjiddfd d¡„Zjd¢ed£e.d¤ee d¥ee. de$f
d¦d§„Zkd¨e+dejlfd©dª„Zmd¨e+de+fd«d¬„Znd¨e+de*fd­d®„Zod¨e+de*fd¯d°„Zpd±ejlde+fd²d³„Zqde
e+ fd´dµ„Zrd¶d·„ ejP s¡ D ƒZtdce+de*fd¸d¹„ZudS )Äé    N)Úisnan)ÚAnyÚCallableÚDictÚKeysViewÚListÚOptionalÚSequenceÚTupleÚTypeVarÚUnionÚcast)Ú
IR_VERSIONÚAttributeProtoÚFunctionProtoÚ
GraphProtoÚMapProtoÚ
ModelProtoÚ	NodeProtoÚOperatorSetIdProtoÚOptionalProtoÚSequenceProtoÚSparseTensorProtoÚTensorProtoÚTensorShapeProtoÚTrainingInfoProtoÚ	TypeProtoÚValueInfoProtoÚdefsÚmappingÚsubbyte))z1.0é   é   r"   )z1.1r!   é   r"   )z1.1.2r!   é   r"   )z1.2r!   é   r"   )z1.3r!   é   r"   )z1.4.1é   é	   r"   )z1.5.0r#   é
   r"   )z1.6.0r$   é   é   )z1.7.0r%   é   r+   r"   )z1.8.0r%   é   r+   r"   )z1.8.1r%   r-   r+   r"   )z1.9.0r%   é   r+   r"   )z1.10.0r&   é   r+   r"   )z1.10.1r&   r/   r+   r"   )z1.10.2r&   r/   r+   r"   )z1.11.0r&   é   r!   r"   )z1.12.0r&   é   r!   r"   )z1.13.0r&   é   r!   r"   )z1.13.1r&   r2   r!   r"   )z1.14.0r(   é   r!   r"   )z1.14.1r(   r3   r!   r"   )z1.15.0r(   é   r'   r"   )z1.16.0r)   é   r#   r"   ÚVERSION_TABLEÚtableÚreturnc                    s8   i ‰ dt dtdtddf‡ fdd„}| D ]}||Ž  qˆ S )zOCreate a map from (opset-domain, opset-version) to ir-version from above table.Úrelease_versionÚ
ir_versionÚargsr8   Nc                    sF   ~ t g d¢|ƒD ]}|ˆ vr |ˆ |< |d dkr |ˆ d|d f< qd S )N)úai.onnxz
ai.onnx.mlúai.onnx.trainingr   r=   zai.onnx.preview.trainingr"   )Úzip)r9   r:   r;   Úpair©Úresult© ú^/var/www/html/academy/tools/voices/clone/cosy-venv/lib/python3.10/site-packages/onnx/helper.pyÚprocessX   s   €üz-create_op_set_id_version_map.<locals>.process)ÚstrÚintr   )r7   rD   ÚrowrB   r@   rC   Úcreate_op_set_id_version_mapT   s
   
rH   FÚopsetidlistÚignore_unknownc                    sF   d‰ dt tdf dtdtf‡ ‡fdd„‰| r!t‡fdd	„| D ƒƒS ˆ S )
a=  Given list of opset ids, determine minimum IR version required.

    Args:
        opsetidlist: A sequence of OperatorSetIdProto.
        ignore_unknown: If True, ignore unknown domain and return default minimum
            version for that domain.

    Returns:
        The minimum IR version required (integer)
    r!   ÚdomainNÚversionr8   c                    s,   | pd|f}|t v rt | S ˆrˆ S tdƒ‚)Nr<   zUnsupported opset-version.)ÚOP_SET_ID_VERSION_MAPÚ
ValueError)rK   rL   Úkey)Údefault_min_versionrJ   rB   rC   Úfind_minw   s   z)find_min_ir_version_for.<locals>.find_minc                 3   s   � | ]
}ˆ |j |jƒV  qd S ©N)rK   rL   ©Ú.0Úx)rQ   rB   rC   Ú	<genexpr>€   s   € z*find_min_ir_version_for.<locals>.<genexpr>)r   rE   rF   Úmax)rI   rJ   rB   )rP   rQ   rJ   rC   Úfind_min_ir_version_forh   s
   $rX   Úop_typeÚinputsÚoutputsÚnameÚ
doc_stringrK   ÚoverloadÚkwargsc           	      K   sz   t ƒ }| |_|j |¡ |j |¡ |r||_|r||_|dur#||_|dur*||_|r;|j	 dd„ t
| ¡ ƒD ƒ¡ |S )a  Construct a NodeProto.

    Args:
        op_type (string): The name of the operator to construct
        inputs (list of string): list of input names
        outputs (list of string): list of output names
        name (string, default None): optional unique identifier for NodeProto
        doc_string (string, default None): optional documentation string for NodeProto
        domain (string, default None): optional domain for NodeProto.
            If it's None, we will just use default domain (which is empty)
        overload (string, default None): optional field, used to
            resolve calls to model-local functions
        **kwargs (dict): the attributes of the node.  The acceptable values
            are documented in :func:`make_attribute`.

    Returns:
        NodeProto
    Nc                 s   s&   � | ]\}}|d urt ||ƒV  qd S rR   )Úmake_attribute)rT   rO   ÚvaluerB   rB   rC   rV   ­   s   € þýzmake_node.<locals>.<genexpr>)r   rY   ÚinputÚextendÚoutputr\   r]   rK   r^   Ú	attributeÚsortedÚitems)	rY   rZ   r[   r\   r]   rK   r^   r_   ÚnoderB   rB   rC   Ú	make_node„   s"   
þri   rL   c                 C   ó   t ƒ }| |_||_|S ©zÉConstruct an OperatorSetIdProto.

    Args:
        domain (string): The domain of the operator set id
        version (integer): Version of operator set id
    Returns:
        OperatorSetIdProto
    ©r   rK   rL   )rK   rL   ZoperatorsetidrB   rB   rC   Úmake_operatorsetidµ   s   rm   ÚnodesÚinitializerÚ
value_infoÚsparse_initializerc           	      C   s†   |du rg }|du rg }|du rg }t ƒ }|j | ¡ ||_|j |¡ |j |¡ |j |¡ |j |¡ |j |¡ |rA||_	|S )a“  Construct a GraphProto

    Args:
        nodes: list of NodeProto
        name (string): graph name
        inputs: list of ValueInfoProto
        outputs: list of ValueInfoProto
        initializer: list of TensorProto
        doc_string (string): graph documentation
        value_info: list of ValueInfoProto
        sparse_initializer: list of SparseTensorProto
    Returns:
        GraphProto
    N)
r   rh   rc   r\   rb   rd   ro   rq   rp   r]   )	rn   r\   rZ   r[   ro   r]   rp   rq   ÚgraphrB   rB   rC   Ú
make_graphÇ   s"   rs   c                 C   rj   rk   rl   )rK   rL   ZopsetidrB   rB   rC   Úmake_opsetidò   s   	rt   ÚfnameÚopset_importsÚ
attributesÚattribute_protosc                 C   s¦   |d u rg }|d u rg }|
d u rg }
t ƒ }| |_||_|j |¡ |j |¡ |j |¡ |j |¡ |j |¡ |j	 |¡ |rD||_
|	d urK|	|_|j |
¡ |S rR   )r   rK   r\   rb   rc   rd   rh   Úopset_importre   Zattribute_protor]   r^   rp   )rK   ru   rZ   r[   rn   rv   rw   rx   r]   r^   rp   ÚfrB   rB   rC   Úmake_function  s*   r{   rr   c                 K   s˜   t ƒ }t|_|j | ¡ d}| dd¡}|dur|j |¡ n
|j ¡ }t	 
¡ |_d}| dd¡}|dur;|j |¡ | ¡ D ]
\}}t|||ƒ q?|S )z·Construct a ModelProto

    Args:
        graph (GraphProto): *make_graph* returns
        **kwargs: any attribute to add to the returned instance
    Returns:
        ModelProto
    Nrv   Ú	functions)r   r   r:   rr   ÚCopyFromÚpopry   rc   Úaddr   Úonnx_opset_versionrL   r|   rg   Úsetattr)rr   r_   Úmodelrv   Úimpr|   ÚkÚvrB   rB   rC   Ú
make_model%  s    	

r†   c                 K   s8   d}||vrd}|  |g ¡}t|ƒ||< t| fi |¤ŽS )Nr:   rv   )ÚgetrX   r†   )rr   r_   Zir_version_fieldZopset_imports_fieldÚimportsrB   rB   rC   Úmake_model_gen_versionJ  s   r‰   ÚprotoÚ
dict_valuec                 C   s8   | j d d …= | ¡ D ]\}}| j  ¡ }||_||_q
d S rR   )Úmetadata_propsrg   r   rO   ra   )rŠ   r‹   r„   r…   ÚentryrB   rB   rC   Úset_metadata_propsS  s   
ýrŽ   r‚   c                 C   s   t | |ƒ d S rR   )rŽ   )r‚   r‹   rB   rB   rC   Úset_model_props`  s   r�   Úcac                    s   ‡ fdd„t tˆ ƒd ƒD ƒS )Nc                    s4   g | ]}|d  dkrˆ |d   j nˆ |d   j‘qS )r+   r   )ÚrealÚimag©rT   Úi©r�   rB   rC   Ú
<listcomp>e  s    &ÿÿz*split_complex_to_pairs.<locals>.<listcomp>r+   )ÚrangeÚlenr•   rB   r•   rC   Úsplit_complex_to_pairsd  s   
þr™   ÚfvalÚtruncatec                 C   sH   t  t d| ¡d¡}|r|d? S t| ƒrdS |d? d@ d }|| d? S )Nú<fÚlittler0   iÀ  r"   iÿ  )rF   Ú
from_bytesÚstructÚpackr   )rš   r›   ÚivalÚroundedrB   rB   rC   Úfloat32_to_bfloat16q  s   r£   ç      ð?TÚscaleÚfnÚuzÚsaturatec                 C   sæ  |st dƒ‚| | }t t dt |¡¡d¡}|d@ d? }|rõ|d@ dkr'dS t |¡r4|r2|dB S dS |d	@ d
? }|d@ }	|dk rHd}t|ƒS |dk r |d }
|
dkre|dd|
 > O }||	d|
 ? O }n|	dkrn|dO }nd}dd|
 > }|	|@ rœ|d@ s˜|	|d @ dks˜|	|@ rœ|	|d> @ rœ|	|d @ dkrœ|d7 }t|ƒS |dk rå|d }
|
dkr·|dO }||	d? O }n||
d> O }||	d? O }|	d@ rá|	d@ sÏ|	d@ rá|d@ dk rÝ|d7 }t|ƒS |sádS t|ƒS |rï|dO }t|ƒS d}t|ƒS |d@ dkrÿd|B S t |¡�r|�r|dB S d|B S |d	@ d
? }|d@ }	|dk�rï|dk �r)	 t|ƒS |dk �r‡|d }
|
dk�rH|dd|
 > O }||	d|
 ? O }n	|	dk�rQ|dO }dd|
 > }|	|@ �rƒ|d@ �s|	|d @ dk�s|	|@ �rƒ|	|d> @ �rƒ|	|d @ dk�rƒ|d7 }t|ƒS |dk �rà|d }
|
dk�r |dO }||	d? O }n||
d> O }||	d? O }|d@ dk�r·|dM }|	d@ �rÜ|	d@ �sÆ|	d@ �rÜ|d@ dk �rÕ|d7 }t|ƒS |�sÜ|dO }t|ƒS |�rë|dO }t|ƒS |dO }t|ƒS ) a  Convert a float32 value to a float8, e4m3 (as int).

    See :ref:`onnx-detail-float8` for technical details.

    Args:
        fval: float to convert
        scale: scale, divide *fval* by *scale* before casting it
        fn: no infinite values
        uz: no negative zero
        saturate: if True, any value out of range included inf becomes
            the maximum value, otherwise, it becomes NaN. The
            description of operator Cast fully describes the
            differences.

    Returns:
        converted float
    z4float32_to_float8e4m3 not implemented with fn=False.rœ   r�   ì        é   é  Àé€   é   é  €é   éÿÿ ét   r   éx   éw   éþÿÿÿr"   r+   r5   r4   é‡   r'   r!   i   é   iÿÿ é~   éu   éy   éˆ   éþ   )ÚNotImplementedErrorrF   rž   rŸ   r    ÚnpÚfloat32Úisinf©rš   r¥   r¦   r§   r¨   rU   ÚbÚretÚeÚmÚexÚmaskrB   rB   rC   Úfloat32_to_float8e4m3~  sÜ   ÿ
&Û
ÿÿ
ÿíúüÿ

&
Û


ÿÿ
ÿ
ë
úüÿrÇ   c                 C   sÎ  | | }t  t dt |¡¡d¡}|d@ d? }|rñ|rñ|d@ dkr#dS |d@ dkr1|r/|d	B S dS |d@ d
? }|d@ }	|dk rEd}t |ƒS |dk r�|d }
|
dkrb|dd|
 > O }||	d|
 ? O }n|	dkrk|dO }nd}dd|
 > }|	|@ r™|d@ s•|	|d @ dks•|	|@ r™|	|d> @ r™|	|d @ dkr™|d7 }t |ƒS |dk rÓ|d }
||
d> O }||	d? O }|	d@ rÏ|	d@ s½|	d@ rÏ|d	@ d	k rË|d7 }t |ƒS |sÏd}t |ƒS |dkrá|	dkrád}t |ƒS |rë|d	O }t |ƒS d}t |ƒS |�sã|�sã|d@ dk�rd	|B S t |¡�r|�rd|B S d|B S |d@ d
? }|d@ }	|dk�rß|dk �r,	 t |ƒS |dk �rŠ|d }
|
dk�rK|dd|
 > O }||	d|
 ? O }n	|	dk�rT|dO }dd|
 > }|	|@ �r†|d@ �s‚|	|d @ dk�s‚|	|@ �r†|	|d> @ �r†|	|d @ dk�r†|d7 }t |ƒS |dk �rÐ|d }
||
d> O }||	d? O }|	d@ �rÌ|	d@ �s®|	d@ �rÌ|d	@ dk �r½|d7 }t |ƒS |�rÈ|dO }t |ƒS |dO }t |ƒS |�rÛ|dO }t |ƒS |dO }t |ƒS tdƒ‚)aà  Convert a float32 value to a float8, e5m2 (as int).

    Args:
        fval: float to convert
        scale: scale, divide *fval* by *scale* before casting it
        fn: no infinite values
        uz: no negative zero
        saturate: if True, any value out of range included inf becomes
            the maximum value, otherwise, it becomes NaN. The
            description of operator Cast fully describes the
            differences.

    Returns:
        converted float
    rœ   r�   r©   rª   r«   r¬   iÿÿÿr®   r­   r¯   r°   ém   r   ép   éo   éÿÿÿÿr"   é   r5   é�   r+   r¶   iÿÿ i    éÿ   é{   é|   én   éq   z%fn and uz must be both False or True.)rF   rž   rŸ   r    r½   r¾   r¿   r¼   rÀ   rB   rB   rC   Úfloat32_to_float8e5m2  sÒ   $Ý
ÿÿ
ÿï	øúüÿ

"
ß


ÿÿ
ÿ
ï	øûüÿrÓ   ÚarrayÚsignedc                    s”   t | tjƒstj| tjd�} |  ¡ }t | j¡d dk}|r(t |t 	dg¡¡}‡ fdd„}t 
|dd¡}||ddd… |ddd… ƒ}| tj¡S )ax  Convert an array of float32 value to a 4bit data-type and pack every two concecutive elements in a byte.
    See :ref:`onnx-detail-int4` for technical details.

    Args:
        array: array of float to convert and pack
        signed: Whether the 4 bit variant is signed or unsigned

    Returns:
        Packed array with size `ceil(farray.size/2)` (single dimension).
    ©Údtyper+   r"   r   c                    s   t  | |ˆ ¡S rR   )r    Zfloat32x2_to_4bitx2)rU   Úy©rÕ   rB   rC   Ú<lambda>—  s    z&pack_float32_to_4bit.<locals>.<lambda>N)Ú
isinstancer½   ÚndarrayÚasarrayr¾   ÚravelÚprodÚshapeÚappendrÔ   Ú
frompyfuncÚastypeÚuint8)rÔ   rÕ   Ú
array_flatZis_odd_volumeZsingle_funcÚfuncÚarrrB   rÙ   rC   Úpack_float32_to_4bit‚  s   rè   Ú	data_typeÚdimsÚvalsÚrawc                 C   sX  t ƒ }||_| |_|t jkr|rtdƒ‚t|ƒ}d}|rA|t jkr$d}n|t jt jt j	t j
fv r3d}n|t jt jfv r>d}n|j}t|ƒtju rSt|jƒdkrS| ¡ }|D ]}||9 }qUt|ƒ|kr|t jt jfv rrt|ƒ|d kstd|› dt|ƒ› d�ƒ‚|r…||_nŸ|t jt jfv r’t|ƒ}n†|t jkr©t |¡ |¡jtjd� ¡  ¡ }no|t jt jt jt j	t j
fv ràt jtt jt t jd	d
„ t j	t!t j
dd
„ i| }	t"t#|	t |¡ |¡ ¡  ¡ ƒƒ}n8|t jt jfv rû|t jk}
t$||
d� |¡ ¡  ¡ }n|t j%k�r
t |¡ t&¡}n|t jk�rt |¡ t'¡}t(|ƒ}t)||ƒ *|¡ |j+ *|¡ |S )a”  Make a TensorProto with specified arguments.  If raw is False, this
    function will choose the corresponding proto field to store the
    values based on data_type. If raw is True, use "raw_data" proto
    field to store the values, and values should be of type bytes in
    this case.

    Args:
        name (string): tensor name
        data_type (int): a value such as onnx.TensorProto.FLOAT
        dims (List[int]): shape
        vals: values
        raw (bool): if True, vals contains the serialized content of the tensor,
            otherwise, vals should be a list of values of the type defined by *data_type*

    Returns:
        TensorProto
    z*Can not use raw_data to store string type.r"   r+   g      à?z8Number of values does not match tensor's size. Expected z, but it is z. rÖ   c                  W   s   t | ddiŽS )Nr§   T)rÇ   ©r;   rB   rB   rC   rÚ   ð  s
    ÿÿzmake_tensor.<locals>.<lambda>c                  W   s   t | dddœŽS )NT)r¦   r§   )rÓ   rí   rB   rB   rC   rÚ   ô  s    ÿrÙ   ),r   ré   r\   ÚSTRINGÚ	TypeErrorÚtensor_dtype_to_np_dtypeÚBFLOAT16ÚFLOAT8E4M3FNÚFLOAT8E4M3FNUZÚ
FLOAT8E5M2ÚFLOAT8E5M2FNUZZUINT4ZINT4ÚitemsizeÚtyper½   rÜ   r˜   rà   ÚflattenrN   Úraw_dataÚ	COMPLEX64Ú
COMPLEX128r™   ÚFLOAT16rÔ   rã   ÚviewÚuint16Útolistr£   rÇ   rÓ   ÚlistÚmaprè   ÚBOOLrF   ÚbytesÚtensor_dtype_to_fieldÚgetattrrc   rê   )r\   ré   rê   rë   rì   ÚtensorÚnp_dtypeÚexpected_sizeÚdZfcastrÕ   ÚfieldrB   rB   rC   Úmake_tensorž  s˜   
ü
ÿ

 ÿû

ùõþÿþ

ür  ÚvaluesÚindicesc                 C   s.   t ƒ }|j | ¡ |j |¡ |j |¡ |S )zÁConstruct a SparseTensorProto

    Args:
        values (TensorProto): the values
        indices (TensorProto): the indices
        dims: the shape

    Returns:
        SparseTensorProto
    )r   r  r}   r  rê   rc   )r  r  rê   ÚsparserB   rB   rC   Úmake_sparse_tensor  s
   r  Ú	elem_typec                 C   s�   t ƒ }| |_||_|t jkr|S |t jkr|j}n(|t jkr"|j}n|t jkr+|j	}n|t j
kr4|j}n|tjkr=|j}ntdƒ‚| |¡ |S )z/Make a Sequence with specified value arguments.z8The element type in the input sequence is not supported.)r   r\   r  Ú	UNDEFINEDÚTENSORZtensor_valuesÚSPARSE_TENSORZsparse_tensor_valuesÚSEQUENCEZsequence_valuesÚMAPZ
map_valuesr   ÚOPTIONALZoptional_valuesrï   rc   )r\   r  r  Úsequencere   rB   rB   rC   Úmake_sequence)  ó$   






r  Úkey_typeÚkeysc                 C   sr   t ƒ }tjtjtjtjtjtjtjtj	g}| |_
||_|tjkr'|j |¡ n
||v r1|j |¡ |j |¡ |S )zøMake a Map with specified key-value pair arguments.

    Criteria for conversion:
    - Keys and Values must have the same number of elements
    - Every key in keys must be of the same type
    - Every value in values must be of the same type
    )r   r   ÚINT8ÚINT16ÚINT32ÚINT64ÚUINT8ÚUINT16ÚUINT32ÚUINT64r\   r  rî   Zstring_keysrc   r  r  r}   )r\   r  r  r  Z	map_protoZvalid_key_int_typesrB   rB   rC   Úmake_mapF  s$   
ø

r$  ra   c                 C   s�   t ƒ }| |_||_|t jkr|S |t jkr|j}n(|t jkr"|j}n|t jkr+|j	}n|t j
kr4|j}n|t jkr=|j}ntdƒ‚| |¡ |S )z0Make an Optional with specified value arguments.z8The element type in the input optional is not supported.)r   r\   r  r  r  Ztensor_valuer  Zsparse_tensor_valuer  Zsequence_valuer  Ú	map_valuer  Zoptional_valuerï   r}   )r\   r  ra   Úoptionalre   rB   rB   rC   Úmake_optionale  r  r'  c                 C   s   t | tƒr| S |  d¡S )z2Coerce a string (or bytes) value into UTF-8 bytes.úutf-8)rÛ   r  Úencode)ra   rB   rB   rC   Ú	_to_bytes‚  s   r*  rO   Ú	attr_typec              
      s$  t ƒ }| |_|r||_t|tjƒrt|ƒ|_t j|_	�nRt|tj
ƒr-t|ƒ|_t j|_	�nAt|ttfƒr?t|ƒ|_t j|_	�n/t|tƒrP|j |¡ t j|_	�nt|tƒra|j |¡ t j|_	�nt|tƒrq|j |¡ t j|_	nýt|tƒr�|j |¡ t j|_	nít|t j!j"ƒ�rft#|ƒ}t$|ƒdkrŸ|du rŸt%d| › d�ƒ‚|du rèdd„ |D ƒ}tjt j&ftj
t j'fttft j(ftt j)ftt j*ftt j+ftt j,ffD ]\‰ }t-‡ fdd„|D ƒƒrß|} nqÌ|du rèt%d	ƒ‚|t j&krø|j. /|¡ t j&|_	nv|t j'k�r	|j0 /|¡ t j'|_	ne|t j(k�r|j1 /d
d„ |D ƒ¡ t j(|_	nO|t j)k�r0|j2 /|¡ t j)|_	n>|t j*k�rA|j3 /|¡ t j*|_	n-|t j+k�rR|j4 /|¡ t j+|_	n|t j,k�rc|j5 /|¡ t j,|_	nt6ƒ ‚t7d|› d�ƒ‚|du�r�|j	|k�r�t7dt8|j	ƒ› d|j	› dt8|ƒ› d|› d�	ƒ‚|S )z0Makes an AttributeProto based on the value type.r   NzCould not infer attribute `z` type from empty iteratorc                 S   s   h | ]}t |ƒ’qS rB   )r÷   ©rT   r…   rB   rB   rC   Ú	<setcomp>²  s    z!make_attribute.<locals>.<setcomp>c                 3   s   � | ]}t |ˆ ƒV  qd S rR   )Ú
issubclass©rT   Út©Úexp_trB   rC   rV   ¼  s   € z!make_attribute.<locals>.<genexpr>zRCould not infer the attribute type from the elements of the passed Iterable value.c                 s   s   � | ]}t |ƒV  qd S rR   )r*  r,  rB   rB   rC   rV   Ë  s   € ú'z%' is not an accepted attribute value.zInferred attribute type 'z'(z") mismatched with specified type 'ú))9r   r\   r]   rÛ   ÚnumbersÚIntegralrF   r”   ÚINTr÷   ÚRealÚfloatrz   ÚFLOATrE   r  r*  Úsrî   r   r0  r}   r  r   Úsparse_tensorr  r   ÚgÚGRAPHr   ÚtpÚ
TYPE_PROTOÚcollectionsÚabcÚIterabler   r˜   rN   ÚINTSÚFLOATSÚSTRINGSÚTENSORSÚSPARSE_TENSORSÚGRAPHSÚTYPE_PROTOSÚallÚintsrc   ÚfloatsÚstringsÚtensorsÚsparse_tensorsÚgraphsÚtype_protosÚAssertionErrorrï   Ú_attr_type_to_str)rO   ra   r]   r+  ÚattrÚtypesZexp_enumrB   r1  rC   r`   ‡  sš   









ÿ

ù	þÿ







(ÿr`   c                 C   s    t ƒ }| |_||_|r||_|S )zeMake an AttributeProto holding a reference to the parent function's attribute of given name and type.)r   r\   r÷   r]   )r\   r+  r]   rU  rB   rB   rC   Úmake_attribute_refå  s   rW  rU  c                 C   sJ  | j r
td| › �ƒ‚| jtjkr| jS | jtjkr| jS | jtjkr%| j	S | jtj
kr.| jS | jtjkr7| jS | jtjkr@| jS | jtjkrI| jS | jtjkrTt| jƒS | jtjkr_t| jƒS | jtjkrjt| jƒS | jtjkrut| jƒS | jtjkr€t| jƒS | jtjkr‹t| jƒS | jtjkr–t| j ƒS | jtj!kržd S td| › �ƒ‚)Nz)Cannot get value of reference attribute: zUnsupported ONNX attribute: )"Zref_attr_namerN   r÷   r   r:  rz   r7  r”   rî   r;  r  r0  r  r<  r>  r=  r@  r?  rE  r   rM  rD  rL  rF  rN  rG  rO  rH  rP  rI  rQ  rJ  rR  r  )rU  rB   rB   rC   Úget_attribute_valueñ  sB   






rX  rh   Ú	attr_namec                    sT   ‡ fdd„| j D ƒ}t|ƒdkrtdˆ › �ƒ‚t|ƒdk r$tdˆ › �ƒ‚t|d ƒS )Nc                    s   g | ]	}|j ˆ kr|‘qS rB   ©r\   rS   ©rY  rB   rC   r–     s    z'get_node_attr_value.<locals>.<listcomp>r"   z'Node has multiple attributes with name z Node has no attribute with name r   )re   r˜   rN   rX  )rh   rY  ÚmatchingrB   r[  rC   Úget_node_attr_value  s   r]  c                 C   s   t ƒ }| |_|S rR   )r   r\   )r\   Úvalue_info_protorB   rB   rC   Úmake_empty_tensor_value_info  s   r_  rà   Úshape_denotationc           	      C   ó´   t ƒ }|j}| |_|j}|durX|j g ¡ |r$t|ƒt|ƒkr$tdƒ‚t|ƒD ]/\}}|j 	¡ }|du r6nt
|tƒr?||_nt
|tƒrH||_ntd|› d�ƒ‚|rW|| |_q(|S )z:Makes a Tensor TypeProto based on the data type and shape.Nú>Invalid shape_denotation. Must be of the same length as shape.úInvalid item in shape: z. Needs to be of int or str.)r   Útensor_typer  rà   Údimrc   r˜   rN   Ú	enumerater   rÛ   rF   Ú	dim_valuerE   Ú	dim_paramÚ
denotation)	r  rà   r`  Ú
type_protoÚtensor_type_protoZtensor_shape_protor”   r	  re  rB   rB   rC   Úmake_tensor_type_proto$  ó2   ÿ



ÿ
€rl  Ú c                 C   s2   t ƒ }| |_|r||_t|||ƒ}|j |¡ |S )z8Makes a ValueInfoProto based on the data type and shape.)r   r\   r]   rl  r÷   r}   )r\   r  rà   r]   r`  r^  rk  rB   rB   rC   Úmake_tensor_value_infoQ  s   ro  c           	      C   ra  )z@Makes a SparseTensor TypeProto based on the data type and shape.Nrb  rc  z. Needs to be of int or text.)r   Úsparse_tensor_typer  rà   re  rc   r˜   rN   rf  r   rÛ   rF   rg  rE   rh  ri  )	r  rà   r`  rj  Úsparse_tensor_type_protoZsparse_tensor_shape_protor”   r	  re  rB   rB   rC   Úmake_sparse_tensor_type_protoc  rm  rr  c                 C   s6   t ƒ }| |_|r||_t|||ƒ}|jj |j¡ |S )zEMakes a SparseTensor ValueInfoProto based on the data type and shape.)r   r\   r]   rr  r÷   rp  r}   )r\   r  rà   r]   r`  r^  rq  rB   rB   rC   Úmake_sparse_tensor_value_info�  s   ÿÿrs  Úinner_type_protoc                 C   ó   t ƒ }|jj | ¡ |S )zMakes a sequence TypeProto.)r   Úsequence_typer  r}   ©rt  rj  rB   rB   rC   Úmake_sequence_type_proto¦  ó   rx  c                 C   ru  )zMakes an optional TypeProto.)r   Úoptional_typer  r}   rw  rB   rB   rC   Úmake_optional_type_proto¯  ry  r{  Ú
value_typec                 C   s    t ƒ }| |j_|jj |¡ |S )zMakes a map TypeProto.)r   Úmap_typer  r|  r}   )r  r|  rj  rB   rB   rC   Úmake_map_type_proto¸  s   r~  rj  c                 C   s&   t ƒ }| |_|r||_|j |¡ |S )z1Makes a ValueInfoProto with the given type_proto.)r   r\   r]   r÷   r}   )r\   rj  r]   r^  rB   rB   rC   Úmake_value_infoÃ  s   r  r;  c                 C   sb   t | tƒr| }nt | tƒr| jddd�}nt| ƒ}t|ƒdk r!|S |d d… dt|ƒd › d� S )Nr(  Úignore)Úerrorsé@   z	...<+len=ú>)rÛ   rE   r  Údecoder˜   )r;  Z	sanitizedrB   rB   rC   Ú_sanitize_strÒ  s   

 r…  Úelem_shape_denotationc                 C   s>   t ƒ }| |_|r||_t|||ƒ}t|ƒ}|jj |j¡ |S )zJMakes a Sequence[Tensors] ValueInfoProto based on the data type and shape.)r   r\   r]   rl  rx  r÷   rv  r}   )r\   r  rà   r]   r†  r^  rk  Zsequence_type_protorB   rB   rC   Úmake_tensor_sequence_value_infoÞ  s   r‡  Ú	subgraphsc                 C   sÎ  g }|  | j¡ |  d¡ dtdtfdd„}dtdtfdd„}td	ƒ}d
t|gtf dt| dtfdd„}g }|  d¡rF|  || j	ƒ¡ �n|  d¡rU|  || j
ƒ¡ �n|  d¡re|  tt| jƒƒ¡ nó|  d¡rŒt| jjƒdkrx|  d¡ nàt| jjƒ}|  dt| j|ƒ› d�¡ nÌ|  d¡r£|  d| jj› d�¡ |  | j¡ nµ|  d¡r³|  d| j› d�¡ n¥| jrÀ|  ||| jƒ¡ n˜| jrÍ|  ||| jƒ¡ n‹| jrÞ|  tttt| jƒƒƒ¡ nz| jrç|  d¡ nq| j�r|  d¡ t| jƒD ]\}	}
|	t| jƒd k�rdnd}|  d|
› d|› �¡ qõ|  d¡ n?| j�rS|  d¡ t| jƒD ]\}	}|	t| jƒd k�r7dnd}|  d|j› d|› �¡ �q'|  d¡ | | j¡ n|  d¡ |�rbd  |¡|fS d  |¡S ) Nú=rz   r8   c                 S   s   | d›S )Nz.15grB   )rz   rB   rB   rC   Ú	str_floatù  s   z&printable_attribute.<locals>.str_floatr”   c                 S   s   t | ƒS rR   )rE   )r”   rB   rB   rC   Ústr_intÿ  s   z$printable_attribute.<locals>.str_intÚ_TÚstr_elemÚxsc                 S   s   dd  t| |ƒ¡ d S )NÚ[ú, Ú])Újoinr  )r�  rŽ  rB   rB   rC   Ústr_list  s   z%printable_attribute.<locals>.str_listr;  r0  r   z<Tensor>z<Scalar Tensor rƒ  r=  z<graph r?  z<Type Proto z[<Tensor>, ...]r�  r"   ú,rn  r‘  z	<Unknown>ú )!rá   r\   r9  rE   rF   r   r   r	   ÚHasFieldrz   r”   Úreprr…  r;  r˜   r0  rê   r  ré   r  r=  r?  rM  rL  rN  r   r  rO  rR  rf  rQ  rc   r’  )rU  rˆ  ÚcontentrŠ  r‹  rŒ  r“  rQ  r
  r”   r?  Úcommar=  rB   rB   rC   Úprintable_attributeò  sb   
$	










rš  re  c                 C   s$   |   d¡}|d u rdS tt| |ƒƒS )Nra   Ú?)Ú
WhichOneofrE   r  )re  ÚwhichrB   rB   rC   Úprintable_dim>  s   
rž  r0  c                 C   sŒ   |   d¡dkr5tj | jj¡}| j d¡r3t| jjj	ƒr/|t
dd tt| jjj	ƒ¡ ƒ7 }|S |d7 }|S |   d¡d u r>dS d|   d¡› �S )	Nra   rd  rà   r�  rU   ú, scalarrn  zUnknown type )rœ  r   ÚDataTypeÚNamerd  r  r–  r˜   rà   re  rE   r’  r  rž  ©r0  r;  rB   rB   rC   Úprintable_typeE  s   "ÿr£  r…   c                 C   s,   d| j › �}| jr|› dt| jƒ› d�}|S )Nú%r�  r‘  )r\   r÷   r£  )r…   r;  rB   rB   rC   Úprintable_value_infoS  s   r¥  c                 C   sh   d| j › d�}|tj | j¡7 }| jd ur.t| jƒr*|tdd t	t| jƒ¡ ƒ7 }n|d7 }|d7 }|S )Nr¤  r�  r�  rU   rŸ  r‘  )
r\   r   r   r¡  ré   rê   r˜   rE   r’  r  r¢  rB   rB   rC   Úprintable_tensor_protoZ  s   

 r¦  Úprefixc                 C   sD  g }t | jƒr| d dd„ | jD ƒ¡¡ | d¡ g }g }| jD ]=}|rHt||ƒ}t|d tƒs9tdt› d�ƒ‚| 	|d ¡ | |d ¡ q!t|ƒ}t|t
ƒsYtd	t
› d�ƒ‚| |¡ q!d t|ƒ¡}	d d
d„ | jD ƒ¡}
| jr„| | j› d|	› d|
› d�¡ n| | j› d|
› d�¡ |r›|d |¡ |fS |d |¡ S )Nr�  c                 S   ó   g | ]}d |› �‘qS ©r¤  rB   ©rT   r\   rB   rB   rC   r–   k  ó    z"printable_node.<locals>.<listcomp>r‰  r"   z1printed_attr_subgraphs[1] must be an instance of Ú.r   zprinted must be an instance of c                 S   r¨  r©  rB   rª  rB   rB   rC   r–     r«  r�  z](r4  ú(r•  )r˜   rd   rá   r’  re   rš  rÛ   r   rï   rc   rE   rf   rb   rY   )rh   r§  rˆ  r˜  rQ  Zprinted_attrsrU  Zprinted_attr_subgraphsZprintedZprinted_attributesZprinted_inputsrB   rB   rC   Úprintable_nodef  s6   




ÿ
 r®  c                    sn  g }|d }d| j g}dd„ | jD ƒ}t| jƒrÀ| d¡ g }g }| jD ]}|j |vr3| t|ƒ¡ q$| t|ƒ¡ q$|rW| |d |¡ ¡ g }|D ]}	| |d |	 ¡ qK| d¡ |r‚| d¡ | |d |¡ ¡ g }|D ]}	| |d |	 ¡ qq| d¡ t|ƒt|ƒk rÀd	d„ | jD ƒ‰ ‡ fd
d„| jD ƒ}
| d¡ | |d |¡ ¡ g }|
D ]}	| |d |	 ¡ q¯| d¡ | d¡ | |d |¡ ¡ g }| jD ]&}t||dd�}t	|d t
ƒsìtdt
› d�ƒ‚| |d ¡ | |d ¡ qÔdg}t| jƒ�r| d dd„ | jD ƒ¡¡ | |d |¡ ¡ | |d ¡ |D ]}| dt|ƒ ¡ �q%d |¡S )z­Display a GraphProto as a string.

    Args:
        graph (GraphProto): the graph to display
        prefix (string): prefix of every line

    Returns:
        string
    z  rr   c                 S   ó   h | ]}|j ’qS rB   rZ  r/  rB   rB   rC   r-  —  ó    z"printable_graph.<locals>.<setcomp>r­  r•  r4  z,optional inputs with matching initializers (c                 S   r¯  rB   rZ  r“   rB   rB   rC   r-  µ  r°  c                    s   g | ]}|j ˆ vrt|ƒ‘qS rB   )r\   r¦  r“   ©Úgraph_inputsrB   rC   r–   ¶  s
    
þz#printable_graph.<locals>.<listcomp>zinitializers (Ú{T)rˆ  r"   z-contents_subgraphs[1] must be an instance of r¬  r   r8   r�  c                 S   s   g | ]}d |j › �‘qS r©  rZ  )rT   ÚoutrB   rB   rC   r–   Ï  s    Ú}Ú
)r\   ro   r˜   rb   rá   r¥  r’  rh   r®  rÛ   r   rï   rc   rd   Úprintable_graph)rr   r§  r˜  ÚindentÚheaderÚinitializersZin_strsZin_with_init_strsÚinpÚlineZ	init_strsrQ  rh   Zcontents_subgraphsÚtailr=  rB   r±  rC   r·  ‰  sl   



ÿ





þ




r·  c                 C   s    t | tjjjƒstdtjjj› d�ƒ‚| jjD ]6}|jdkr%|  	|j¡ q|j
|jkrM|j|jkr?t| |jƒD ]}t|ƒ q7q|  |j¡rMtt| |jƒƒ qdS )z:Empties `doc_string` field on any nested protobuf messageszproto must be an instance of r¬  r]   N)rÛ   ÚgoogleÚprotobufÚmessageÚMessagerï   Ú
DESCRIPTORÚfieldsr\   Ú
ClearFieldr÷   ÚTYPE_MESSAGEÚlabelÚLABEL_REPEATEDr  Ústrip_doc_stringr–  )rŠ   Ú
descriptorrU   rB   rB   rC   rÈ  Ø  s    ÿ

ÿ€ørÈ  Ú	algorithmÚalgorithm_bindingsÚinitializationÚinitialization_bindingsc                 C   sr   t ƒ }|j | ¡ |D ]\}}|j ¡ }||_||_q|r#|j |¡ |r7|D ]\}}|j ¡ }||_||_q'|S rR   )	r   rÊ  r}   Zupdate_bindingr   rO   ra   rÌ  Zinitialization_binding)rÊ  rË  rÌ  rÍ  Ztraining_infor„   r…   ÚbindingrB   rB   rC   Úmake_training_infoé  s   

rÏ  Útensor_dtypec                 C   ó   t j|  jS )zÉConvert a TensorProto's data_type to corresponding numpy dtype. It can be used while making tensor.

    Args:
        tensor_dtype: TensorProto's data_type

    Returns:
        numpy's data_type
    )r   ÚTENSOR_TYPE_MAPr  ©rÐ  rB   rB   rC   rð     ó   	rð   c                 C   rÑ  )z³Convert a TensorProto's data_type to corresponding data_type for storage.

    Args:
        tensor_dtype: TensorProto's data_type

    Returns:
        data_type for storage
    )r   rÒ  Ústorage_dtyperÓ  rB   rB   rC   Ú$tensor_dtype_to_storage_tensor_dtype  rÔ  rÖ  c                 C   rÑ  )z˜Get the name of given TensorProto's data_type.

    Args:
        tensor_dtype: TensorProto's data_type

    Returns:
        the name of data_type
    )r   rÒ  r\   rÓ  rB   rB   rC   Útensor_dtype_to_string  rÔ  r×  c                 C   s   t jt j|  j S )zÎConvert a TensorProto's data_type to corresponding field name for storage. It can be used while making tensors.

    Args:
        tensor_dtype: TensorProto's data_type

    Returns:
        field name
    )r   Z_STORAGE_TENSOR_TYPE_TO_FIELDrÒ  rÕ  rÓ  rB   rB   rC   r  &  s   	
ÿr  r  c                 C   s   t ttj|  ƒS )zÑConvert a numpy's dtype to corresponding tensor type. It can be used while converting numpy arrays to tensors.

    Args:
        np_dtype: numpy's data_type

    Returns:
        TensorsProto's data_type
    )r   rF   r   Z_NP_TYPE_TO_TENSOR_TYPE)r  rB   rB   rC   Únp_dtype_to_tensor_dtype4  s   	þrØ  c                   C   s
   t j ¡ S )zcGet all tensor types from TensorProto.

    Returns:
        all tensor types from TensorProto
    )r   rÒ  r  rB   rB   rB   rC   Úget_all_tensor_dtypesC  s   
rÙ  c                 C   s   i | ]\}}||“qS rB   rB   )rT   r…   r„   rB   rB   rC   Ú
<dictcomp>L  r«  rÚ  c                 C   s$   | t j ¡ v rt|  S t j ¡ d S )z Convert AttributeProto type to string.

    Args:
        attr_type: AttributeProto type.

    Returns:
        String representing the supplied attr_type.
    r   )r   ÚAttributeTyper  Ú_ATTRIBUTE_TYPE_TO_STRr  )r+  rB   rB   rC   rT  O  s   	rT  )F)NNNN)NNNNN)r¤   TFT)r¤   FFT)NNrR   )rn  N)rn  )rn  F)vÚcollections.abcrA  r5  rŸ   Úcmathr   Útypingr   r   r   r   r   r   r	   r
   r   r   r   Úgoogle.protobuf.messager¾  Únumpyr½   Úonnxr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    rE   rF   ZVersionRowTypeZVersionTableTypeZAssignmentBindingTyper6   Ú__annotations__ZVersionMapTyperH   rM   ÚboolrX   ri   rm   rs   rt   r{   r†   r‰   rŽ   r�   Ú	complex64r™   r9  r£   rÇ   rÓ   rÜ   rè   r  r  r   r  r$  r'  r  r*  r`   rÛ  rW  rX  r]  r_  rl  ro  rr  rs  rx  r{  r~  r  r…  r‡  rš  Z	Dimensionrž  r£  r¥  r¦  r®  r·  r¿  rÀ  rÁ  rÈ  rÏ  r×   rð   rÖ  r×  r  rØ  rÙ  rg   rÜ  rT  rB   rB   rB   rC   Ú<module>   sô  
4T&ÿÿÿ
þ ùÿþýüûúùø	
÷1ÿþ
ýøÿþýü
ûú
ù
ø	
÷+õÿþýüûú
ù
ø	÷
ö
õ
ô$%	ÿÿ
ü
ûûÿþýüû
ú 	ûÿþýüû
ú~ÿÿ
þÿÿÿÿÿÿ
þwÿÿÿ
þÿþý
üÿÿÿÿ
þÿþý
üüÿþýü
û_ÿÿÿÿ
þ$		ýÿþ
ý
ü1ûÿþýü
û
úýÿþ
ý
ü1ûÿþýü
û
úÿ
þ	ÿ
þ	ÿþ
ýýÿþý
üûÿþýü
û
úÿÿÿ
þLÿÿÿÿ
þ#Oÿþýü
û	