
     Ti2X                    P   % S SK Jr  S SKrS SKrS SKrS SKJrJrJrJ	r	J
r
JrJrJrJr  S SKrS SKrS SKrS SKrS SKrS SKJr  S SKJrJr  S SKJrJrJrJr  S SK J!r!  \\	\RD                     \S   4   r#S	\$S'   \\	S
   \S   4   r%S	\$S'   \\	S
   \S   \RD                  \&\'\(\)4   r*S	\$S'   \" S5      r+S*S jr,S+S jr-S,S jr.\ " S S\
5      5       r/ " S S\/\R`                  5      r1 " S S\25      r3S r4        S-S jr5S r6  S.S jr7        S/S jr8        S/S jr9    S0S jr: " S S\15      r; " S  S!\15      r<\;" 5       r= " S" S#\;5      r>\>" 5       r?\?R                  \R                  S$9S1S% j5       rB\=qCS\$S&'   S2S' jrDS3S( jrE\R                  S4S) j5       rGg)5    )annotationsN)	AnyCallableMappingOptionalProtocolSequenceTypeVarUnionruntime_checkable)	TypeAlias)
onnx_opsettensor)autocastparam_manipulationutilsvalues)_schemasUserModeValuer   ztensor.TensorEagerModeValueExtendedModeValue_Tc                4   ^^ SmSUU4S jjmT" U 5      nUT4$ )a  Adapts inputs into representation used by onnxscript eager mode.

This does the following transformations:
* It adds an onnxscript Tensor wrapper around numpy arrays, which
allows the use of overloaded operators like + to be controlled by onnxscript.
* It also provides a promotion of scalars into tensors as a convenience.
This is needed to complement the similar promotion supported by the
onnxscript converter (for example, when an attribute is promoted and used
as an input argument).

Args:
    inputs: a list/tuple of inputs to an ONNX function

Returns:
    a pair (wrapped_inputs, flag) where flag indicates whether any numpy array
    was wrapped into a Tensor.
