qiCdZddlZddlmZmZmZmZmZmZddl m Z m Z m Z ddl mZmZmZddlmZddlmZdd lmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(dd lm)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1dd l2m3Z3dd l4m5Z5dd l6m7Z7ddl8m9Z9ddl:m;Z;mZ>m?Z?m@Z@ddlAmBZCgdZDejjejj&jgejejjurUddlKZejeje_IejjjejdddZPddZQdeRfdZSdeRddfdZTy)a TorchDynamo is a Python-level JIT compiler designed to make unmodified PyTorch programs faster. TorchDynamo hooks into the frame evaluation API in CPython (PEP 523) to dynamically modify Python bytecode right before it is executed. It rewrites Python bytecode in order to extract sequences of PyTorch operations into an FX Graph which is then just-in-time compiled with a customizable backend. It creates this FX Graph through bytecode analysis and is designed to mix Python execution with compiled backends to get the best of both worlds: usability and performance. This allows it to seamlessly optimize PyTorch programs, including those using modern Python features. N) aot_compileconfig convert_frame eval_framefunctional_exportresume_execution) list_backendslookup_backendregister_backend)callback_handleron_compile_endon_compile_start) code_context)replay)allow_in_graphassume_constant_resultdisabledisable_nested_graph_breaksdisallow_in_graphdont_skip_tracingerror_on_graph_breakforbid_in_graph graph_breakis_dynamo_disable_recursive mark_dynamic mark_staticmark_static_addressmaybe_mark_dynamicnonstrict_tracepatch_dynamo_configrun set_stance skip_framestep_unsupportedsubstitute_in_graph) _reset_guarded_backend_cacheexplainexportis_dynamo_supportedis_inductor_supportedoptimizeoptimize_assertOptimizedModule reset_code) is_compiling)GenerationTracker)reset_code_state)TensorifyState)graph_break_reasonsguard_failures orig_code_map(register_hook_for_recompile_user_contextreset_frame_countreset_recompile_user_contexts)loader)#rrrrrrrr)r(rrr0rr r rrrrr r,r-r.r!r rresetr9r"rset_recursion_limitr#r$r%r&zaten::manual_seedreturncddl}|jt}|jdtj 5t tjjttjjtjtjtjtjj jt#t%t&j(j*j-dt_tj0jt3jt5jt7jt&j(j8j:jt&j<j>jAddddy#1swYyxYw)a Clear all compile caches and restore initial state. This function is intended to reset Dynamo's state *as if* you had started a fresh process invocation, which makes it good for testing scenarios where you want to behave as if you started a new process. It does NOT affect any file system caches. NB: this does NOT reset logging state. Don't use this to test logging initialization/reinitialization. rNztorch._dynamo.resetF)!logging getLogger__name__infor compile_lockreset_code_caches input_codesclearr2 output_codesr6r5r4r ContinueExecutionCachecacher'r8torch_dynamocompiled_autogradr; FRAME_COUNTERFRAME_COMPILE_COUNTERr r1r3utilswarn_once_cache_C _autograd _saved_tensors_hooks_set_tracing)r?logs \/home/ubuntu/crypto_trading_bot/.venv/lib/python3.12/site-packages/torch/_dynamo/__init__.pyr;r;sF   H %CHH "#  # #C!!'')""((*!!#//55;;=$& ''--/&' #++113 ! ++113 ;;EB%CCCs F1G55G>c~ddl}|jt}|jd tj 5t tjjtjjzD]}|}|s t|tjdddy#1swYyxYw)z Clears in-memory code cache, which is what stores compiled products. This resets less state than :func:`reset` and is mostly only used for testing purposes. rNztorch._dynamo.reset_code_caches) r?r@rArBrrCr2rEseenrGr/rrF)r?rT weak_codecodes rUrDrDs   H %CHH ./=  # #  % % * *]-G-G-L-L L !I;D4  ! sA B3 !B33B<cftjjjj S)z Returns the internal dynamo recursion limit set by `torch._dynamo.set_recursion_limit`. Returns -1 if no c recursion limit has been set. )rJrQrKrget_c_recursion_limitrUget_recursion_limitr^s# 88   & & < < >>r]limitcjtjjjj |y)a Sets an internal dynamo recursion limit. The limit must be >= 1, or -1 to reset to the default (unset) state. This is possibly needed in Python 3.12-3.13 since there is a separate C recursion limit that is not visible at the Python level. If you are getting RecursionErrors during Dynamo compilation and `sys.setrecursionlimit()` doesn't help, this function may alleviate the issue. NOTE: this function does NOT call `sys.setrecursionlimit()` - the user is expected to manually call this if required. This is because the 2 recursion limits are not sync'd up - e.g. in Python 3.12, functions can be inline-evaluated, which apparently doesn't use up the C stack. WARNING: increasing the recursion limit to an arbitrary large value may cause segfaults due to stack overflows! You can try also try to manually increase the stack size, e.g. with `$ ulimit -s ...` N)rJrQrKrset_c_recursion_limit)r_s rUr<r<s"$ HH55erys- ONHH&!.   )-!,#$ N$$emm&>&>&H&H%IJ 000.--e.?.?@E II))%*;*;=PQ!CH.?S?=s=t=r]