o
    eM                     @   s  U d dl Zd dlZd dlm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 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% d dlm&Z& d dlm'Z' d dl(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/Z3dee de+fddZ4			dde*dee* dee* de	e* de	e* de	e* dedefddZ5de*de+defddZ6ddg dfdee de*dee dee de	ee  de	e* dee d e	ee  defd!d"Z7de*de+defd#d$Z8g dfde*d%e*dee* dee* dee d&ee d'e	ee*  de	e* de%fd(d)Z9d*ededefd+d,Z:d*ededefd-d.Z;d/ed0e
e*e*f ddfd1d2Z<d3eej= dee+ fd4d5Z>dd7e?d8e@de+fd9d:ZA	6dde*d;e+d<ee+ d=ed>e@defd?d@ZBdAedBed<ee+ defdCdDZCde*dEe jDdAee de fdFdGZEde*dHe+dIee dAe de!f
dJdKZFde*dEe$jDdLe	e de$fdMdNZGdOee*eHf deeHe@f fdPdQZI	ddRe*dLede	e* defdSdTZJdUedefdVdWZKde*defdXdYZL	ddEe+dZe	eee*e+df   d[e	ee*  defd\d]ZM	^	dde*dEe+dZe	eee*e+df   de*d[e	ee*  defd_d`ZN	ddEe+dZe	eee*e+df   d[e	ee*  defdadbZO	^	dde*dEe+dZe	eee*e+df   de*d[e	ee*  defdcddZPdeedefdfdgZQdeedefdhdiZR	^dde*djede*defdkdlZSdmee*eHf de*fdndoZT	^	dde*dEe+dZe	eee*e+df   de*dpe	ee*  defdqdrZUddUedse@dee*ee*ee f f fdtduZVdvejWde*fdwdxZXdyede*fdzd{ZYd|ede*fd}d~ZZdyede*fddZ[ddede*dse@dee*ee*ee f f fddZ\dd*ede*de*fddZ]dej^j_j`ddfddZadede.de	e de	e. de#f
ddZbdS )    N)isnan)
SequenceAnyOptionalDictUnionTypeVarCallableTupleListcast)TensorProtoSparseTensorProtoAttributeProtoValueInfoProtoTensorShapeProto	NodeProto
ModelProto
GraphProtoOperatorSetIdProto	TypeProtoSequenceProtoMapProto
IR_VERSIONTrainingInfoProtoOptionalProtoFunctionProto)defs)mapping)STORAGE_TENSOR_TYPE_TO_FIELD))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!   VERSION_TABLEtablereturnc                    s:   t   dtdtdtddf fdd}| D ]}||  q S )zNcreate a map from (opset-domain, opset-version) to ir-version from above tablerelease_version
ir_versionargsr3   Nc                    sD   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   r8   zai.onnx.preview.trainingr!   )zip)r4   r5   r6   pairresult ;D:\Projects\ConvertPro\env\Lib\site-packages\onnx/helper.pyprocess5   s   z-create_op_set_id_version_map.<locals>.process)dictstrintr   )r2   r?   rowr=   r;   r>   create_op_set_id_version_map1   s
   
rD   opsetidlistc                    s@   d}dt tdf dtdtfdd | rt fdd	| D S |S )
z>Given list of opset ids, determine minimum IR version requiredr    domainNversionr3   c                 S   s(   | r| nd|f}|t v rt | S td)Nr7   zUnsupported opset-version.)OP_SET_ID_VERSION_MAP
ValueError)rF   rG   keyr=   r=   r>   find_minG   s   z)find_min_ir_version_for.<locals>.find_minc                 3   s    | ]
} |j |jV  qd S N)rF   rG   ).0xrK   r=   r>   	<genexpr>N   s    z*find_min_ir_version_for.<locals>.<genexpr>)r   rA   rB   max)rE   Zdefault_min_versionr=   rO   r>   find_min_ir_version_forC   s
   rR   op_typeinputsoutputsname