Fc                  > [        U [        R                  5      (       a  Sm[        R                  " U 5      $ [        U [        R                  5      (       a  U $ [        U [
        [        45      (       a*  [        R                  " [        R                  " U 5      5      $ [        U [        5      (       a7  [        R                  " [        R                  " U [        R                  S95      $ U c  g [        U [        5      (       a  U  Vs/ s H  nT" U5      PM     sn$ [        U [        5      (       a  [        U4S jU  5       5      $ [        S[        U 5       S35      es  snf )NTdtypec              3  4   >#    U  H  nT" U5      v   M     g 7fN ).0eltadapts     ]/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/onnxscript/_internal/evaluator.py	<genexpr>6_adapt_to_eager_mode.<locals>.adapt.<locals>.<genexpr>T   s     5usus   zUnexpected input type .)
isinstancenpndarrayr   Tensorboolfloatarrayintint64listtuple	TypeErrortype)inputr!   r"   	has_arrays     r#   r"   #_adapt_to_eager_mode.<locals>.adaptD   s    eRZZ((I==''eV]]++LedE]++==%11eS!!==%rxx!@AA=eT""*/0%3E#J%00eU##5u5550eQ?@@ 1s   E)r4   r   returnr   r   )inputsresultr"   r5   s     @@r#   _adapt_to_eager_moder:   0   s,    $ IA A& 6]F9    c                   [        U [        R                  5      (       a  U R                  $ U c  g[        U [        5      (       a  U  Vs/ s H  n[        U5      PM     sn$ [        U [        5      (       a  [        S U  5       5      $ [        U [        R                  5      (       a  U $ [        S[        U 5       S35      es  snf )zUnwraps Tensor wrapper around numpy arrays.

Args:
    output: output of an ONNX function, which can be either a single
        onnx value or a list/tuple of onnx values.

Returns:
    unwrapped output
Nc              3  8   #    U  H  n[        U5      v   M     g 7fr   )_adapt_to_user_mode)r    r!   s     r#   r$   &_adapt_to_user_mode.<locals>.<genexpr>l   s     @#(--s   zUnexpected type r&   )r'   r   r*   valuer0   r>   r1   r(   r)   r2   r3   )outputr!   s     r#   r>   r>   [   s     &&--((||~&$4:;FS#C(F;;&%  @@@@&"**%%
&tF|nA6
77 <s   	Cc                    0 nU R                  5        H8  u  p#X1U'   [        U[        R                  5      (       d  M*  UR                  X'   M:     U$ )z,Unwrap tensors in a mapping to numpy arrays.)itemsr'   r   r*   r@   )kwargs
new_kwargskvs       r#   _unwrap_tensors_in_kwargsrH   r   sD    J1a''GGJM 
 r;   c                  D    \ rS rSrSr      SS jr      SS jrSrg)		Evaluator}   zProtocol for evaluating ONNX ops.

NOTE: The ``eval`` method was deprecated and removed. Implement ``eval_op``
and ``eval_function`` instead.
c                    g)zEvaluates an Op.

Args:
    op: The Op to evaluate.
    args: The positional arguments to the op.
    kwargs: The keyword arguments to the op.
Nr   )selfopargsrD   s       r#   eval_opEvaluator.eval_op       r;   c                    g)zEvaluates an OnnxFunction.

Args:
    function: The OnnxFunction to evaluate.
    args: The positional arguments to the function.
    kwargs: The keyword arguments to the function.
Nr   )rM   functionrO   rD   s       r#   eval_functionEvaluator.eval_function   rR   r;   r   NrN   z	values.OprO   Sequence[ExtendedModeValue]rD   Mapping[str, ExtendedModeValue]rT   zvalues.OnnxFunctionrO   rX   rD   rY   )__name__
__module____qualname____firstlineno____doc__rP   rU   __static_attributes__r   r;   r#   rJ   rJ   }   sI     * 0	% * 0	r;   rJ   c                      \ rS rSrSrSSS jjr    SS jr    SS jrSS jrSS jr	\
R                            SS j5       r      SS	 jr      SS
 jrSrg)BaseEvaluator   a[  Base class for evaluation of ONNX ops.

The execution of onnxscript functions in eager-mode is dispatched to an Evaluator
instance (or, more precisely, to the eval method of the Evaluator instance).
The evaluator is expected to transform the input/output/attribute representation
supported by onnxscript to those expected by a particular backend.
c                    Xl         g)ak  Initializes a BaseEvaluator.

Args:
    ignore_unknown_function_kwargs: Whether to ignore unknown keyword arguments
        when evaluating an OnnxFunction. This is useful when using the
        evaluator to validate operators programmatically, where
        additional keyword arguments that is not part of the signature
        may be provided to the function.
N_ignore_unknown_function_kwargs)rM   ignore_unknown_function_kwargss     r#   __init__BaseEvaluator.__init__   s     0N,r;   c                .    [         R                  " X5      $ )zTransform inputs to the expected format for the evaluator.

Enables some syntactic sugar, such as the use of Python scalars,
in a manner consistent with the translator. See autocast.py for details.
)r   dynamic_cast_inputs)rM   op_signaturer8   s      r#   _adapt_inputsBaseEvaluator._adapt_inputs   s     ++LAAr;   c                   U R                  U5      n0 n0 nUR                  5        H  u  pg[        U[        R                  5      (       a  U(       al  UR
                  R                  5       XV'   UR
                  R                   H4  u  pUR                  R                  U   XIR                  R                  '   M6     M  UR                  XV'   M  [        U5      (       a  [        SUR                   S35      eXuU'   M     XT4$ )zTransform attributes to the expected format for the evaluator.

Returns:
    A closure that can be used to evaluate graph-valued attributes.
z!Error: function-valued attribute zH has no graph_protoattribute. Did you forget to decorate it with @graph?)use_graph_attributerC   r'   r   OnnxClosurefunction_irto_graph_protoouter_scope_variablesframef_localsr@   namerT   callabler2   r[   )
rM   rl   
attributesrp   closureadapted_attributesrF   rG   pyvaronnxvars
             r#   _adapt_attributesBaseEvaluator._adapt_attributes   s     #66|D"$$$&DA!V//00&,-MM,H,H,J&)*+--*M*M67gg6F6Fu6M 2 23 +N -.JJ&)!7

| DL L 
 )*1% ' "**r;   c                .    [        U5      S:X  a  US   $ U$ )z~Adapt evaluator's output to convention used in onnxscript.

Onnxscript uses a tuple/sequence only when number of outputs > 1.
   r   )len)rM   outputss     r#   _adapt_outputsBaseEvaluator._adapt_outputs   s    
 !\Q.wqz;G;r;   c                    Ag)NTr   rM   rl   s     r#   rp   !BaseEvaluator.use_graph_attribute   s    r;   c                    g)a  Evaluates an ONNX op given its schema and inputs/attributes.

