o H h@sddlmZ ddlZddlZddlZddlZddlZddlZddlZddl Z ddlm Z m Z ddl m Z mZmZddlZddlmmZddlmZmZmZmZmZmZmZmZddlmZerhddlmZe e!Z"ej#e!dZ$gd Z%dd l&m'Z(d d Z)Gd ddZ*idej+dej,dej-dej.dej.dej/dej0dej1dej2dej3dej4dej5ddddej6dej7d ej8d!ej9id"ej:d#ej;d$ej<d%ej=d&ej=d'ej>d(ej>d)ej?d*ej@d+ejAd,ed-ed.ed/ed0ed1ejBd2ejBZChd3ZDd4d5ZEd6ZFeFD]&ZGd7eGZHd8eHZIeJe*eHeEeGeKeeIeCeH<eD-eHe%LeHqdhZMeDeMBZNhd9ZOhd:ZPdhZQeOeQBZRhd;ZSdd%hZTdd%d<ZUhd=ZVeFD] ZGd7eGZHeV-eHqmhd>ZWhd?ZXd@dAZYdBdCZZdDdEZ[dFdGZ\dHdIZ]dJdKZ^dLdMZ_dNdOZ`dPdQZadRdSZbdTdUZc VddWdXZddYdZZed[d\ZfedejAej:e\e]e^e_eee`efeYeZe[eaebd]Zgd^d_Zhd`daZidbdcZjdddeZkdfdgZldhdiZmdjdkZndldmZodndoZpdpdqZqdrdsZrdtduZsdvdwZte jue!ZvdxdyZweFD]ZGdzeGZxeweGZyexey_zey_!eJevexeyq[y[G[xd{d|Z{dd}d~Z|ddZ}ddZ~iegid0ejdej+deld#emdend eodepdeqdeidejd,e}dekd$ej<d/erd.esd-etde{e|e~dZeFD]ZGd7eGZHeKevdzeGeeH<q[G[H[F[vddZddZddZddZddZddZddZddZeeeeeedZejejdZddZddZddZddZddZeD] \ZZeeeqeD] \ZZeeeqddZeD];\ZZeeOvreeeqeeSvreeeqeeQvs'eePvr,eeeeeeeeUvr;eeeq[[dS)) annotationsN) lru_cacheupdate_wrapper)Optional TYPE_CHECKINGUnion) sym_floatsym_itesym_maxsym_minsym_notSymBoolSymFloatSymInt)dtrace_structured)ShapeEnvsym_node)SymNodemethod_to_operator magic_methods) py_sym_typescCs(|turtS|tur tS|turtS|SN)boolr intrfloatr)trR/var/www/vscode/kcb/lib/python3.10/site-packages/torch/fx/experimental/sym_node.py _to_symtype:src@s(eZdZUdZdZded<   dddd Zdd dZdddZdddZ e ddZ e ddZ ddZ dddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Zdd:d;Zddd?Zddd@dAZ ddBdCZ!ddDdEZ"ddFdGZ#ddHdIZ$ddJdKZ%ddLdMZ&ddNdOZ'ddPdQZ(ddRdSZ)ddTdUZ*ddVdWZ+ddXdYZ,ddZd[Z-dd\d]Z.dd^d_Z/dd`daZ0ddbdcZ1ddddeZ2ddfdgZ3ddhdiZ4ddjdkZ5ddldmZ6ddndoZ7ddpdqZ8ddrdsZ9ddtduZ:ddvdwZ;ddxdyZdd~dZ?dddZ@dddZAdddZBdddZCdddZDddZEddZFddZGddZHddZIdddZJddZKddZLddZMdddZNdddZOddZPddZQddZRddZSddZTddZUddZVddZWddZXddZYdS)rz This is a type erased SymInt/SymFloat which we use to do actual operations. End users don't touch this. Magic methods are NOT defined on this object. Fr_optimized_summationNhint!Optional[Union[int, float, bool]]c s|_|_|_|_fdd}|durMt||us0t|t|us0Jd|dt|jrLjjrL|} || ksLJ|d| djdn|}|_|_ jo\jj} | o`|_ dS)NcsPddlm}|jr dSjjjdd}|dur&t|ts$|n|}|S)Nr)has_free_unbacked_symbolsT) compute_hint)%torch.fx.experimental.symbolic_shapesr"expr shape_env_maybe_evaluate_static isinstanceSymTypespytype)r"r selfrrr#s  z&SymNode.__init__..compute_hintzCannot create SymNode of type z with incompatible hint of type z != z (for )) _exprr&r*rtyper_translation_validation_enabledr%_hintconstantfx_node) r,r%r&r*r r2r3optimized_summationr# computed_hinttx_validation_enrr+r__init__Vs2    zSymNode.__init__r&rreturncCst|j||j|j|j|jSr)rr.r*r1r2r3)r,r&rrrwith_shape_envszSymNode.with_shape_envothercCs<|j|jko|j|jko|j|jko|j|jko|j|jkSr)r.r*r1r2r3r,r:rrr _value_eqs     zSymNode._value_eqrcCst|j|j|j|j|jfSr)hashr.r*r1r2r3r+rrr _value_hashszSymNode._value_hashcCs|j|jSr)r&replacer.r+rrrr%sz SymNode.exprcCs|jSrr1r+rrrr sz SymNode.hintcCs |jduSrr@r+rrrhas_hint zSymNode.has_hintcs`ddlm}jdur-|dur&|jfddjjD}j|SjjSjS)Nrfree_unbacked_symbolscs&i|]}||vr dnjj|qS)i)r& var_to_val.0sr,unbacked_symbolsrr sz(SymNode.require_hint..)r$rDr1r% free_symbolsxreplacer& size_hint)r,fallbackrD replacementsrrIr require_hints    zSymNode.require_hintcCs|jjr t|jSdSr)r% is_numberrr+rrr maybe_as_ints zSymNode.maybe_as_intcCs$ddl}t|j|jrt|jSdSNr)sympyr(r%Floatrr,rUrrrmaybe_as_floats zSymNode.maybe_as_floatcCs,ddl}|j|jur dS|j|jurdSdS)NrTF)rUr%truefalserWrrr maybe_as_bools   zSymNode.maybe_as_boolcC |jtuSr)r*rr+rrris_intrBzSymNode.is_intcCr\r)r*rr+rrris_floatrBzSymNode.is_floatcCr\r)r*rr+rrris_boolrBzSymNode.is_boolcCs"|jduot|jto|jjSr)r1r(rnode is_nested_intr+rrrras   zSymNode.is_nested_intcC4t|tusJddl}t|||jt|||dSNr)r2r3)r/rrUrIntegerr&r,numrUrrrwrap_int zSymNode.wrap_intcCrbrc)r/rrUrrVr&rerrr wrap_floatrhzSymNode.wrap_floatcCs:t|tusJddl}t|r|jn|j|jt|||dSrc)r/rrUrrYrZr&rerrr wrap_boolszSymNode.wrap_boolcC|Srrr+rrrclone%z SymNode.clonecCs|jSrr%r+rrrstr(z SymNode.strcC|Srror+rrr__str__+rpzSymNode.__str__cCsd|jd|jd|jg}|jdur|d|j|jdur+|d|j|jdur9|d|jd|dS) NzSymNode(z , shape_env=z , pytype=zhint=z constant=zfx_node=z, r-)r.r&r*r1appendr2r3join)r,reprrr__repr__.s   zSymNode.__repr__ builtins.strcCrqrrrr+rrr _graph_repr:szSymNode._graph_reprcCrqr)_absr+rrrabs@rpz SymNode.abscCrqr)_posr+rrrposCrpz SymNode.poscC ||Sr)_roundr,ndigitsrrrroundFrBz SymNode.roundcCrqr)_truncr+rrrtruncIrpz SymNode.trunccCr~r)_addr;rrraddLrBz SymNode.addcCr~r)_subr;rrrsubOrBz SymNode.subcCr~r)_mulr;rrrmulRrBz SymNode.mulcCr~r)_modr;rrrmodUrBz SymNode.modcCr~r) _float_powr;rrr float_powXrBzSymNode.float_powcCr~r)_pow_by_naturalr;rrrpow_by_natural[rBzSymNode.pow_by_naturalcCr~r)_and_r;rrrand_^rBz SymNode.and_cCr~r)_or_r;rrror_arBz SymNode.or_cCr~r)_float_truedivr;rrr float_truedivdrBzSymNode.float_truedivcCr~r) _int_truedivr;rrr int_truedivgrBzSymNode.int_truedivcCr~r) _int_floordivr;rrr int_floordivjrBzSymNode.int_floordivcCr~r)_lshiftr;rrrlshiftmrBzSymNode.lshiftcCr~r)_rshiftr;rrrrshiftprBzSymNode.rshiftcCrqr)_sym_notr+rrrr srpzSymNode.sym_notcCr~r)_eqr;rrreqvrBz SymNode.eqcCr~r)_ner;rrrneyrBz SymNode.necCr~r)_gtr;rrrgt|rBz SymNode.gtcCr~r)_ltr;rrrltrBz SymNode.ltcCr~r)_ler;rrrlerBz SymNode.lecCr~r)_ger;rrrgerBz SymNode.gecCrqr)_floorr+rrrfloorrpz SymNode.floorcCrqr) _is_integerr+rrr is_integerrpzSymNode.is_integercCrqr) _sym_floatr+rrrrrpzSymNode.sym_floatcCrqr)_sym_intr+rrrsym_intrpzSymNode.sym_intcCrqr)_ceilr+rrrceilrpz SymNode.ceilcCrqr)_negr+rrrnegrpz SymNode.negcCr~r)_sym_minr;rrrr rBzSymNode.sym_mincCr~r)_sym_maxr;rrrr rBzSymNode.sym_maxcC |||Sr)_sym_ite)r,then_valelse_valrrrr  zSymNode.sym_itecCrr)_is_contiguousr,sizesstridesrrr is_contiguousrzSymNode.is_contiguouscCrr)_is_channels_last_contiguous_2drrrris_channels_last_contiguous_2drz&SymNode.is_channels_last_contiguous_2dcCrr)_is_channels_last_contiguous_3drrrris_channels_last_contiguous_3drz&SymNode.is_channels_last_contiguous_3dcCrr)_is_channels_last_strides_2drrrris_channels_last_strides_2drz#SymNode.is_channels_last_strides_2dcCrr)_is_channels_last_strides_3drrrris_channels_last_strides_3drz#SymNode.is_channels_last_strides_3dcCrr)'_is_non_overlapping_and_dense_indicatorrrrr&is_non_overlapping_and_dense_indicatorrz.SymNode.is_non_overlapping_and_dense_indicatorcCr~r)rr;rrrsym_orrBzSymNode.sym_orcCr~r)rr;rrrsym_andrBzSymNode.sym_andcCr~r) _bitwise_andr;rrr bitwise_andrBzSymNode.bitwise_andcCr~r) _bitwise_orr;rrr bitwise_orrBzSymNode.bitwise_orcCr~r)rr;rrrtruedivrBzSymNode.truedivcCr~r)rr;rrrfloordivrBzSymNode.floordivcCr~r)rr;rrrpowrBz SymNode.powcCs|||t|dS)N)rrto_noderrrris_non_overlapping_and_densesz$SymNode.is_non_overlapping_and_densecC |ddSNr) guard_intr+rrrint_rz SymNode.int_c Csddl}ddlm}m}|r!t||tjtdd|DfiSdd|D}|j|}g}d}|D]} | j dur<n | | j q3t |}|j tjtdd|Df\} } t||j t|| dS) Nrget_proxy_modehandle_sym_dispatchcss|]}t|VqdSr wrap_noderGarrr sz"SymNode.sym_sum..cSg|]}|jqSrrnrrrr z#SymNode.sym_sum..css|]}|jVqdSrr3rrrrrsr)rU"torch.fx.experimental.proxy_tensorrrrtorchsym_sumtupleAddr rtsumr&_create_fx_call_functionrr) r,argsrUrrexprsout size_hintsout_hintrr3_rrrrs0  zSymNode.sym_sumcCs|j||Sr)r&evaluate_sym_node)r,size_obliviousrrrevaluateszSymNode.evaluatecC0|}zt|WStytd|w)NzFailed to convert to int: %s)rr Exceptionlogwarningr,filelinerrrrr   zSymNode.guard_intcCr)NzFailed to convert to float: %s)rrrrrrrrr guard_float rzSymNode.guard_floatcCr)NFailed to convert to bool: %srrrrrrrrr guard_boolrzSymNode.guard_boolcCsRddlm}|r||js|jjs|||S|jj|j|d||jdS)NrrC:r) r$rDrAr%r&+prefer_deferred_runtime_asserts_over_guardsrdefer_runtime_assertr3)r,rrrDrrr expect_trues  zSymNode.expect_truecCsDddlm}||d}|||}|r |s |t||S)Nr)_advise_is_size)r$r rrgr rAr)r,rrr brrrr expect_size1s    zSymNode.expect_sizecCs4|jdd}zt|WStytd|w)aN Like guard_bool, but if we encounter unbacked symbols, if those symbols are size-like, we will treat them as >= 2 for the purposes of the analysis. This CHANGES the runtime semantics, but all size-oblivious sites have been audited to ensure that the runtime semantics don't change in a material way. Acceptable runtime semantic changes are, e.g., squeeze() no longer dropping an unbacked one size, or a tensor reporting as non-contiguous even if it's contiguous if it would have been reported contiguous due to being empty. T)rrrrrrrguard_size_oblivious?s    zSymNode.guard_size_obliviouscCrr)rr+rrrbool_Srz SymNode.bool_cCdS)NTrr+rrr is_symbolicVrmzSymNode.is_symboliccCsdSrrr+rrr nested_intYrmzSymNode.nested_intcCr)NFrr+rrr is_constant\rmzSymNode.is_constant)NNF)r r!)r&rr8r)r:rr8r)r8rr)r8rx)r8r)F)Z__name__ __module__ __qualname____doc__r__annotations__r7r9r<r>propertyr%r rArQrSrXr[r]r^r_rargrirjrlrorsrwryr{r}rrrrrrrrrrrrrrrr rrrrrrrrrrrrr r r rrrrrrrrrrrrrrrrrrrrr r rrrrrrrrrrGs   R                                                 %    rr}r{randrrrrrrrrrcCrqr)rxrrrnsrrrrrrrrorrrrrrrrr r r r rr> r{rr}rrrrr rcfdd}|S)Ncst|dS)N_sym_)getattrr+namerrfnsz_get_sym_node_fn..fnrr#r$rr"r_get_sym_node_fns r&) sqrtcoscoshsinsinhtantanhasinacosatanlog2sym_r>rrr r >rrr>rrsym_log2r)rr>rrrr>rrrr> rrrrrrrrr rrcCddlm}|||S)Nr) FloatTrueDiv)torch.utils._sympy.functionsr5)rr r5rrr_sympy_float_truediv  r7cCr4)Nr) IntTrueDiv)r6r9)rr r9rrr_sympy_int_truedivr8r:cCr4)Nr)FloorDiv)r6r;)rr r;rrr_sympy_floordivr8r<cCs0ddlm}m}|jr|jr|||S|||S)NrMod PythonMod)r6r>r?is_nonnegative)rr r>r?rrr _sympy_mods   rAcCr4)Nr) PowByNatural)r6rB)rr rBrrr_sympy_pow_by_naturalr8rCcCr4)Nr)FloatPow)r6rD)rr rDrrr_sympy_float_powr8rEcCddl}|||SrT)rUAndrr rUrrr _sympy_and  rIcCrFrT)rUOrrHrrr _sympy_orrJrLcCr4)Nr)LShift)r6rM)rr rMrrr _sympy_lshiftr8rNcCr4)Nr)RShift)r6rO)rr rOrrr _sympy_rshiftr8rPcCst|dkr |gSddlm}m}||d||kr ||gS||d||kr/|g|Sdt|d}}||kra||d}||||}|dkrPdS|dkrY|d}n|d}||ks<||||S)zs If new_arg is found in ordered_args None is returned, else the new ordered_args with new_arg inserted r) _args_sortkeyBasicrN)lensympy.core.basicrQrRcompareinsert) ordered_argsnew_argsort_keyrRlowhighmidcompare_resultrrr_binary_search_insert_arg%s&      r`Fc sddlddlm}fdd}ddlm}|||O}|||O}|rR|rR||jd||jdkr<||j|jS||jd||jdkrR||j|jS|rg|jrgtt|j|}|durg||S|r||jr|tt|j|}|dur|||S ||}|||fS)a Custom optimization for Add used to optimize incremental binary summations of certain properties. The idea is when we know the expression is a summation of unique symbols all we need to know is the correct order of symbols, and no other optimizations are needed. We pass evaluate=false, with the correct order of args and save the following. 1. Avoid running other optimizations when the Add is constructed. 2. Manually figure out the order of the args for the new expression in log(n) comparisons instead of nLog(n) (comparing terms is expensive and shows in the profiles). The function returns a tuple of (1) a boolean that indicates whether the output is a summation of unique symbols, (2) the result sympy expression. rN)rQcsj|ddi}d|fS)NrFT)r)rYresultrUrrmake_optimizedWsz&_optimized_add..make_optimized)_is_symbols_binary_summationrS) rUrVrQr6rd_args is_symbolr`listr) lhsrhslhs_is_optimized_summationrhs_is_optimized_summationsortkeyrcrdnew_argsrarrbr_optimized_addGs*         rncCr4)Nr)BitwiseFn_bitwise_and)r6ro)rr rorrrrxr8rcCr4)Nr)BitwiseFn_bitwise_or)r6rp)rr rprrrr~r8r)rrrrrrrrrrrrrrrcCsddl}t||jr3|j}t|dkr3t|d|jr3|djr3||d}|d|kr3||dSt||jr@|||ksFt||jrK||S||S)NrrTr)rUr(MulrrUrVrrd)rr$rUaacoefrrr_floor_ceil_helpers &     rtcCddlm}||S)Nr) FloorToInt)r6rv)rrvrrr _sympy_floor rwcCru)Nr) TruncToInt)r6ry)rryrrr _sympy_truncrxrzcCru)Nr) CeilToInt)r6r{)rr{rrr _sympy_ceilrxr|cCrFrT)rUEqrHrrr _sympy_eqrJr~cCrFrT)rUNerHrrr _sympy_nerJrcCrFrT)rUGtrHrrr _sympy_gtrJrcCrFrT)rULtrHrrr _sympy_ltrJrcCrFrT)rULerHrrr _sympy_lerJrcCrFrT)rUGerHrrr _sympy_gerJrcCr4)Nr)Min)r6r)rr rrrr _sympy_minr8rcCr4)NrMax)r6r)rr rrrr _sympy_maxr8rcCsddl}|||f|dfS)NrT)rU Piecewise)rrfrUrrr _sympy_itesrcr)Ncs"ddl}t|jjjd|S)NrOpaqueUnaryFn_)r6r!utils_sympy functions)rrr"rrr$sz_get_sym_math_fn..fnrr%rr"r_get_sym_math_fns r_sympy_cCsddl}||SrT)rUAbsrrUrrr _sympy_abss rcCs*ddlm}m}|dur||S|||S)Nr) RoundDecimal RoundToInt)r6rr)numberrrrrrr _sympy_rounds rcCruNr)ToFloat)r6r)rrrrr_sympy_sym_floats rcCs*ddl}ddlm}|||||Sr)rUr6rr}r)rrUrrrr_sympy_is_integers r)rrcCs$t|}t||tt|dddS)NrrS)rUsympy_is_contiguous_genericrgrange)rrdimrrrsympy_is_contiguousFsrcCsddl}t|}t||kr|jS|j}|jj}|D]}|||||jj||||BM}|||9}qt|D]}|||||jjO}q;|SrT) rUrUrZrYSOner}rZero)rr dim_orderrUrrzdrrrrKs ( rcCt||gdSN)rrTrrrrrrr$sympy_is_channels_last_contiguous_2dcrcCrN)rrrTrrrrrr$sympy_is_channels_last_contiguous_3dgrrc Csddl}ddlm}t|}|t|kr|jS|jj}|j}|||ddM}|D]+}||||d|||k@M}|dkrJ||||dM}|||||d}q*|S)Nrrr) rUr6rrUrZrrrYr) rrrrUrrmrrrrr&sympy_is_channels_last_strides_genericks    rcCrrrrrrr!sympy_is_channels_last_strides_2drrcCrrrrrrr!sympy_is_channels_last_strides_3drrcCsddlm}|g||RS)Nr)!IsNonOverlappingAndDenseIndicator)r6r)rrrrrr-_sympy_is_non_overlapping_and_dense_indicators r)rrrrrr)r r cCsVt|tr|jSt|tur||St|tur||St|tur)| |St Sr) r(r)r`r/rrjrrgrriNotImplemented)r,rfrrrrs       rcCsXt|tr |jdur |jS|rt|S|rt|S|r%t|St d|)Nzunrecognized return type ) r(rr2r]rr^rr_r AssertionErrorrrrrrsrcCst|Sr)METHOD_TO_OPERATORmethodrrrrrprc stdtvrd}n}ddd}fdd}|fd d }|fd d }tvr>ttd||dSd krTfdd}ttd||dSdkrkdfdd }ttd||dSttd||dS)Nrr8set[str]cSsJddl}|jj|jj|jjj|g}ddl}dd|D|jj BdhBS)NrcSsh|]}t|qSr)inspectgetfile)rGrrrr z@_make_node_magic..uninteresting_files..z) r_dynamo eval_framerfx experimentalrtorch._dynamo.guardsguardsuninteresting_files)rmodsrrrrs  z-_make_node_magic..uninteresting_filescstdfdd }|S)Ncsj|dur |n||tjjjr3|dur||gn|gd fdd tdfdddS) Nr8 Optional[int]cs`ddl}|jdur dSt|tkrdSt|j|j|jfr!dS|j|j|jfvr,dSt|SrT) rUr2idr(r%rdrVrYrZ)rrU)rarrget_ids zM_make_node_magic..capture_provenance..wrapper..get_idexpression_createdc s@ttddDfddDtdtddS)NcSg|]}t|qSrrrrrrrr zc_make_node_magic..capture_provenance..wrapper....cs g|] }|dur|qSrr)rGi)rrrrsr)rra result_id arguments argument_ids user_stackstack)ror structuredget_user_stackget_framework_stackr)rrrrarrr s  zO_make_node_magic..capture_provenance..wrapper..) metadata_fn)r8r)r_logging _internalGET_DTRACE_STRUCTUREDrr;)r$r)rrrarwrappers    z=_make_node_magic..capture_provenance..wrapperr) functoolswraps)r$rr)r$rcapture_provenances*z,_make_node_magic..capture_provenancec sddlm}m}t}d}|jdur|jdur||j|j}t}|r6|dur6t||t|t|S|rHt|||t|t|fiSt |t sOJd}zTdkrddl m }m } |j} |jjsn| |jjdkr|jjs{| |jjdkr||j|j} n!| |j|j} ndkr|j|j|j|j\}} n|j|j} Wntytd|j|jwtd|j|j| tvrt} ntvrt} n|jtus|jturt} n|j} | dur|durt |ts| |}|j||j |j f\} }t | |j| || |d }|S) NrrFrr=rfailed to eval %s(%s, %s)z%s %s %s -> %s)r3r4)!rrrrr alternate_impl_if_hinted_methodsgetrrr(rr6r>r?r&r%r@ bound_sympylowerrrrr sym_node_logdebugalways_float_magic_methodsralways_bool_magic_methodsrr*r)rr3)r,r:rropralternate_implr4r>r?r&rr*r3rrafuncrrrbinary_magic_impls      z+_make_node_magic..binary_magic_implc sddlm}m}t}|rt|||t|fiS|j}dks&dkr,|j|}z|}Wnt yAt d|wt d||d}|jdurV||j}tvr]t}ntvrdt}n tvrkt}n|j}|j||jf\}} t||j|||dS)Nrrrceilingzfailed to eval %s(%s)z %s %s -> %sr)rrrrrrr%r&_simplify_floor_divrrrrrr always_int_magic_methodsrrrrrr*rr3r) r,rrrr%rrr*r3rrrrunary_magic_implys4     z*_make_node_magic..unary_magic_implr c sddlm}m}|jr|jn|j}|r&t||tt|t|t|fiSz |j|j|j}WntyEt d|j|j|jw|j t|j |j |j f\}}t||j |j||dS)Nrrzfailed to eval %s(%s, %s, %s)r)rrrr rr rr%rrrr&rr3rr*) pred_node then_node else_noderrrrr3rrrr sym_ite_impls@   z&_make_node_magic..sym_ite_implrc sddlm}m}tj}|rt|||t||fiS|j}z||}Wnty5t d||w|dur=t }n|j }d}|j durM||j |}|jg} |durZ| ||j|t| \} } t||j||| dS)Nrrz!failed to eval %s(%s, ndigits=%s)r)rrrbuiltinsrrrr%rrrrr*r r3rtr&rrr) r,rrrrr%rr*rrr3rrrr round_impls0     z$_make_node_magic..round_impl)r8rr)r2magic_methods_on_operator_with_trailing_underscore unary_methodssetattrr) rr method_attrrrrrrrrrr_make_node_magics&    .^$()rcsXfdd}ttd|fdd}ttjts*ttjt|dSdS)Nc sddlm}m}ttjt}|r(t|||dd|Ddd|DfiSdd|D}dd|D}z||}WntyMt d||wg} d} |D]} | j dur]n | | j qTg} |D]} | j durqn | | j qh|| | }  drt} nt} t||j| | S) NrrcSrrrrFrrrr rzH_make_node_sizes_strides..sizes_strides_impl..cSrrrnrFrrrrrcSrrrnrFrrrrrr _indicator)rrrr!sysmodulesrrrrrr rtendswithrrrr&)r,rrrrr size_exprs stride_exprsrrrrH stride_hintsr*rrrsizes_strides_implsF     z4_make_node_sizes_strides..sizes_strides_implrcsddlddlm}t||D]"ttr2ttj fdd|Dfdd|DSqdkr<|||St fdd|Dfdd|DS) Nr)!eval_is_non_overlapping_and_densecg|]}tj|qSrrr`rGr rrrr>zH_make_node_sizes_strides..sizes_strides_user..cr rrrrrrr?rrcg|]}|qSrsympifyrrbrrrHrcrrrrrbrrrIr) rUr$r  itertoolschainr(rrr!r`r)rrr rrrsizes_strides_user3s&    z4_make_node_sizes_strides..sizes_strides_user)rrhasattrrrr)rrr rrrr_make_node_sizes_stridess 0rc stvr dndddddtvrdd nd d fd d fd d}fdd}fdd}tvrXt|dd|dStvrlt|}t|t||dSdkrfdd}t|dd|dSdkrdfdd }t|dd|dS}tvrt}t|d|d|tvrt|d|d|dSdS)Nr2r2Union[SymInt, int, SymFloat, float, SymBool, bool]cSs4t|tttfr |St|tr|jddStd)Nrrz*expect to be called with constant SymBools)r(rrrr r`rrrrrr get_constantbs  z&_make_user_magic..get_constantcSs2t|tttfr dSt|tttfr|jSdS)NTF) r(rrrrrr r`rrrrrris  z%_make_user_magic..is_constantcSs"t|trt|jt|S|S)z;Implements True+True=2, which works in python but not sympy)r(r rr`rgrrrrrpromotes z!_make_user_magic..promotecSrkrrrrrrrrmcs\dvr||fSt|ttjf}t|ttjf}|s|r*|s#t|}|s*t|}||fS)N)rrrrrrrr r rrrrrr)r(rrrr)r,r:f_selff_otherrrrpromote2s  z"_make_user_magic..promote2cs2|}|rt|Stt|jSr)rrr!r`r+)rrrrrrrrsz*_make_user_magic..unary_magic_implcst|ttttttfs tSt d|||}|}||\}}|r1t ||S|r9|}t |j |}|turEtSt t|j |}|rW|S|S)NzMAGIC %s %s %s)r(rrrrrr rrrrrr`rr!r,r: other_noderetrrrrrrrrrs z+_make_user_magic..binary_magic_implcst|ttttttfs tS|}|}||\}}|r)t||S|r1|}t |j |}|tur=tSt t ||j }|rO|S|Sr) r(rrrrrr rrrr`rr!r r#rrrbinary_magic_impls z,_make_user_magic..rbinary_magic_impl__r cs~|j}t||}t||}|tus|turtSt|tr't|tr'|j|jks)Jtt|j||}|jr=|S|Sr) r`rrr(rr*rr!r)predrrrrrr")rrrrsym_ite_magic_impls  z,_make_user_magic..sym_ite_magic_implrcs,|r t||Stt|j|Sr)rrrr!r`r)rrrrrround_magic_implsz*_make_user_magic..round_magic_impl__r)rrr) rbool_becomes_int_magic_methodsunary_magic_methodsrunary_nonmagic_methodsr!r bitwise_opsreflectable_magic_methods) r user_typerrr$origr'r( method_namerr#r_make_user_magicYs<  !  * r2)FFr) __future__rrrrrloggingmathoperatorrrrtypingrrrrtorch._logging.structuredrrrr r r r r rrtorch._loggingrr$r getLoggerrrgetArtifactLoggerr__all__ torch.typesrr)rrr}r{rrrrrrrrrrrrrrrrrrrrrrrr+r& math_op_namesr#sym_name priv_sym_namerr!rtr,ronly_bool_magic_methodsr*also_bool_magic_methodsbool_magic_methodsonly_float_magic_methodsrr-rrrr7r:r<rArCrErIrLrNrPr`rnrrr.rtrwrzr|r~rrrrrrrrrcurrent_modulerpriv_sympy_namer$rrrrrinvertrrrrrrrrrsizes_strides_methodsminmaxrrrrrritemsrrr2rrrrs  (           !"%     # 1           (  *W8