doc_stringrF   kwargsc                 K   sl   t  }| |_|j| |j| |r||_|r||_|dur#||_|r4|jdd t	|
 D  |S )a  Construct a NodeProto.

    Arguments:
        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)
        **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 rL   )make_attribute)rM   rJ   valuer=   r=   r>   rP   v   s    zmake_node.<locals>.<genexpr>)r   rS   inputextendoutputrV   rW   rF   	attributesorteditems)rS   rT   rU   rV   rW   rF   rX   noder=   r=   r>   	make_nodeR   s   
rb   rG   c                 C      t  }| |_||_|S zConstruct an OperatorSetIdProto.

    Arguments:
        domain (string): The domain of the operator set id
        version (integer): Version of operator set id
    Returns:
        OperatorSetIdProto
    r   rF   rG   )rF   rG   Zoperatorsetidr=   r=   r>   make_operatorsetid}   s   rf   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

    Arguments:
        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   ra   r\   rV   r[   r]   rh   rj   ri   rW   )	rg   rV   rT   rU   rh   rW   ri   rj   graphr=   r=   r>   
make_graph   s"   rl   c                 C   rc   rd   re   )rF   rG   Zopsetidr=   r=   r>   make_opsetid   s   	rm   fnameopset_imports
attributesc           	      C   s\   t  }| |_||_|j| |j| |j| |j| |j| |r,||_	|S rL   )
r   rF   rV   r[   r\   r]   ra   opset_importr^   rW   )	rF   rn   rT   rU   rg   ro   rp   rW   fr=   r=   r>   make_function   s   
rs   rk   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 )zConstruct a ModelProto

    Arguments:
        graph (GraphProto): *make_graph* returns
        **kwargs: any attribute to add to the returned instance
    Returns:
        ModelProto
    Nro   	functions)r   r   r5   rk   CopyFrompoprq   r\   addr   Zonnx_opset_versionrG   rt   r`   setattr)rk   rX   modelro   imprt   kvr=   r=   r>   
make_model   s    	

r}   c                 K   s@   d}||vrd}||v r|| ng }t |||< t| fi |S )Nr5   ro   )rR   r}   )rk   rX   Zir_version_fieldZopset_imports_fieldZimportsr=   r=   r>   make_model_gen_version  s   r~   ry   
dict_valuec                 C   s8   | j d d = | D ]\}}| j  }||_||_q
d S rL   )Zmetadata_propsr`   rw   rJ   rZ   )ry   r   r{   r|   entryr=   r=   r>   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rM   ir   r=   r>   
<listcomp>  s    ,z*split_complex_to_pairs.<locals>.<listcomp>r*   )rangelenr   r=   r   r>   split_complex_to_pairs  s   
r   Ffvaltruncatec                 C   sH   t td| d}|r|d? S t| rdS |d? d@ d }|| d? S )Nz<flittler/   i  r!   i  )rB   
from_bytesstructpackr   )r   r   Zivalroundr=   r=   r>   float32_to_bfloat16"  s   r   	data_typedimsvalsrawc           
      C   sZ  t  }||_| |_|t jkr|rJ dtj| }d}|r(|t jkr%d}n|j}t|t	j
u r:t|jdkr:| }|D ]}||9 }q<t||krStd|t||rY||_nL|t jksc|t jkrht|}n-|t jkrt	||jt	jd  }n|t jkrtttt	||  }tjtj|  }	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.

    Arguments:
        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 seralized 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 typer!   r*   zJNumber of values does not match tensor's size. Expected {}, but it is {}. )Zdtype)"r   r   rV   STRINGr   ZTENSOR_TYPE_TO_NP_TYPEZBFLOAT16itemsizetypenpZndarrayr   shapeflattenrI   formatraw_dataZ	COMPLEX64Z
COMPLEX128r   ZFLOAT16arrayZastypeviewZuint16tolistlistmapr   r   Z"TENSOR_TYPE_TO_STORAGE_TENSOR_TYPEgetattrr\   r   )
rV   r   r   r   r   ZtensorZnp_dtypeZexpected_sizedfieldr=   r=   r>   make_tensor/  sB   





