o >hY@s\dZddlmZddlZddlZddlZddlZddlZddlm Z ddlm Z ddl m Z ddl mZmZmZddlmZdd lmZdd lmZed ed efd ZdadZGdddeZd-ddZdZGdddeZddZ GdddZ!GdddZ"GdddZ#gZ$d.d!d"Z%Gd#d$d$e&Z'd%d&Z(d'Z)dddd(e'j*fd)d*Z+d+d,Z,dS)/z9 Asynchronous-friendly error mechanism. See L{Failure}. ) annotationsN)partial)getmro)StringIO)CallableNoReturnTypeVar)Version)reflect)deprecatedProperty _T_Callable.)boundc@s eZdZdS)DefaultExceptionN)__name__ __module__ __qualname__rrv/var/www/vedio/testing/chatpythonscript.ninositsolution.com/env/lib/python3.10/site-packages/twisted/python/failure.pyr&srdefaultc Csx|dvr td|f|}|dkr*|D]\}}}}}||d|d|dqdS|dkrT|D]!\}}}}}|d|d|d |d|d t||q0dS|d krq|D]\}}}}}|d |||fqZ|d dS|dkr|D]B\}}}}}|d |||f|d|D]\} } |d| dt| dq|d|D]\} } |d| dt| dqqwdSdS)a Format and write frames. @param frames: is a list of frames as used by Failure.frames, with each frame being a list of (funcName, fileName, lineNumber, locals.items(), globals.items()) @type frames: list @param write: this will be called with formatted strings. @type write: callable @param detail: Four detail levels are available: default, brief, verbose, and verbose-vars-not-captured. C{Failure.printDetailedTraceback} uses the latter when the caller asks for verbose, but no vars were captured, so that an explicit warning about the missing data is shown. @type detail: string )rbriefverboseverbose-vars-not-capturedzNDetail must be default, brief, verbose, or verbose-vars-not-captured. (not %r)r: rz File "z", line z, in z %s rz%s:%d: %s(...) zA [Capture of Locals and Globals disabled (use captureVars=True)] rz [ Locals ] z z : z ( Globals ) N) ValueError linecachegetlinestriprepr) frameswritedetailwmethodfilenamelineno localVars globalVarsnamevalrrr format_frames*s@   r+z--- ---c@seZdZdZdS)NoCurrentExceptionErrorz Raised when trying to create a Failure from the current interpreter exception state and there is no current exception state. N)rrr__doc__rrrrr,\sr,cCsbt|dks Jdd}t|d|}t|}}|ddD]}t||}t||_|j}q|S)z Construct a fake traceback object using a list of frames. It should have the same API as stdlib to allow interaction with other tools. @param tbFrames: [(methodname, filename, lineno, locals, globals), ...] rzMust pass some framesN)len_Frame_TracebackFrametb_next)tbFramesstackfirstTbtbsfrrr _Tracebackcs    r8c@eZdZdZddZdS)r1zq Fake traceback object which can be passed to functions in the standard library L{traceback} module. cCs ||_|j|_|j|_d|_dS)z- @param frame: _Frame object N)tb_framef_lineno tb_linenof_lastitb_lastir2)selfframerrr__init__s z_TracebackFrame.__init__Nrrrr-rArrrrr1s r1c@r9)r0aD A fake frame object, used by L{_Traceback}. @ivar f_code: fake L{code} object @ivar f_lineno: line number @ivar f_globals: fake f_globals dictionary (usually empty) @ivar f_locals: fake f_locals dictionary (usually empty) @ivar f_back: previous stack frame (towards the caller) cCs`|\}}}}}t|||_||_t|pi|_t|pi|_||_d|_tt  |_ d|_ dS)z @param frameinfo: (methodname, filename, lineno, locals, globals) @param back: previous (older) stack frame @type back: C{frame} rN) _Codef_coder;dict f_globalsf_localsf_backr=varsbuiltinscopy f_builtinsf_trace)r? frameinfobackr)r%r&localzglobalzrrrrAs  z_Frame.__init__NrBrrrrr0s r0c@s eZdZdZddZddZdS)rCz A fake code object, used by L{_Traceback} via L{_Frame}. It is intended to have the same API as the stdlib code type to allow interoperation with other tools based on that interface. cCsd||_||_d|_d|_d|_g|_d|_d|_d|_d|_ d|_ d|_ d|_ d|_ d|_d|_dS)Nrr)co_name co_filename co_lnotabco_firstlineno co_argcount co_varnamesco_code co_cellvars co_constsco_flags co_freevarsco_posonlyargcountco_kwonlyargcountco_names co_nlocals co_stacksize)r?r)r%rrrrAs  z_Code.__init__cCsdS)N))NNNNrr?rrr co_positionssz_Code.co_positionsN)rrrr-rArdrrrrrCs rCfreturncCst|j|S)a Mark the given callable as extraneous to inlineCallbacks exception reporting; don't show these functions. @param f: a function that you NEVER WANT TO SEE AGAIN in ANY TRACEBACK reported by Failure. @type f: function @return: f )_inlineCallbacksExtraneousappend__code__)rerrr _extraneouss rjc@s4eZdZdZdZdZdBddZeddZej d dZe e d d d dd dZ e j ddZ eddZ e j ddZ ddZedCddZddZddZdDdd Zed!d"ZdEd$d%ZdEd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1ZdEd2d3ZdEd4d5ZdFdGd:d;ZdHdd?Z!dId@dAZ"dS)JFailurea A basic abstraction for an error that has occurred. This is necessary because Python's built-in error mechanisms are inconvenient for asynchronous communication. The C{frame} attribute contain the traceback frames. Each frame is a tuple of (funcName, fileName, lineNumber, localsItems, globalsItems), where localsItems and globalsItems are the contents of C{locals().items()}/C{globals().items()} for that frame, or an empty tuple if those details were not captured. Local/global variables in C{frame} will only be captured if C{captureVars=True} when constructing the L{Failure}. @ivar value: The exception instance responsible for this failure. @ivar type: The exception's class. @ivar stack: Deprecated, always an empty list. Equivalent information can be extracted from C{import traceback; traceback.extract_stack(your_failure.tb)} @ivar frames: list of frames, innermost first. rNFcCstdat|_d|_|_}||_|dur(t\|_|_}|jdur'tn|dur?t|tr6|j |_nt||_||_n||_||_t|jt rS| |jdS|durg|r\|}n t |jddrg|jj }||_dS)a- Initialize me with an explanation of the error. By default, this will use the current C{exception} (L{sys.exc_info}()). However, if you want to specify a particular kind of failure, you can pass an exception as an argument. If no C{exc_value} is passed, then an "original" C{Failure} will be searched for. If the current exception handler that this C{Failure} is being constructed in is handling an exception raised by L{raiseException}, then this C{Failure} will act like the original C{Failure}. For C{exc_tb} only L{traceback} instances or L{None} are allowed. If L{None} is supplied for C{exc_value}, the value of C{exc_tb} is ignored, otherwise if C{exc_tb} is L{None}, it will be found from execution context (ie, L{sys.exc_info}). @param captureVars: if set, capture locals and globals of stack frames. This is pretty slow, and makes no difference unless you are going to use L{printDetailedTraceback}. r.N __traceback__)counttypevalue captureVarssysexc_infor, isinstance Exception __class__rk _extrapolategetattrrlr6)r? exc_valueexc_typeexc_tbrpr6rrrrAs2       zFailure.__init__cCst|dr|jSg}|_|j}|durb|j}|jrH|j}|j|jur(i}n|j}||fD] }d|vr:|d=q1t| }t| }nd}}| |j j |j j |j||f|j}|dus|S)N_frames __builtins__r)hasattrr{r6r:rprGrKrFlistitemsrhrDrSrTr<r2)r?r r6rerPrQdrrrr 8s:        zFailure.framescC ||_dSN)r{)r?r rrrr [ Twisted cCsgSrrrcrrrr4_sz Failure.stackcCs~dSrr)r?r4rrrr4cscCsZ|jdur|jSt|jr%t|jtr%t|j}ttt j ||_|jS|jg|_|jSr) _parentsinspectisclassrn issubclassrtrr~mapr qual)r?parentCsrrrparentsgs   zFailure.parentscCrr)r)r?rrrrrsrcCst|j|_dS)a, Extrapolate from one failure into another, copying its stack frames. @param otherFailure: Another L{Failure}, whose traceback information, if any, should be preserved as part of the stack presented by this one. @type otherFailure: L{Failure} N)rK__dict__)r? otherFailurerrrrvws zFailure._extrapolatero BaseExceptionrfcCs6tt}td7ad|_t|_||_|j|_d|_|S)z Create a L{Failure} for an exception without a traceback. By restricting the inputs significantly, this constructor runs much faster. r.FN)rk__new__rmrprorurnr6)roresultrrr_withoutTracebacks zFailure._withoutTracebackcGs|j|}|s ||S)a Trap this failure if its type is in a predetermined list. This allows you to trap a Failure in an error callback. It will be automatically re-raised if it is not a type that you expect. The reason for having this particular API is because it's very useful in Deferred errback chains:: def _ebFoo(self, failure): r = failure.trap(Spam, Eggs) print('The Failure is due to either Spam or Eggs!') if r == Spam: print('Spam did it!') elif r == Eggs: print('Eggs did it!') If the failure is not a Spam or an Eggs, then the Failure will be 'passed on' to the next errback. In Python 2 the Failure will be raised; in Python 3 the underlying exception will be re-raised. @type errorTypes: L{Exception} )checkraiseException)r? errorTypeserrorrrrtraps z Failure.trapcGsB|D]}|}t|rt|trt|}||jvr|SqdS)a Check if this failure's type is in a predetermined list. @type errorTypes: list of L{Exception} classes or fully-qualified class names. @returns: the matching L{Exception} type, or None if no match. N)rrrrtr rr)r?rrerrrrrrs  z Failure.checkrcCs|j|j)zf raise the original exception, preserving traceback information if available. )rowith_tracebackr6rcrrrrszFailure.raiseExceptioncCs||j|jS)aJ Throw the original exception into the given generator, preserving traceback information if available. @return: The next value yielded from the generator. @raise StopIteration: If there are no more values in the generator. @raise anything else: Anything that the generator raises. )throwrorr6)r?grrrthrowExceptionIntoGenerators z#Failure.throwExceptionIntoGeneratorstrcCs"dt|jt|j|S)Nz <{} {}: {}>)formatr rrurngetErrorMessagercrrr__repr__s   zFailure.__repr__cCs d|S)Nz[Failure instance: %s])getBriefTracebackrcrrr__str__s zFailure.__str__cCs>d|vr |d|d|d<|d|d<|j|dS)Nr4rrr r{)poprupdater?staterrr __setstate__s  zFailure.__setstate__cCsr|j}|j}|d|d<g|d<d|vr|d|jr*dd|jD|d<n|j|d<d|d <d |d <|S) z Avoid pickling objects in the traceback. This is not called direclty by pickle, since C{BaseException} implements reduce; instead, pickle calls C{Failure.__reduce__} which then calls this API. rrr4r{c Ss6g|]}|d|d|dt|dt|dgqS)rr.r) _safeReprVars).0vrrr s  z(Failure.__getstate__..r Nr6r.pickled)rrrKrrpr )r?_crrr __getstate__s   zFailure.__getstate__cCsttjtd|fS)Nr)rrkrrrcrrr __reduce__szFailure.__reduce__cCs:|}|d|d<||_t|jddrd|j_dSdS)z Remove references to other objects, replacing them with strings. On Python 3, this will also set the C{__traceback__} attribute of the exception instance to L{None}. r r{rlN)rrrrwrorlrrrr cleanFailures  zFailure.cleanFailurecCs,|jdur|jSt|jdkrt|jSdS)a Get an object that represents this Failure's stack that can be passed to traceback.extract_tb. If the original traceback object is still present, return that. If this traceback object has been lost but we still have the information, return a fake traceback object (see L{_Traceback}). If there is no traceback information at all, return None. Nr)r6r/r r8rcrrrgetTracebackObject!s  zFailure.getTracebackObjectcCs"t|jtr |jSt|jS)zJ Get a string of the exception which caused this Failure. )rsrorkrr safe_strrcrrrr2s   zFailure.getErrorMessagecCst}|j|d|S)N)file)rprintBriefTracebackgetvalue)r?iorrrr:s zFailure.getBriefTracebackrelideFrameworkCodeintr"cCst}|j|||d|S)N)rrr")rprintTracebackr)r?rr"rrrr getTraceback?s zFailure.getTracebackcCs8|dur ddlm}|j}|j}|dkr|jsd}n|}|dkr/|d|j|jr)dp*dfn"|d krM|jr9d }nd }|d |t |j t |j fn|d |jr\t |j||n|d ksd|d|d ksz|t |j dt |j dt|j tr|d|j ||||dkr|d|jdSdS)a Emulate Python's standard error reporting mechanism. @param file: If specified, a file-like object to which to write the traceback. @param elideFrameworkCode: Deprecated, ignored. @param detail: A string indicating how much information to include in the traceback. Must be one of C{'brief'}, C{'default'}, or C{'verbose'}. Nr)logrrz*--- Failure #%d%s--- z (pickled)  r Tracebackz"Traceback (failure with no frames)z %s: %s: %s z#Traceback (most recent call last): z Failure: z: rz (chained Failure) z*--- End of Failure #%d --- )twisted.pythonrlogerrr!rprmrr r rrnror+rrsrkr)r?rrr"rr# formatDetail hasFramesrrrrFsF $  zFailure.printTracebackcC|j||dddS)z; Print a traceback as densely as possible. rr"Nrr?rrrrrrzFailure.printBriefTracebackcCr)zQ Print a traceback with detailed locals and globals information. rrNrrrrrprintDetailedTracebackrzFailure.printDetailedTraceback)NNNF)rorrfrk)rfr)rfr)rr)rrr"rrfr)NFr)Nr)#rrrr-rrrApropertyr setterr r r4rrv staticmethodrrrrrjrrrrrrrrrrrrrrrrrrrksL 9 "         (     ArkcCsdd|DS)aq Convert a list of (name, object) pairs into (name, repr) pairs. L{twisted.python.reflect.safe_repr} is used to generate the repr, so no exceptions will be raised by faulty C{__repr__} methods. @param varsDictItems: a sequence of (name, value) pairs as returned by e.g. C{locals().items()}. @returns: a sequence of (name, repr) pairs. cSsg|] \}}|t|fqSr)r safe_repr)rr)objrrrrsz!_safeReprVars..r) varsDictItemsrrrrs rTFc Cs|||fdkr:t}|d|jks:tr:zt|d}Wn ty'd}Ynwtd|ddl}| |d||||||dS)z; Initialize failure object, possibly spawning pdb. )NNNrr.z broken strz8Jumping into debugger for post-mortem of exception '{}':Nr) rqrrruDO_POST_MORTEMrrprintrpdb post_mortem) r?rxryrzrpFailure__init__excstrreprrrrr _debuginits   rcCs tt_dS)z* Enable debug hooks for Failures. N)rrkrArrrrstartDebugModes r)r)rer rfr )-r- __future__rrJrKrrrq functoolsrrrrtypingrrr incrementalr rr twisted.python.deprecater objectr rm traceupLengthrtrr+EXCEPTION_CAUGHT_HEREr,r8r1r0rCrgrjrrkrrrArrrrrrsP        /! 6