o iY@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__rr\C:\Users\psant\Downloads\PAF backend\school\venv\Lib\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) frameswritedetailwmethodfilenamelinenoZ localVarsZ 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)ZtbFramesstackZfirstTbtbZsfrrr _Tracebackcs    r3c@eZdZdZddZdS)r/zq 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_lastir0)selfframerrr__init__s z_TracebackFrame.__init__Nrrrr+r<rrrrr/s r/c@r4)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|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_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>s r>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 N)_inlineCallbacksExtraneousappend__code__)r`rrr _extraneouss rec@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__rf _extrapolategetattrrgr2)r: exc_valueexc_typeexc_tbrkr2rrrr<s2       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)hasattrrvr2r5rkrBrFrAlistitemsrcr?rNrOr7r0)r:r r2r`rKrLdrrrr 8s:        zFailure.framescC ||_dSN)rv)r:r rrrr [ ZTwisted cCsgSr}rr^rrrr1_sz Failure.stackcCs~dSr}r)r:r1rrrr1cscCsZ|jdur|jSt|jr%t|jtr%t|j}ttt j ||_|jS|jg|_|jSr}) _parentsinspectisclassri issubclassrorrymapr qual)r:ZparentCsrrrparentsgs   zFailure.parentscCr|r})r)r:rrrrrsr~cCst|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._extrapolaterj BaseExceptionracCs6tt}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__rhrkrjrprir2)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} N)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)rrrror rr)r:rrerrrrrrs  z Failure.checkrcCs|j|j)zf raise the original exception, preserving traceback information if available. N)rjwith_tracebackr2r^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. N)throwrjrr2)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__s zFailure.__str__cCs>d|vr |d|d|d<|d|d<|j|dS)Nr1rrr rv)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. rrr1rvc Ss6g|]}|d|d|dt|dt|dgqS)rr,r) _safeReprVars).0vrrr s  z(Failure.__getstate__..r Nr2r,pickled)rrrFrrkr )r:_crrr __getstate__s   zFailure.__getstate__cCsttjtd|fS)Nr)rrfrrr^rrr __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 rvrgN)rrrrrrjrgrrrr 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)r2r-r r3r^rrrgetTracebackObject!s  zFailure.getTracebackObjectcCs"t|jtr |jSt|jS)zJ Get a string of the exception which caused this Failure. N)rnrjrfrr safe_strr^rrrr2s   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.pythonrZlogerrr!rkrhrr r rrirjr)rrnrfr)r:rrr"rr#Z formatDetailZ 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)rjrrarf)rar)rar)rr)rrr"rrar)NFr)Nr)#rrrr+rrr<propertyr setterr r r1rrq staticmethodrrrrrerrrrrrrrrrrrrrrrrrrfsL 9 "         (     ArfcCsdd|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..Nr)Z 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) rlrmrpDO_POST_MORTEMrrprintrpdbZ post_mortem) r:rsrtrurkZFailure__init__excZstrreprrrrr _debuginits   rcCs tt_dS)z* Enable debug hooks for Failures. N)rrfr<rrrrstartDebugModes r)r)r`r rar )-r+ __future__rrErFrrrl functoolsrrrrtypingrrr incrementalr rr Ztwisted.python.deprecater objectr rhZ traceupLengthrorr)ZEXCEPTION_CAUGHT_HEREr*r3r/r.r>rbrerrfrrr<rrrrrrsP        /! 6