$
"r   valuesindicesc                 C   s.   t  }|j|  |j| |j| |S )zConstruct a SparseTensorProto

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

    Returns:
        SparseTensorProto
    )r   r   ru   r   r   r\   )r   r   r   sparser=   r=   r>   make_sparse_tensort  s
   r   	elem_typec                 C   s0   t  }| |_||_tj| }t||| |S )z9
    Make a Sequence with specified value arguments.
    )r   rV   r   r   ZSTORAGE_ELEMENT_TYPE_TO_FIELDr   r\   )rV   r   r   sequencevalues_fieldr=   r=   r>   make_sequence  s   
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   ZINT8ZINT16ZINT32ZINT64ZUINT8ZUINT16ZUINT32ZUINT64rV   r   r   Zstring_keysr\   r   r   ru   )rV   r   r   r   r   Zvalid_key_int_typesr=   r=   r>   make_map  s   
r   rZ   c                 C   s8   t  }| |_||_|dkrtj| }t||| |S )z:
    Make an Optional with specified value arguments.
    r   )r   rV   r   r   ZOPTIONAL_ELEMENT_TYPE_TO_FIELDr   ru   )rV   r   rZ   optionalr   r=   r=   r>   make_optional  s   
r   valc                 C   s0   t | tr| S z| dW S  ty   Y dS w )a3  An internal graph to convert the input to a bytes or to False.

    The criteria for conversion is as follows and should be python 2 and 3
    compatible:
    - If val is py2 str or py3 bytes: return bytes
    - If val is py2 unicode or py3 str: return val.decode('utf-8')
    - Otherwise, return False
    utf-8F)
isinstancebytesencodeAttributeError)r   r=   r=   r>   _to_bytes_or_false  s   
	r   rJ   c                 C   s  t  }| |_|r||_t|tjj}t|}t|tr$||_	t j
|_|S t|tjr6tt||_t j|_|S |durJt|tsAJ ||_t j|_|S t|tr[|j| t j|_|S t|trl|j| t j|_|S t|tr}|j| t j|_|S t|tr|j | t j!|_|S |rAdd |D }t"dd |D r|j#$dd |D  t j%|_|S t"dd |D r|j&$dd |D  t j'|_|S t"t(d	d
 |r|j)$tt*t | t j+|_|S t"dd |D r|j,$| t j-|_|S t"dd |D r|j.$| t j/|_|S t"dd |D r'|j0$| t j1|_|S t"dd |D r=|j2$| t j3|_|S t4dt5d| d)z0Makes an AttributeProto based on the value type.Fc                 S   s   g | ]}t |qS r=   )r   rM   r|   r=   r=   r>   r     s    z"make_attribute.<locals>.<listcomp>c                 s       | ]	}t |tjV  qd S rL   )r   numbersIntegralr   r=   r=   r>   rP         z!make_attribute.<locals>.<genexpr>c                 s       | ]}t |V  qd S rL   )rB   r   r=   r=   r>   rP         c                 s   r   rL   )r   r   Realr   r=   r=   r>   rP     r   c                 s   r   rL   )floatr   r=   r=   r>   rP   	  r   c                 S   s   | duS )NFr=   )bytes_or_falser=   r=   r>   <lambda>  s    z make_attribute.<locals>.<lambda>c                 s       | ]}t |tV  qd S rL   )r   r   r   r=   r=   r>   rP         c                 s   r   rL   )r   r   r   r=   r=   r>   rP     r   c                 s   r   rL   )r   r   r   r=   r=   r>   rP     r   c                 s   r   rL   )r   r   )rM   tpr=   r=   r>   rP     r   zPYou passed in an iterable attribute but I cannot figure out its applicable type.zvalue "z#" is not valid attribute data type.)6r   rV   rW   r   collectionsabcIterabler   r   rr   FLOATr   r   r   r   rB   r   INTr   sr   r   tru   TENSORr   sparse_tensorSPARSE_TENSORr   gGRAPHr   r   
TYPE_PROTOallintsr\   INTSfloatsFLOATSr   stringsr   STRINGStensorsTENSORSsparse_tensorsSPARSE_TENSORSgraphsGRAPHStype_protosTYPE_PROTOSrI   	TypeError)rJ   rZ   rW   attris_iterabler   Z
byte_arrayr=   r=   r>   rY     s   
84/
,
)
&
#
rY   r   c                 C   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r$| j	S | j tj
kr-| jS | j tjkr6| jS | j tjkr?| 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rkt| jS | j tjkrvt| jS | j tjkrt| jS | j tjkrt| jS td|  )NzUnsupported ONNX attribute: ) r   r   r   rr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rI   )r   r=   r=   r>   get_attribute_value$  s:   