Args:
    schema: The schema of the op to evaluate.
    inputs: The ONNX inputs to the op.
    attributes: The ONNX attributes to the op.
    closure: The closure to use when evaluating graph-valued attributes.
Nr   rM   schemar8   ry   rz   s        r#   _evalBaseEvaluator._eval   rR   r;   c                   UR                   nUc   SUR                   S35       e[        U5      nU R                  XE5      u  pVU R	                  XB5      nU R                  UR                  XuU5      nU R                  U5      $ )NzOp  has no signature.)rl   rw   rH   r~   rm   r   	op_schemar   )	rM   rN   rO   rD   rl   ry   rz   r8   r   s	            r#   rP   BaseEvaluator.eval_op   s     'J3rwwi7I)JJ'.v6
"44\N
##L7**R\\6wG""7++r;   c                x   UR                   nUc  [        SUR                   S35      e[        R                  " UUUSU R
                  S9u  pV/ n0 nSn	U H`  u  p[        U[        R                  5      (       a+  [        U
5      u  pU	=(       d    Un	UR                  U5        MO  UR                  U
5        Mb     UR                  5        HI  u  nu  p[        U[        R                  5      (       a  [        U
5      u  pU	=(       d    Un	XU'   ME  XU'   MK     UR                  " U0 UD6nU	(       a  [        U5      $ U$ )a  Evaluates a function in eager mode.

Override this function to change the evaluator's behavior for functions.

Args:
    function: The OnnxFunction to evaluate.
    args: The positional arguments to the function.
    kwargs: The keyword arguments to the function.
z	Function r   F)fill_defaultsallow_extra_kwargs)rl   RuntimeErrorrw   r   tag_arguments_with_signaturerf   r'   r   	Parameterr:   appendrC   rT   r>   )rM   rT   rO   rD   rl   tagged_argstagged_kwargsadapted_argsadapted_kwargsr5   argparamadapted_arg
has_array_keyr9   s                   r#   rU   BaseEvaluator.eval_function  s=     ,,8==/9KLMM &8%T%T#CC&
" 1379	%JC%!3!344*>s*C'%3	##K0##C( & "/!4!4!6C#%!3!344*>s*C'%3	&1s#&)s# "7 ""LCNC /8"6*CVCr;   re   N)F)rg   r+   )rl   _schemas.OpSignaturer8   rX   )ry   rY   r7   zAtuple[dict[str, ExtendedModeValue], dict[str, ExtendedModeValue]])r   zSequence[EagerModeValue]rl   r   r7   r+   )
r   onnx.defs.OpSchemar8   rX   ry   rY   rz   rY   r7   r   rW   rZ   )r[   r\   r]   r^   r_   rh   rm   r~   r   rp   abcabstractmethodr   rP   rU   r`   r   r;   r#   rb   rb      s    
NB0B:UB+(G+	J+8< 	" , 4	
 1 
  ,, *, 0	,8D%8D *8D 0	8Dr;   rb   c                      \ rS rSrSrg)EagerModeErroriE  r   N)r[   r\   r]   r^   r`   r   r;   r#   r   r   E  s    r;   r   c                    Uc  gU  U 3$ )N r   )prefixir   s      r#   
_rename_ior   I  s    
{XaS>r;   c                   U R                   S:X  a  U R                  S:X  a  UR                  SS5      (       d  gU R                  S:X  a  gU R                  S:X  aB  [        U5      S:X  a  S	U;  a  [	        S
5      e[        U5      S:X  a  [        US   5      $ US	   $ U R                  S:X  a  US   n[        UR
                  5      $ U R                  S:X  a  US   n[        UR
                  5      S-
  $ [        U R                  5      $ )z'Returns the number of outputs expected.r   BatchNormalizationtraining_moder   r   LSTM   Splitnum_outputszcOperator Split: the number of expected outputs defines the split. This information is unknown here.   ScanbodyLoop)domainrw   getr   r   rA   r   )r   rO   rD   	scan_body	loop_bodys        r#   compute_num_outputsr   O  s     }};;..::oq11;;& ;;'!4yA~-v"=$8  4yA~47|#m,,;;& vIy''((;;& vIy''(1,,v~~r;   c                $   [        U [        R                  5      (       a  U R                  $ [        U [        5      (       a  U  Vs/ s H  n[        U5      PM     sn$ [        U [        5      (       a]  [        U 5      S:  a8  [        U S   5      [        L a#  [        R                  " U [        R                  S9$ [        R                  " U 5      $ U c  U $ [        U [        R                  5      (       a  U $ [        S[        U 5       S35      es  snf )zZConverts an onnxscript encoding of an ONNX value into the numpy encoding used by runtimes.r   r   z"Unexpected onnxscript value type 'zV'.Valid value types are 'Tensor | list[Tensor] | None | np.ndarray | list[np.ndarray]')r'   r   r*   r@   r0   _onnxscript_to_numpy_valuer1   r   r3   r.   r(   r-   r/   r)   r2   rG   xs     r#   r   r   n  s    !V]]##ww!T789q!*1-q99!Uq6A:$qt*+88ARXX..xx{y !RZZ  

,T!WI 6_ 	_  :s   Dc                   [        U [        R                  5      (       a$  [        R                  " U R                  5       5      $ [        [        U 5      [        R                  5      (       a*  [        R                  " [        R                  " U 5      5      $ [        U [        5      (       a  U  Vs/ s H  n[        U5      PM     sn$ U c  [        S5      e[        S[        U 5       S35      es  snf )zOConverts an ORT encoding of an ONNX value into the encoding used by onnxscript.z*Dynamic optional values not yet supported.zUnexpected runtime value type 'zR'.Valid types are: 'np.ndarray | np.generic | list[np.ndarray] | list[np.generic]')r'   r(   r)   r   r*   copy
issubclassr3   genericr-   r0   _numpy_to_onnxscript_valuer2   r   s     r#   r   r     s     !RZZ   }}QVVX&&$q'2::&& }}RXXa[))!T789q!*1-q99yDEE

)$q' 3[ 	[  :s   /C-c           	     v  ^ ^ U=(       d    0 nU Vs/ s H  n[        U5      PM     nnUR                  5        VVs0 s H  u  pVU[        U5      _M     nnnS	U 4S jjm[        U5       VVs/ s H  u  px[        SXx5      PM     n	nn[	        T X5      n
[        U
5       Vs/ s H  nSU 3PM
     nn[        R                  R                  T R                  XT R                  S9nUR                  R                  U4S jUR                  5        5       5        [        R                  " [        X5      5      n[        R                  " UR                  5       5      nU Vs/ s H6  n[        R                  R!                  U[        R"                  " 5       5      PM8     nn[        R                  R%                  U/SX-   U5      n[        R                  R'                  T R                  T R(                  5      n[        R                  R+                  UU/[,        R.                  " T R(                  T R                  S9S9n[        R0                  R3                  U5      n[        X5       VVs0 s H  u  pUS:w  d  M  X_M     nnnUR5                  U5        UUU	4$ s  snf s  snnf s  snnf s  snf s  snf s  snnf )
Nc                   >^  SU 4S jjn[         R                  " [        R                  " T X[	        TR
                  T    R                  5      5      5      $ )Nc                    > ST  3$ )Nattr_r   )r   s   r#   make_tensor_nameP_prepare_model_and_inputs_for_eager.<locals>.make_attr.<locals>.make_tensor_name  s    3%= r;   )r7   str)irto_protor   pyvalue_to_onnx_attributer.   ry   r3   )r   r@   r   r   s   `  r#   	make_attr6_prepare_model_and_inputs_for_eager.<locals>.make_attr  sF    	! {{..Uc&2C2CC2H2M2M.N
 	
