!ni dZddlZddlZddlZddlZddlZgdZejdZGddZ ddZ dZ d Z d Z d Zd Zdd ZddZddZddZddZddZy)zeThe debug module contains utilities and functions for better debugging Eventlet-powered applications.N) spewunspewformat_hub_listenersformat_hub_timershub_listener_stackshub_exceptionstpool_exceptionshub_prevent_multiple_readershub_timer_stackshub_blocking_detectionformat_asyncio_infoformat_threads_infoz\W+ceZdZddZdZy)SpewNc ||_||_y)N trace_names show_values)selfrrs N/home/homepc/tiktok-worker/venv/lib/python3.12/site-packages/eventlet/debug.py__init__z Spew.__init__s&&c|dk(r|j}d|jvr\|jd}|jds|jdr|dd}|jd}tj||}n*d} t j |\}} | dk(rd } ||| z }|j||jvrt|d |d |j|js|Sg} tj!|} | D]e} | |jvr#| j#| d |j| | |j$vsC| j#| d |j$| g| rtddj'| z|S#t$r)d |jj|jfz}YwxYw)Nline__file__z.pycz.pyo__name__z [unknown]rz,Unknown code named [%s]. VM instruction #%d:z: =z %s )f_lineno f_globalsendswith linecachegetlineinspectgetsourcelinesOSErrorf_codeco_namef_lastirprintrstripr_token_splittersplitappendf_localsjoin) rframeeventarglinenofilenamenamersrcoffsetdetailstokenstoks r__call__z Spew.__call__s F?^^FU__, ??:6%%f- ))&1'}Hz2 ((6:" =")"8"8"?KC{!"v/D'443C3C+CT64;;=AB''K(..t4!MCeoo-#us7K'LMenn,#u~~c7J'KL M &388G#445 !=I ,,emmM==D=s'F.GG)NT)r __module__ __qualname__rr?rrrrs '#rrcBtjt||y)zpInstall a trace hook which writes incredibly detailed logs about what code is being executed to stdout. N)syssettracerrs rrr?sLLk;/0rc.tjdy)z-Remove the trace hook installed by spew. N)rDrErBrrrrFsLLrcPddlm}|j}dg}|jD]}|j t ||j d|j D]}|j t |tjj|S)z Returns a formatted string of the current listeners on the current hub. This can be useful in determining what's going on in the event system, especially when used in conjunction with :func:`hub_listener_stacks`. rhubszREADERS:zWRITERS:) eventletrIget_hub get_readersr1repr get_writersoslinesepr3rIhubresultls rrrLs  ,,.C\F __  d1g MM* __  d1g ::??6 ""rcddl}|j}dg}|jt||jd|jj t jj|S)z Returns a formatted string of the asyncio info. This can be useful in determining what's going on in the asyncio event loop system, especially when used in conjunction with the asyncio hub. rNzTASKS:z EVENTLOOP: ) asyncio all_tasksr1rMeventsget_event_looprOrPr3)rVtasksrSs rr r \s`     EZF MM$u+ MMK = = ?@AB ::??6 ""rcddl}|j}dg}|jt|tj j |S)z Returns a formatted string of the threads info. This can be useful in determining what's going on with created threads, especially when used in conjunction with greenlet rNzTHREADS:) threading_activer1rMrOrPr3)r\threadsrSs rrris< G\F MM$w- ::??6 ""rcddlm}|j}dg}|jD]}|j t |t jj|S)z Returns a formatted string of the current timers on the current hub. This can be useful in determining what's going on in the event system, especially when used in conjunction with :func:`hub_timer_stacks`. rrHzTIMERS:) rJrIrKtimersr1rMrOrPr3rQs rrrusO  ,,.C[F ZZ d1g ::??6 ""rcNddlm}|jj|y)aVToggles whether or not the hub records the stack when clients register listeners on file descriptors. This can be useful when trying to figure out what the hub is up to at any given moment. To inspect the stacks of the current listeners, call :func:`format_hub_listeners` at critical junctures in the application logic. rrHN)rJrIrKset_debug_listeners)staterIs rrrsLLN&&u-rcddlm}||_y)zToggles whether or not the hub records the stack when timers are set. To inspect the stacks of the current timers, call :func:`format_hub_timers` at critical junctures in the application logic. r)timerN) eventlet.hubsre_g_debug)rcres rr r s $ENrc~ddlm}m}ddlm}|s&t ||j r t d||_y)aToggle prevention of multiple greenlets reading from a socket When multiple greenlets read from the same socket it is often hard to predict which greenlet will receive what data. To achieve resource sharing consider using ``eventlet.pools.Pool`` instead. It is important to note that this feature is a debug convenience. That's not a feature made to be integrated in a production code in some sort. **If you really know what you are doing** you can change the state to ``False`` to stop the hub from protecting against this mistake. Else we strongly discourage using this feature, or you should consider using it really carefully. You should be aware that disabling this prevention will be applied to your entire stack and not only to the context where you may find it useful, meaning that using this debug feature may have several significant unexpected side effects on your process, which could cause race conditions between your sockets and on all your I/O in general. You should also notice that this debug convenience is not supported by the Asyncio hub, which is the official plan for migrating off of eventlet. Using this feature will lock your migration path. r)rRrK)rVz5Multiple readers are not yet supported by asyncio hubN)rfrRrKrV isinstanceHub RuntimeErrorg_prevent_multiple_readers)rcrRrKrVs rr r s04+% Z 7;;7RSS%*C"rchddlm}|jj|ddlm}||_y)zToggles whether the hub prints exceptions that are raised from its timers. This can be useful to see how greenthreads are terminating. rrH) greenpoolN)rJrIrKset_timer_exceptionsrnDEBUG)rcrIrns rrrs%LLN''."IOrc ddlm}| |_y)zToggles whether tpool itself prints exceptions that are raised from functions that are executed in it, in addition to raising them like it normally does.r)tpoolN)rJrrQUIET)rcrrs rr r s)EKrcddlm}|dkDsJ||j_||j_|s|jj yy)aToggles whether Eventlet makes an effort to detect blocking behavior in an application. It does this by telling the kernel to raise a SIGALARM after a short timeout, and clearing the timeout every time the hub greenlet is resumed. Therefore, any code that runs for a long time without yielding to the hub will get interrupted by the blocking detector (don't use it in production!). The *resolution* argument governs how long the SIGALARM timeout waits in seconds. The implementation uses :func:`signal.setitimer` and can be specified as a floating-point value. The shorter the resolution, the greater the chance of false positives. rrHN)rJrIrKdebug_blockingdebug_blocking_resolutionblock_detect_post)rc resolutionrIs rr r sI  >>$)DLLN!/9DLLN,  ((* r)NF)F)T)Fr)__doc__rOrDr%rer'__all__compiler/rrrrr rrrr r rr r rBrrr}s|,   " "**V$))X1 # # # #.+B+r