r   c                 C   s   t  }| |_|S rL   )r   rV   )rV   value_info_protor=   r=   r>   make_empty_tensor_value_infoD  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   dimr\   r   rI   	enumeraterw   r   rB   	dim_valuerA   	dim_param
denotation)	r   r   r   
type_prototensor_type_protoZtensor_shape_protor   r   r   r=   r=   r>   make_tensor_type_protoJ  4   




r    c                 C   s2   t  }| |_|r||_t|||}|j| |S )z8Makes a ValueInfoProto based on the data type and shape.)r   rV   rW   r   r   ru   )rV   r   r   rW   r   r   r   r=   r=   r>   make_tensor_value_infox  s   r   c           	      C   r   )z@Makes a SparseTensor TypeProto based on the data type and shape.Nr   r   z. Needs to be of int or text.)r   sparse_tensor_typer   r   r   r\   r   rI   r   rw   r   rB   r   rA   r   r   )	r   r   r   r   sparse_tensor_type_protoZsparse_tensor_shape_protor   r   r   r=   r=   r>   make_sparse_tensor_type_proto  r   r   c                 C   s6   t  }| |_|r||_t|||}|jj|j |S )zEMakes a SparseTensor ValueInfoProto based on the data type and shape.)r   rV   rW   r   r   r   ru   )rV   r   r   rW   r   r   r   r=   r=   r>   make_sparse_tensor_value_info  s   r   inner_type_protoc                 C      t  }|jj|  |S )zMakes a sequence TypeProto.)r   sequence_typer   ru   r  r   r=   r=   r>   make_sequence_type_proto     r  c                 C   r  )zMakes an optional TypeProto.)r   Zoptional_typer   ru   r  r=   r=   r>   make_optional_type_proto  r  r  r   c                 C   s&   t  }| |_|r||_|j| |S )z1Makes a ValueInfoProto with the given type_proto.)r   rV   rW   r   ru   )rV   r   rW   r   r=   r=   r>   make_value_info  s   r  r   c                 C   s^   t | tr| }nt | tr| jddd}nt| }t|dk r!|S |d d dt|d   S )Nr   ignore)errors@   z...<+len=%d>)r   rA   r   decoder   )r   Z	sanitizedr=   r=   r>   _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   rV   rW   r   r  r   r  ru   )rV   r   r   rW   r  r   r   Zsequence_type_protor=   r=   r>   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rt| jjdkrx| d nt| jj }| dt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rU| d t| jD ]\}	}|	t| jd kr9dnd}| d|j d|  q)| d || j n| d |rdd ||fS d |S ) N=rr   r3   c                 S   s   | dS )Nz.15gr=   )rr   r=   r=   r>   	str_float  s   z&printable_attribute.<locals>.str_floatr   c                 S   s   t | S rL   )rA   )r   r=   r=   r>   str_int  s   z$printable_attribute.<locals>.str_int_Tstr_elemxsc                 S   s   dd t| | d S )N[, ])joinr   )r  r  r=   r=   r>   str_list  s   z%printable_attribute.<locals>.str_listr   r   r   z<Tensor>z<Scalar Tensor >r   z<graph r   z<Type Proto z[<Tensor>, ...]r  r!   ,r   r  z	<Unknown> )!appendrV   r   rA   rB   r   r	   r   HasFieldrr   r   reprr  r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r\   r  )r   r  contentr  r  r  r  r   r   r   r   commar   r=   r=   r>   printable_attribute  sb   
$	



 






r$  r   c                 C   s$   |  d}|d usJ tt| |S )NrZ   )
WhichOneofrA   r   )r   whichr=   r=   r>   printable_dimV  s   
r'  r   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 )	NrZ   r   r   r  rN   , scalarr   zUnknown type )r%  r   DataTypeNamer   r   r   r   r   r   rA   r  r   r'  r   r   r=   r=   r>   printable_type\  s   "r,  r|   c                 C   s,   d| j  }| jr| dt| j d}|S )N%r  r  )rV   r   r,  )r|   r   r=   r=   r>   printable_value_infoj  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  rN   r(  r  )
rV   r   r)  r*  r   r   r   rA   r  r   r+  r=   r=   r>   printable_tensor_protoq  s   

 r/  ra   prefixc                 C   s,  g }t | jr|ddd | jD  |d g }g }| jD ]1}|rBt||}t|d ts3J ||d  ||d  q!t|}t|t	sMJ || q!dt
