U P|jY@sbdZddlmZddlZddlZddlZddlZddlZddlm Z ddlm Z ddl m Z ddl mZmZmZddlmZdd lmZdd lmZed ed efd ZdadZGdddeZd,ddZdZGdddeZddZ GdddZ!GdddZ"GdddZ#gZ$d d dd 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__rr:/tmp/pip-unpacked-wheel-audpp6lv/twisted/python/failure.pyr&srdefaultc Csv|dkrtd|f|}|dkrT|D](\}}}}}||d|d|dq&n|dkr|D]B\}}}}}|d|d|d |d|d t||q`n|d kr|D] \}}}}}|d |||fq|d n|dkrr|D]\}}}}}|d |||f|d|D]$\} } |d| dt| dq|d|D]$\} } |d| dt| dqJqdS)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) frameswritedetailwmethodfilenamelinenoZ localVarsZ globalVarsnamevalrrr format_frames*s6     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|dkstdd}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)lenAssertionError_Frame_TracebackFrametb_next)ZtbFramesstackZfirstTbtbZsfrrr _Tracebackcs    r4c@seZdZdZddZdS)r0zq 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_lastir1)selfframerrr__init__sz_TracebackFrame.__init__Nrrrr+r<rrrrr0sr0c@seZdZdZddZdS)r/aD 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|p(i|_t|p6i|_||_d|_tt  |_ d|_ dS)z @param frameinfo: (methodname, filename, lineno, locals, globals) @param back: previous (older) stack frame @type back: C{frame} rN) _Codef_coder6dict f_globalsf_localsf_backr8varsbuiltinscopy f_builtinsf_trace)r: frameinfobackr'r%r&localzglobalzrrrr<s z_Frame.__init__Nr=rrrrr/s r/c@s eZdZdZddZddZdS)r>z 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%rrrr<s z_Code.__init__cCsdS)N))NNNNrr:rrr co_positionssz_Code.co_positionsN)rrrr+r<r_rrrrr>sr>)freturncCst|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__)r`rrr _extraneouss rec@sVeZdZdZdZdZdAddZeddZej d dZe e d d d dd dZ e j ddZ eddZ e j ddZ ddZedddddZddZddZdddd Zed!d"Zd#dd$d%Zd#dd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd#dd2d3Zd#dd4d5ZdBd7d#d#d8d9d:ZdCd;d<Z dDd=d>Z!dEd?d@Z"dS)FFailurea 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|_|_}||_|dkrPt\|_|_}|jdkrtn:|dkr~t|trl|j |_n t||_||_n ||_||_t|jt r| |jdS|dkr|r|}nt |jddr|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__rf _extrapolategetattrrgr3)r: exc_valueexc_typeexc_tbrkr3rrrr<s0      zFailure.__init__cCst|dr|jSg}|_|j}|dk r|j}|jr|j}|j|jkrPi}n |j}||fD]}d|krb|d=qbt| }t| }nd}}| |j j |j j |j||f|j}q |S)N_frames __builtins__r)hasattrrvr3r5rkrBrFrAlistitemsrcr?rNrOr7r1)r:r r3r`rKrLdrrrr 8s6        zFailure.framescCs ||_dSN)rv)r:r rrrr [sZTwisted cCsgSr|rr^rrrr2_sz Failure.stackcCs~dSr|r)r:r2rrrr2cscCsV|jdk r|jSt|jrFt|jtrFt|j}ttt j ||_n |jg|_|jSr|) _parentsinspectisclassri issubclassrorrymapr qual)r:ZparentCsrrrparentsgs   zFailure.parentscCs ||_dSr|)r)r:rrrrrsscCst|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)rF__dict__)r:Z otherFailurerrrrqws zFailure._extrapolate BaseException)rjracCs6tt}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)rf__new__rhrkrjrprir3)rjresultrrr_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]8}|}t|r*t|tr*t|}||jkr|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)rrrror rr)r:rrerrrrrrs   z Failure.checkr)racCs|j|jdS)zf raise the original exception, preserving traceback information if available. N)rjwith_tracebackr3r^rrrrszFailure.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. )throwrjrr3)r:grrrthrowExceptionIntoGenerators z#Failure.throwExceptionIntoGeneratorstrcCs"dt|jt|j|S)Nz <{} {}: {}>)formatr rrprigetErrorMessager^rrr__repr__s   zFailure.__repr__cCs d|S)Nz[Failure instance: %s])getBriefTracebackr^rrr__str__szFailure.__str__cCs>d|kr|d|d|d<|d|d<|j|dS)Nr2rrr rv)poprupdater:staterrr __setstate__s  zFailure.__setstate__cCsr|j}|j}|d|d<g|d<d|kr8|d|jrTdd|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. rrr2rvc Ss6g|].}|d|d|dt|dt|dgqS)rr,r) _safeReprVars).0vrrr s  z(Failure.__getstate__..r Nr3r,pickled)rrrFrrkr )r:_crrr __getstate__s    zFailure.__getstate__cCsttjtd|fS)Nr)rrfrrr^rrr __reduce__szFailure.__reduce__cCs6|}|d|d<||_t|jddr2d|j_dS)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 rvrgN)rrrrrrjrgrrrr cleanFailures zFailure.cleanFailurecCs0|jdk r|jSt|jdkr(t|jSdSdS)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)r3r-r r4r^rrrgetTracebackObject!s  zFailure.getTracebackObjectcCs"t|jtr|jSt|jS)zJ Get a string of the exception which caused this Failure. )rnrjrfrr safe_strr^rrrr2s  zFailure.getErrorMessagecCst}|j|d|S)N)file)rprintBriefTracebackgetvalue)r:iorrrr:s zFailure.getBriefTracebackrint)elideFrameworkCoder"racCst}|j|||d|S)N)rrr")rprintTracebackr)r:rr"rrrr getTraceback?szFailure.getTracebackcCs8|dkrddlm}|j}|j}|dkr4|js4d}n|}|dkr^|d|j|jrRdpTdfnD|d kr|jrrd }nd }|d |t |j t |j fn|d |jrt |j||n|d ks|d|d ks|t |j dt |j dt|j tr|d|j ||||dkr4|d|jdS)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.pythonrZlogerrr!rkrhrr r rrirjr)rrnrfr)r:rrr"rr#Z formatDetailZ hasFramesrrrrFsD  $  zFailure.printTracebackcCs|j||dddS)z; Print a traceback as densely as possible. rr"Nrr:rrrrrrszFailure.printBriefTracebackcCs|j||dddS)zQ Print a traceback with detailed locals and globals information. rrNrrrrrprintDetailedTracebackszFailure.printDetailedTraceback)NNNF)rr)NFr)Nr)Nr)#rrrr+rrr<propertyr setterr r r2rrq staticmethodrrrrrerrrrrrrrrrrrrrrrrrrfsJ 9 "       ( A rfcCsdd|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 Z safe_repr)rr'objrrrrsz!_safeReprVars..r)Z varsDictItemsrrrrs rTFc Cs|||fdkrvt}|d|jksvtrvzt|d}Wntk rPd}YnXtd|ddl}| |d||||||dS)z; Initialize failure object, possibly spawning pdb. )NNNrr,z broken strz8Jumping into debugger for post-mortem of exception '{}':Nr) rlrmrpDO_POST_MORTEMrrprintrpdbZ post_mortem) r:rsrtrurkZFailure__init__excZstrreprrrrr _debuginits  rcCs tt_dS)z* Enable debug hooks for Failures. N)rrfr<rrrrstartDebugModesr)r)-r+ __future__rrErFrrrl functoolsrrrrtypingrrr incrementalr rr Ztwisted.python.deprecater objectr rhZ traceupLengthrorr)ZEXCEPTION_CAUGHT_HEREr*r4r0r/r>rbrerrfrrr<rrrrrrsN        /!6