r;   r4   rA   )r   c              3  B   >#    U  H  u  pUc  M
  T" X5      v   M     g 7fr   r   )r    r   r@   r   s      r#   r$   6_prepare_model_and_inputs_for_eager.<locals>.<genexpr>  s#      0>*#%	#s   	
node_graph)opset_imports
ir_versionr   )r   r   r@   r   r7   zonnx.AttributeProto)r   rC   	enumerater   r   rangeonnxhelper	make_noderw   r   	attributeextendr   values_to_value_infoszipmake_value_info	TypeProto
make_graphmake_opsetidsince_version
make_modelr   select_ir_versionshape_inferenceinfer_shapesupdate)r   rO   rD   implicit_argsr   rF   rG   r   r   r8   r   r   nodeinput_value_infosimplicit_value_infosrw   output_value_infosgraphopset_idmodelsession_run_inputr   s   `                    @r#   #_prepare_model_and_inputs_for_eagerr     s^    "'RM3784a&q)4D8BOBUBUBWXBW$!Q2155BWMX
 9B$Hfaj!)FH%fd;K%*;%78%7s|%7G8;;  ffmm TDNN 06  33C4EF 66}7J7J7LM D 	##D$..*:;  
 KK""	/FHZE {{''v7K7KLHKK""j++F,@,@W # E
   --e4E474ET4EytQS4ET]+#V++] 9X I 9  Us(   JJ-J%!J+=J0+J5;J5c                H   SS K nSSKJnJnJn  [        XX#5      u  pn
 UR                  UR                  5       SS9n UR                  S U	5      nU Vs/ s H  n[+        U5      PM     sn$ ! XWU4 aK  n[        SU R                   SU R                   S[        R                  R                  U5       35      UeS nAff = f! [        U4 a  n[        SU R                  < S	U< S
[         R"                  " [%        X5       VVs0 s H  u  pU['        U5      _M     Os  snnf snn5       S[         R"                  " U	R)                  5        VVs0 s H  u  pU['        U5      _M     Os  snnf snn5       S[         R"                  " U	5       SU 35      UeS nAff = fs  snf )Nr   )FailInvalidArgumentInvalidGraph)CPUExecutionProvider)	providersz<Unable to create onnxruntime InferenceSession for executing r&   z op with onnx model
!Unable to execute model operator  due to 
input types:

modified input types:
	
inputs:

)onnxruntime+onnxruntime.capi.onnxruntime_pybind11_stater   r   r   r   InferenceSessionSerializeToStringr   r   rw   r   printerto_textrunr   pprintpformatr   r3   rC   r   )r   rO   rD   r   ortr   r   r   r   r   r8   sessioner9   rF   rG   r   s                    r#   	_call_ortr    s      (Kf($Ef	&&##%1J ' 

T#45 4::6a&q)6::) 0 #]]O1V[[M :  $ 4 4U ;<>
 		 $ /hqe~~c&6GH6Gdaq$q'z6GHIJ'~~6G6M6M6OP6Odaq$q'z6OPQR&..):;<BugG
 	 ;sM   A, C F,B?4AB::B?F6FD3FE('0FFc                H    U R                   U R                  U R                  4$ r   )rw   r   r   )op_schema_or_signatures    r#   _op_identifierr    s)     	##%%,, r;   c                      \ rS rSrSrS rSrg)ORTEvaluatori  &Evaluates ONNX ops using ONNX Runtime.c                    [        XX45      $ r   )r  r   s        r#   r   ORTEvaluator._eval  s    ==r;   r   Nr[   r\   r]   r^   r_   r   r`   r   r;   r#   r  r    s
    0>r;   r  c                      \ rS rSrSrS rSrg)OnnxReferenceRuntimeEvaluatori  r  c                |   [        XX45      u  pVn[        R                  R                  U5      n UR	                  S U5      n	U	 Vs/ s H  n[        U5      PM     sn$ ! [
         a  n
[        SUR                  < SU
< S[        R                  " [        Xr5       VVs0 s H  u  pU[        U5      _M     Os  snnf snn5       S[        R                  " UR                  5        VVs0 s H  u  pU[        U5      _M     Os  snnf snn5       S[        R                  " U5       SU 35      U
eS n
A
ff = fs  snf )Nr   r   r   r   r   r  )r   r   	referenceReferenceEvaluatorr  r   r   rw   r	  r
  r   r3   rC   r   )rM   r   r8   ry   rz   r   r   adapted_inputsr  r9   r  rF   rG   r   s                 r#   r   #OnnxReferenceRuntimeEvaluator._eval  s   3VJ4
0. ..33E:
	[['89F 8>>v!*1-v>>  	 3FKK?(1%">>#n:U"V:U$!1d1g::U"VWX+>>:K:Q:Q:S"T:S$!1d1g::S"TUVfnn->?@5'K 	 ?s5   A D9
D6(6D1B763D1)D0D11D6r   Nr  r   r;   r#   r  r    s
    0?r;   r  c                  P   ^  \ rS rSrSrSU 4S jjrS	S jrU 4S jrS
S jrSr	U =r
$ )ORTMixedEvaluatori,  zEvaluates ONNX ops using ONNX Runtime, unless an overriding python implementation is registered.

This is useful for higher-order ops such as Scan and SequenceMap, allowing for
python-based debugging.
c                0   > [         TU ]  5         0 U l        g r   )superrh   _python_ops)rM   	__class__s    r#   rh   ORTMixedEvaluator.__init__3  s    <>r;   c                2    [        U5      U R                  ;  $ r   )r  r#  r   s     r#   rp   %ORTMixedEvaluator.use_graph_attribute7  s    l+43C3CCCr;   c                   > [        U5      nXPR                  ;   a  U R                  U   " X#5      $ [        TU ]  XX45      $ r   )r  r#  r"  r   )rM   r   r8   ry   rz   
identifierr$  s         r#   r   ORTMixedEvaluator._eval:  s@    #F+
)))##J/CC7=EEr;   c                &   ^ ^ Tc   eSUU 4S jjnU$ )Nc                j   > TU R                      R                  nU TR                  [        U5      '   U $ r   )r[   rl   r#  r  )rT   rl   opsetrM   s     r#   	decorator-ORTMixedEvaluator.register.<locals>.decoratorD  s3     !2!23@@L=ED^L9:Or;   )rT   r   r7   r   r   )rM   r-  r.  s   `` r#   registerORTMixedEvaluator.registerA  s!       	 	
 r;   )r#  )r7   Noner   )r-  zvalues.Opsetr7   zCallable[[_T], _T])r[   r\   r]   r^   r_   rh   rp   r   r0  r`   __classcell__)r$  s   @r#   r   r   ,  s#    ?DF r;   r   )r-  c                   ^ ^ US   nU 4S jmUU 4S jn[        [        T S   5      5       Vs/ s H  oB" U" U5      6 PM     sn$ s  snf )zEvaluates a SequenceMap op.r   c                D   > TU    n[        U[        5      (       a  X!   $ U$ r   )r'   r0   )input_indexiter_numr4   r8   s      r#   get_input_of!SequenceMap.<locals>.get_input_ofT  s'    {#eT""?"r;   c                d   > [        [        T5      5       Vs/ s H  nT" X5      PM     sn$ s  snf r   r   r   )r7  r6  r8  r8   s     r#   	get_inputSequenceMap.<locals>.get_inputZ  s,    GLSQW[GYZGY[3GYZZZs   -r   r;  )r8   ry   funr<  r   r8  s   `    @r#   SequenceMapr?  O  sL     V