|}	ddd | jD }
| jrx|| j d|	 d	|
 d
 n|| j d|
 d
 |r|d| |fS |d| S )Nr  c                 S      g | ]}d | qS r-  r=   rM   rV   r=   r=   r>   r         z"printable_node.<locals>.<listcomp>r  r!   r   c                 S   r1  r2  r=   r3  r=   r=   r>   r     r4  r  z]()(r  )r   r]   r  r  r^   r$  r   r   r\   rA   r_   r[   rS   )ra   r0  r  r"  r   Zprinted_attrsr   Zprinted_attr_subgraphsZprintedZprinted_attributesZprinted_inputsr=   r=   r>   printable_node}  s2   



 r7  c                    sb  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 rd	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
sJ ||d  ||d  qdg}t| jr|ddd | jD  ||d|  ||d  |D ]}|dt|  qd|S )z
    Display a GraphProto as a string.

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

    Returns:
        string
    z  rk   c                 S      h | ]}|j qS r=   rV   )rM   r   r=   r=   r>   	<setcomp>      z"printable_graph.<locals>.<setcomp>r6  r  r5  z,optional inputs with matching initializers (c                 S   r8  r=   r9  r   r=   r=   r>   r:    r;  c                    s   g | ]}|j  vrt|qS r=   )rV   r/  r   Zgraph_inputsr=   r>   r     s    
z#printable_graph.<locals>.<listcomp>zinitializers ({T)r  r!   r   r3   r  c                 S   s   g | ]}d |j  qS r2  r9  )rM   outr=   r=   r>   r     s    }
)rV   rh   r   r[   r  r.  r  ra   r7  r   r   r\   r]   printable_graph)rk   r0  r"  indentheaderZinitializersZin_strsZin_with_init_strsinplineZ	init_strsr   ra   Zcontents_subgraphstailr   r=   r<  r>   rA    sh   












rA  protoc                 C   s   t | tjjjs
J | jjD ]6}|jdkr| |j q|j	|j
krD|j|jkr6t| |jD ]}t| q.q| |jrDtt| |j qdS )zD
    Empties `doc_string` field on any nested protobuf messages
    rW   N)r   googleprotobufmessageMessageZ
DESCRIPTORfieldsrV   Z
ClearFieldr   ZTYPE_MESSAGElabelZLABEL_REPEATEDr   strip_doc_stringr   )rG  Z
descriptorrN   r=   r=   r>   rN    s   

rN  	algorithmalgorithm_bindingsinitializationinitialization_bindingsc                 C   sr   t  }|j|  |D ]\}}|j }||_||_q|r#|j| |r7|D ]\}}|j }||_||_q'|S rL   )	r   rO  ru   Zupdate_bindingrw   rJ   rZ   rQ  Zinitialization_binding)rO  rP  rQ  rR  Ztraining_infor{   r|   Zbindingr=   r=   r>   make_training_info  s   

rS  )NNN)FrL   )r   N)r   )r   F)ccollections.abcr   r   Zcmathr   r   typingr   r   r   r   r   r   r	   r
   r   r   Zgoogle.protobuf.messagerH  numpyr   Zonnxr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   Zonnx.mappingr   rA   rB   ZVersionRowTypeZVersionTableTypeZAssignmentBindingTyper1   __annotations__ZVersionMapTyperD   rH   rR   rb   rf   rl   rm   rs   r}   r~   r   Z	complex64r   r   boolr   r   r   r)  r   r   r   r   r   rY   r   r   r   r   r   r   r  r  r  r  r  r$  Z	Dimensionr'  r,  r.  r/  r7  rA  rI  rJ  rK  rN  rS  r=   r=   r=   r>   <module>   s   
0H&
+


	
+
	
%		
E



"
L 	

2



2


	



,K0K*