U W[h@s dZddlmZmZmZddlZddlZddlZddlZddl Z ddlm Z ddl m Z ddl mZmZdadZGdd d eZd$d d Zd ZGdddeZddZGdddeZGdddeZGdddeZgZddZGdddeZ ddZ!dZ"dddde j#fd d!Z$d"d#Z%dS)%z9 Asynchronous-friendly error mechanism. See L{Failure}. )divisionabsolute_importprint_functionN)getmro)reflect)_PY3NativeStringIOc@s eZdZdS)DefaultExceptionN)__name__ __module__ __qualname__rr8/usr/lib/python3/dist-packages/twisted/python/failure.pyr sr defaultc CsX|dkrtd|f|}|dkrL|D] \}}}}}|d|||fq&n|dkr|D]8\}}}}}|d|||f|dt||qXn|dkr|D] \}}}}}|d |||fq|d n|d krT|D]x\}}}}}|d |||f|d |D]\} } |d | t| fq|d|D]\} } |d | t| fq2qdS)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)rz %s:%s:%s rz File "%s", line %s, in %s z %s rz%s:%d: %s(...) zA [Capture of Locals and Globals disabled (use captureVars=True)] rz [ Locals ] z %s : %s 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)r r r __doc__rrrrr#Vsr#cCs4t|dkstdd}t|D]}t||}q |S)aE Construct a fake traceback object using a list of frames. Note that although frames generally include locals and globals, this information is not kept by this method, since locals and globals are not used in standard tracebacks. @param frames: [(methodname, filename, lineno, locals, globals), ...] rzMust pass some framesN)lenAssertionErrorreversed_TracebackFrame)rtbframerrr _Traceback^s   r+c@seZdZdZddZdS)r(zq Fake traceback object which can be passed to functions in the standard library L{traceback} module. cCs*|\}}}}}t|||_||_||_dS)z @param frame: (methodname, filename, lineno, locals, globals) @param tb_next: next inner _TracebackFrame object, or None if this is the innermost frame. N)_Frametb_frame tb_linenotb_next)selfr*r/r rrlocalzglobalzrrr__init__ws z_TracebackFrame.__init__Nr r r r$r3rrrrr(qsr(c@seZdZdZddZdS)r,z A fake frame object, used by L{_Traceback}. @ivar f_code: fake L{code} object @ivar f_globals: fake f_globals dictionary (usually empty) @ivar f_locals: fake f_locals dictionary (usually empty) cCst|||_i|_i|_dS)z @param name: method/function name for this frame. @type name: C{str} @param filename: filename for this frame. @type name: C{str} N)_Codef_code f_globalsf_localsr0r rrrrr3s z_Frame.__init__Nr4rrrrr,sr,c@seZdZdZddZdS)r5zB A fake code object, used by L{_Traceback} via L{_Frame}. cCs||_||_dSN)co_name co_filenamer9rrrr3sz_Code.__init__Nr4rrrrr5sr5cCst|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__)frrr _extraneouss rAc@seZdZdZdZdZer$ejdZ ne ejdZ d.ddZ dd Z d d Z d d ZeeddrjddZnedde_eddZddZeeZddZddZddZddZdd Zd!d"Zd#d$Zd/d&d'Zd0d(d)Zd1d*d+Z d2d,d-Z!dS)3Failurea 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{stack} and C{frame} attributes contain 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. @ivar value: The exception instance responsible for this failure. @ivar type: The exception's class. @ivar stack: list of frames, innermost last, excluding C{Failure.__init__}. @ivar frames: list of frames, innermost first. rNZ YIELD_VALUEFcCstdat|_d|_|_}||_t|tr>|dkr>tdd}|dkrR|}|dkrt \|_|_}|jdkr|t d}n:|dkrt|t r|j |_n t||_||_n ||_||_t|jt r||jdSt|jdr||jj|j`dS|dkr*|r|}nt|jddr*|jj}g}|_g}|_||_|rR|j} nt|jt shd} }|r| r| j} |d8}qh| r|r| j} | j| jkri} n | j} | | fD]} d| kr| d=q| } | } nd} } |d| jj| jj| j | | f| j} q|dk r|j} |r| j} | j| jkrRi} n | j} | | fD]} d| krd| d=qdt!| } t!| } nd} } |"| jj| jj|j#| | f|j$}qt%&|jrt'|jt rt(|j} t!t)t*j+| |_,n |jg|_,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}. Nz$Strings are not supported by Failurer __failure__ __traceback__ __builtins__r)-counttypevalue captureVars isinstancestr TypeError _findFailuresysexc_infor# Exception __class__rB _extrapolatehasattrrDgetattrrErstackr)r-f_backr8copyr7itemsinsertr6r;r<f_linenolistr>r.r/inspectisclass issubclassrmaprqualparents)r0 exc_valueexc_typeexc_tbrJr)Z stackOffsetrrVr@r1r2dZparentCsrrrr3s                            zFailure.__init__cCstt|j|_t\}}}g}|dk r^|j}|jtkrV||jj|jj |j ddf|j }q | |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} Nr)rX__dict__rOrPr-r6r=r>r;r<r.r/extendr)r0Z otherFailure_r)rr@rrrrS|s   zFailure._extrapolatecGs$|j|}|s tr|n||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} )checkrraiseException)r0 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)r]r^r_rQrrarb)r0rlrmerrrrrrjs   z Failure.checkwith_tracebackcCs|j|jdSr:)rIrpr)r0rrrrkszFailure.raiseExceptionzBdef raiseException(self): raise self.type, self.value, self.tbzf raise the original exception, preserving traceback information if available. cCs||j|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. )throwrHrIr))r0grrrthrowExceptionIntoGenerators z#Failure.throwExceptionIntoGeneratorcCstd}|sdSd}|}|jr.|}|j}q|j}|j|jjkrN|jdS|jj rj|jj |j |j krndS|r|j}|j|j jkr|jdS|jj }|r|j|j jkr|jdSdS)zV Find the failure that represents the exception currently in context. Nr0)rOrPr/r-r6rkr?r8getco_codetb_lasti _yieldOpcodertrW)clsr)Z secondLastTbZlastTbZ lastFramer*rrrrNs,    zFailure._findFailurecCs"dt|jt|j|fS)Nz <%s %s: %s>)rrarRrHgetErrorMessagerqrrr__repr__)s  zFailure.__repr__cCs d|S)Nz[Failure instance: %s])getBriefTracebackrqrrr__str__/szFailure.__str__cCs\|jr |jS|j}dd|jD|d<d|d<|jdk rPdd|jD|d<d|d <|S) z1Avoid pickling objects in the traceback. c Ss6g|].}|d|d|dt|dt|dgqSrrCr  _safeReprVars.0vrrr :s  z(Failure.__getstate__..rNr)c Ss6g|].}|d|d|dt|dt|dgqSrrrrrrrHs  rVrCpickled)rrgrXrrV)r0crrr __getstate__3s    zFailure.__getstate__cCs$||_t|jddr d|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}. rEN)rrgrUrIrErqrrr cleanFailureTs 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)r)r%rr+rqrrrgetTracebackObjectas  zFailure.getTracebackObjectcCs"t|jtr|jSt|jS)zJ Get a string of the exception which caused this Failure. )rKrIrBr{rsafe_strrqrrrr{ss  zFailure.getErrorMessagecCst}|j|d|S)N)file)StringIOprintBriefTracebackgetvalue)r0iorrrr}|s zFailure.getBriefTracebackrcCst}|j|||d|S)N)relideFrameworkCoder)rprintTracebackr)r0rrrrrr getTracebacks zFailure.getTracebackcCs`|dkrddlm}|j}|j}|dkr4|js4d}n|}|dkr^|d|j|jrRdpTdfnD|d kr|jrrd }nd }|d |t |j t |j fn|d |jr|st |j t d|||dtft |j||n|d ks|d|d ks|dt|j t |j ft|j trD|d|j ||||dkr\|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: A flag indicating whether to attempt to remove uninteresting frames from within Twisted itself from the output. @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%s z Failure: z%s: %s z (chained Failure) z*--- End of Failure #%d --- )twisted.pythonrZlogerrrrJrGrrrrrHrIr"rV traceupLengthEXCEPTION_CAUGHT_HERErarKrBr)r0rrrrrZ formatDetailZ hasFramesrrrrsN        zFailure.printTracebackcCs|j||dddS)z; Print a traceback as densely as possible. rrNrr0rrrrrrszFailure.printBriefTracebackcCs|j||dddS)zQ Print a traceback with detailed locals and globals information. rrNrrrrrprintDetailedTracebackszFailure.printDetailedTraceback)NNNF)rr)NFr)Nr)Nr)"r r r r$rrVropcodeZopmaprychrr3rSrnrjrU BaseExceptionrkexecrArtrN classmethodr|r~rrrr{r}rrrrrrrrrBsF  $ !   9!    F rBcCsdd|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)rZ safe_repr)rr objrrrrsz!_safeReprVars..r)Z varsDictItemsrrrrs rTFc Cs|||fdkrnt}|d|jksntrnzt|d}Wnd}YnXtd|fddl}||d||||||dS)z; Initialize failure object, possibly spawning pdb. )NNNrrCz broken strz8Jumping into debugger for post-mortem of exception '%s':Nr)rOrPrRDO_POST_MORTEMrLprintpdbZ post_mortem) r0rcrdrerJZFailure__init__excZstrreprrrrr _debuginits rcCs tt_dS)z* Enable debug hooks for Failures. N)rrBr3rrrrstartDebugModesr)r)&r$Z __future__rrrrXrOrr]rrrrZtwisted.python.compatrrrrGrrQr r"rr#r+objectr(r,r5r=rArrBrrr3rrrrrrsB   / +