C[ +0F1I*?@*?QC)A, *?@@@s   A_default_evaluatorc                     [         $ )z&Returns the default Evaluator default.r@  r   r;   r#   defaultrC  e  s    r;   c                    U q g)z#Sets the current Evaluator default.NrB  )new_defaults    r#   set_defaultrF  j  s
     %r;   c              #  n   #    [         n[        U 5         Sv   [        U5        g! [        U5        f = f7f)z@Context manager that temporarily switches the default evaluator.N)r@  rF  )temp_defaultold_defaults     r#   
default_asrJ  p  s,      %K!K K s   5% 525)r8   r   r7   ztuple[EagerModeValue, bool])rA   r   r7   r   )rD   Mapping[str, Any]r7   zdict[str, Any])r   r   rO   Sequence[Any]rD   rK  r7   r.   )rG   z=np.ndarray | np.generic | list[np.ndarray] | list[np.generic])r   r   rO   rL  rD   rK  r   zOptional[Mapping[str, Any]])r  z)onnx.defs.OpSchema | _schemas.OpSignaturer7   ztuple[str, str, int])r8   rL  ry   rK  )r7   rJ   )rE  rJ   r7   r2  )rH  rJ   )H
__future__r   r   
contextlibr	  typingr   r   r   r   r   r	   r
   r   r   numpyr(   r   	onnx.defsonnx.referenceonnx_irr   typing_extensionsr   
onnxscriptr   r   onnxscript._internalr   r   r   r   onnxscript.irr   r)   r   __annotations__r   r.   r,   r+   r   r   r   r:   r>   rH   rJ   ABCrb   r   r   r   r   r   r   r   r  r  r  r  ort_evaluatorr   ort_mixed_evaluatorr0  opset18r?  r@  rC  rF  contextmanagerrJ  r   r;   r#   <module>r^     sQ   # 
  
 
 
      ' ) L L " "**!5x7P!PQy Q!(?";XFV=W"WX	 X$_ !JJ		  9  T](V8. ! ! !H]DIsww ]DF	\ 	&3=N>,D,6,6,
6, 6, /	6,r+;+;
+; +; /	+;\E>= >?M ?.  @ ()  J$6$67A 8A$ !. I -
% ! !r;   