tfsdZddlmZddlZddlZddlZddlZddlZddlm Z ddlm Z ddl m Z ddl mZmZmZddlZddlmZed ed ef Zdad ZGd deZd%dZdZGddeZdZGddZGddZGddZ gZ!d&dZ"Gdde#Z$d Z%d!Z&dddd"e$j'fd#Z(d$Z)dS)'z9 Asynchronous-friendly error mechanism. See L{Failure}. ) annotationsN)partial)getmro)StringIO)CallableNoReturnTypeVar)reflect _T_Callable.)boundceZdZdS)DefaultExceptionN)__name__ __module__ __qualname__U/var/www/surfInsights/venv3-11/lib/python3.11/site-packages/twisted/python/failure.pyrr%sDrrdefaultc |dvrtd|d|}|dkr!|D]\}}}}}||d|d|ddS|dkrU|D]P\}}}}}|d|d |d |d|d tj||zQdS|d kr)|D]\}}}}}|d |||fz|ddS|dkr|D]\}}}}}|d |||fz|d|D]$\} } |d| dt | d%|d|D]$\} } |d| dt | d%~dSdS)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-capturedzKDetail must be default, brief, verbose, or verbose-vars-not-captured. (not )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 globalVarsnamevals r format_framesr.)s{"QQQj5;VV >    A ?E 1 1 ;FHfi A//F//V/// 0 0 0 0 1 1 9  ?E H H ;FHfi ABBB6BBBBB C C C Aj9,Xv>>DDFFF G G G G H H . . .?E ? ? ;FHfi A Hff#== > > > >  NOOOOO 9  ?E / / ;FHfi A Hff#== > > > Ao   & / / c-t--S ---.... A   ' / / c-t--S ---.... /   / /rz--- ---ceZdZdZdS)NoCurrentExceptionErrorz Raised when trying to create a Failure from the current interpreter exception state and there is no current exception state. N)rrr__doc__rrrr0r0\srr0c,t|dks Jdd}|D]}t||}t|d|}t|x}}|ddD]-}t||}t||_|j}.|S)a5 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 stackFrames: [(methodname, filename, lineno, locals, globals), ...] @param tbFrames: [(methodname, filename, lineno, locals, globals), ...] rzMust pass some framesN)len_Frame_TracebackFrametb_next) stackFramestbFramesstacksffirstTbtbs r _Tracebackr>cs x==1   5    E""r5!! 8A; & &E"5)))Gbqrrlr5!!$U++ Z NrceZdZdZdZdS)r6zq Fake traceback object which can be passed to functions in the standard library L{traceback} module. cR||_|j|_|j|_d|_dS)z- @param frame: _Frame object N)tb_framef_lineno tb_linenof_lastitb_lastir7)selfframes r__init__z_TracebackFrame.__init__s(    rNrrrr1rHrrrr6r6s- rr6ceZdZdZdZdS)r5aD 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) c&|\}}}}}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_coderBdict f_globalsf_localsf_backrDvarsbuiltinscopy f_builtinsf_trace)rF frameinfobackr,r(r)localzglobalzs rrHz_Frame.__init__s 3</hD(++  gm,,V\r**   x..--// rNrIrrrr5r5s-rr5ceZdZdZdZdZdS)rLz 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. c||_||_d|_d|_d|_g|_d|_d|_d|_d|_ d|_ d|_ d|_ d|_ d|_d|_dS)Nrrr)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)rFr,r(s rrHz_Code.__init__s #  "#!" rcdS)N))NNNNrrFs r co_positionsz_Code.co_positionss**rN)rrrr1rHrorrrrLrLs<$+++++rrLfreturncDt|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__)rps r _extraneousrvs%%aj111 Hrc4eZdZdZdZdZdZejdZ d&dZ e dZ e j dZ d Zed'd ZdZdZd(dZedZedZd)dZd)dZdZdZdZdZdZd)dZd)dZ d*d+d"Z!d,d#Z"d-d$Z#d-d%Z$dS).Failurea 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. rN YIELD_VALUEFctdzat|_dx|_x|_}||_d}||}|9t j\|_|_}|jtd}nN|>t|tr |j |_nt||_||_n||_||_t|jtr| |jdSt|jdr(| |jj|j`dS|'|r|}n"t|jddr |jj}gx}|_gx}|_||_|r|j} nt|jtsdx} }|r| r| j} |dz}|r| | r|rz| j} | j| juri} n| j} | | fD] } d| vr| d= | } | } ndx} } |d| jj| jj| j| | f| j} | ||j} |r| j} | j| juri} n| j} | | fD] } d| vr| d= t?| } t?| } ndx} } | | jj| jj|j!| | f|j"}|dSdS)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}. r3Nr __failure__ __traceback__ __builtins__r)#counttypevalue captureVars _findFailuresysexc_infor0 isinstance Exception __class__rx _extrapolatehasattrr{getattrr|r#r:r=rArQrPrTrOitemsinsertrMr]r^rBlistrtrCr7) rF exc_valueexc_typeexc_tbrr= stackOffsetr#r:rprYrZds rrHzFailure.__init__s2  &** *DJ&  ))++I  (+  %DItz2y -///KK  )Y// ,%/ !OO "DJJ DI"DJ dj' * *    dj ) ) ) F 4:} - -    dj4 5 5 5  & F : ._d;; .Z-!!   # AADJ00 ## "A  a A 1 K  a   &**:,, GGk..00G &..A%**n-!--//#%% LLH$H(J    A1 4n A &**:,, GGk..00G &..A%**n-fllnn--w}}//#%% MMH$H(L    B1nnnnnrc.|j|jStj|jr[t |jt rAt |j}tttj ||_n |jg|_|jSN) _parentsinspectisclassr issubclassrrrmapr qual)rFparentCss rparentszFailure.parentssx = $= ?49 % % (*TY *J*J (di((H W\8!>1bn Ax999 X%qx';R\2rRB n  dk""" rr BaseExceptionrqctt}tdz ad|_t|_g|_g|_||_|j|_d|_ |S)z Create a L{Failure} for an exception without a traceback. By restricting the inputs significantly, this constructor runs much faster. r3FN) rx__new__r~rr#r:rrrr=)rresults r_withoutTracebackzFailure._withoutTracebacksW))  "    o   rcF|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)rF errorTypeserrors rtrapz Failure.traps10 J' "    ! ! ! rc|D]N}|}tj|r)t|trt j|}||jvr|cSOdS)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)rrrrr rr)rFrrerrs rrz Failure.checksj   ECu%% **UI*F*F *l5))dl"" #trrc@|j|j)zf raise the original exception, preserving traceback information if available. )rwith_tracebackr=rns rrzFailure.raiseExceptions j''000rcf||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. )throwrrr=)rFgs rthrowExceptionIntoGeneratorz#Failure.throwExceptionIntoGenerators(wwtz0099:::rc tjd}|sdSd}|}|jr|}|j}|j|j}|j|jjur|jdS|jj r |jj |j |j krdS|r4|j}|j|j jur|jdS|jj }|r-|j|j jur|jdSdSdS)zV Find the failure that represents the exception currently in context. NrF)rrr7rArMrrurPgetrcrE _yieldOpcoderrQ)clsr= secondLastTblastTb lastFramerGs rrzFailure._findFailure'sC \^^B   F n $!L^Fn $O   s1: : :%))&11 1 ( Y-=-E O.  .. F  2 )E|s>GGG~))&111 "  .U\S%D%MMM>%%f-- - . .MMrstrcdtj|jtj|j|S)Nz <{} {}: {}>)formatr rrrgetErrorMessagerns r__repr__zFailure.__repr__bsG## L ( ( L # #  " "   rc0d|zS)Nz[Failure instance: %s])getBriefTracebackrns r__str__zFailure.__str__is'$*@*@*B*BBBrcj|d|d<|j|dS)Nrr)poprupdate)rFstates r __setstate__zFailure.__setstate__ls4!IIi00j U#####rc|j}|j}|d|d<|jrd|jD|d<d|d<|j|jrd|jD|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. rrc g|]A}|d|d|dt|dt|dgBSrr3r  _safeReprVars.0vs r z(Failure.__getstate__..s_    aDaDaD!!A$''!!A$''    rr#Nr=c g|]A}|d|d|dt|dt|dgBSrrrs rrz(Failure.__getstate__..s_    !!!%ad++%ad++    rr:r3pickled)rrrTrrr#r:)rFrcs r __getstate__zFailure.__getstate__ps L M   uuZ(()        AhK$ : !   "Z   ' ) rcjttjtd|fS)Nr)rrxrrrns r __reduce__zFailure.__reduce__s)112t7H7H7J7JKKrc||_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|N)rrrrr|rns r cleanFailurezFailure.cleanFailuresG))++ 4: 5 5 ,'+DJ $ $ $ , ,rc|j|jSt|jdkrt|j|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)r=r4r#r>r:rns rgetTracebackObjectzFailure.getTracebackObjectsA 7 7N    ! !dj$+66 64rct|jtr|jSt j|jS)zJ Get a string of the exception which caused this Failure. )rrrxrr safe_strrns rrzFailure.getErrorMessages? dj' * * 0:--// / +++rcrt}|||S)N)file)rprintBriefTracebackgetvalue)rFios rrzFailure.getBriefTracebacks0 ZZ   b ))){{}}rrelideFrameworkCodeintr%cvt}|||||S)N)rrr%)rprintTracebackr)rFrr%rs r getTracebackzFailure.getTracebacks@ ZZ (:6    {{}}rc | ddlm}|j}|j}|dkr |jsd}n|}|dkr|d|j|jrdpdfzn`|d krO|jrd }nd }||d tj |j d tj |j d n |d|jrP|s7t|j t d|||td t|j||n|d ks |d|d ks?|tj|j d tj |j d t#|j t$r1|d|j ||||dkr|d|jzdSdS)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: rz#Traceback (most recent call last): z Failure: z (chained Failure) z*--- End of Failure #%d --- )twisted.pythonrlogerrr$rr~rr#r rrrr.r: traceupLengthEXCEPTION_CAUGHT_HERErrrxr)rFrrr%rr& formatDetail hasFramess rrzFailure.printTracebacksO < * * * * * *:D J Y  t'7 7LL!L Y   A): >F3GH    w  { A' @ A99g.ty99997;KDJ;W;W;W;WY     A4 5 5 5 ; % 0dj-91lKKK*.../// $+q, 7 7 7 77"" AkNNN  Adi((LLG, G G G Y   A- : ; ; ; ; ;  rc6|||ddS)z; Print a traceback as densely as possible. rr%NrrFrrs rrzFailure.printBriefTracebacks& D"4WEEEEErc6|||ddS)zQ Print a traceback with detailed locals and globals information. rrNrrs rprintDetailedTracebackzFailure.printDetailedTraceback"s& D"4YGGGGGr)NNNF)rrrqrx)rqr)rqr)rr)rrr%rrqr)NFr)Nr)%rrrr1rr:ropcodeopmaprrHpropertyrsetterr staticmethodrrrrrvr classmethodrrrrrrrrrrrrrrrrrrxrxs-$G EH< .LZZZZx  X  ^  ^ :\&: 1111 ; ;[ ;8.8.[8.t    CCCC$$$///bLLL , , ,",,,, C<C<C<C.4s, L L L{cT7$S)) * L L Lrr) varsDictItemss rrr)s M Lm L L LLrTFc`|||fdkrtj}|d|jksqtrj t |d}n#t $rd}YnwxYwt d|ddl}| |d||||||dS)z; Initialize failure object, possibly spawning pdb. )NNNrr3z broken strz8Jumping into debugger for post-mortem of exception '{}':Nr) rrrDO_POST_MORTEMrrprintrpdb post_mortem) rFrrrrFailure__init__excstrreprr s r _debuginitr<s 8V$(:::lnn1v''N' 'c!f++  ' ' '& ' JQQ    JJJ OOCF # # #OD)Xv{CCCCCsA AAc(tt_dS)z* Enable debug hooks for Failures. N)rrxrHrrrstartDebugModerYs"Gr)r)rpr rqr )*r1 __future__rrSrTrrr functoolsrrrrtypingrrr rrr objectr r~rrrr.rr0r>r6r5rLrsrvrrxrrrHrrrrrrs #"""""  .......... """"""gm8CK+@AAA        y   +/+/+/+/`:i###R         8++++++++<      }H}H}H}H}Hm}H}H}H@ M M M    $ DDDD:"""""r