/usr/lib/python3/dist-packages/twisted/python/__pycache__
Edit: /usr/lib/python3/dist-packages/twisted/python/__pycache__/failure.cpython-310.pyc (18960B)
o
bi @ s d Z ddlZddlZddlZddlZddlmZ ddlmZ ddlZddl m
Z
da dZ G dd de
Zd#d
d Zd ZG d
d de
Zdd ZG dd dZG dd dZG dd dZg Zdd ZG dd deZdd Zd Zdddd ej fd d Z d!d" Z dS )$z9
Asynchronous-friendly error mechanism.
See L{Failure}.
N)getmro)StringIO)reflect c @ s e Zd ZdS )DefaultExceptionN)__name__
__module__ __qualname__ r
r
8/usr/lib/python3/dist-packages/twisted/python/failure.pyr s r defaultc C sx |dvr t d|f |}|dkr*| D ]\}}}}}|| d| d| d qdS |dkrT| D ]!\}}}}}|d| d| d | d |d
t|| q0dS |d krq| D ]\}}}}}|d |||f qZ|d
dS |dkr| D ]B\}}}}}|d |||f |d |D ]\} }
|d| dt|
d q|d |D ]\} }
|d| dt|
d qqwdS dS )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
)r briefverboseverbose-vars-not-capturedzNDetail must be default, brief, verbose, or verbose-vars-not-captured. (not %r)r
:
r z File "z", line z, in z %s
r z%s:%d: %s(...)
zA [Capture of Locals and Globals disabled (use captureVars=True)]
r z [ Locals ]
z z : z
( Globals )
N)
ValueError linecachegetlinestriprepr) frameswritedetailwmethodfilenamelineno localVars
globalVarsnamevalr
r
r
format_frames# s@ r" z ---
---c @ s e Zd ZdZdS )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__r
r
r
r r# V s r# c C sv t |dks
J dd}| D ]}t||}qt|d |}t| }}|dd D ]}t||}t||_|j}q)|S )a
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 stackFrames: [(methodname, filename, lineno, locals, globals), ...]
@param tbFrames: [(methodname, filename, lineno, locals, globals), ...]
r zMust pass some framesN )len_Frame_TracebackFrametb_next) stackFramestbFramesstacksffirstTbtbr
r
r
_Traceback] s
r0 c @ e Zd ZdZdd ZdS )r( zq
Fake traceback object which can be passed to functions in the standard
library L{traceback} module.
c C s || _ |j| _d| _dS )z-
@param frame: _Frame object
N)tb_framef_lineno tb_linenor) )selfframer
r
r __init__ s
z_TracebackFrame.__init__Nr r r r$ r7 r
r
r
r r( s r( c @ r1 )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)
c C s6 |\}}}}}t ||| _|| _i | _i | _|| _dS )z
@param frameinfo: (methodname, filename, lineno, locals, globals)
@param back: previous (older) stack frame
@type back: C{frame}
N)_Codef_coder3 f_globalsf_localsf_back)r5 frameinfobackr r r localzglobalzr
r
r r7 s
z_Frame.__init__Nr8 r
r
r
r r' s
r' c @ r1 )r9 zB
A fake code object, used by L{_Traceback} via L{_Frame}.
c C s || _ || _d S )N)co_name co_filename)r5 r r r
r
r r7 s
z_Code.__init__Nr8 r
r
r
r r9 s r9 c C s t | 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__)fr
r
r _extraneous s rH c @ s e Zd ZdZdZdZejd Zd.ddZ dd Z
d
d Z d d
Z dd Z
edd Zedd ZdefddZdefddZdd Zdd Zd d Zdefd d Zdefd!d"Zd/d$ed%edefd&d'Zd0d(d)Z d1d*d+Z d1d,d-Z dS )2Failurea
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.
r N YIELD_VALUEFc C s t d a t | _ d | _ | _}|| _t|tr |du r tdd}|du r)| }|du rAt \| _| _}| jdu r>t
d}n |du rXt|t rO|j | _nt|| _|| _n|| _|| _t| jt
rl| | j dS t| jdr~| | jj | j`dS |du r|r|}n t| jddr| jj}g }| _g }| _|| _|r|j} n
t| jt
sd } }|r| r| j} |d8 }|r| s| r|r| j }
| j| ju ri } n| j } | |
fD ] } d| v r| d= q|
}
| } nd }
} | d| j j | j j | j |
| f | j} | s|dur]|j} |rB| j }
| j| ju r i } n| j } | |
fD ] } d| v r3| d= q)t!|
}
t!| } nd }
} |"| j j | j j |j#|
| f |j$}|dus t%&| jr{t'| jt r{t(| j}
t!t)t*j+|
| _,dS | 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}.
r% Nz$Strings are not supported by Failurer __failure__
__traceback__ __builtins__r
)-counttypevalue captureVars
isinstancestr TypeError _findFailuresysexc_infor# Exception __class__rI _extrapolatehasattrrK getattrrL r r, r/ r2 r= r< copyr; itemsinsertr: rB rC r3 listrE r4 r) inspectisclass
issubclassr mapr qualparents)r5 exc_valueexc_typeexc_tbrQ r/ stackOffsetr r, rG r@ rA dparentCsr
r
r r7 s
zFailure.__init__c C sz t |j| _t \}}}g }|dur2|j}|jtvr+||jj|jj |j
ddf |j }|dus| | 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
)r] __dict__rV rW r2 r: rD rE rB rC r4 r) extendr )r5 otherFailure_r/ r rG r
r
r rZ s
zFailure._extrapolatec G s | 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)r5
errorTypeserrorr
r
r trap s
z Failure.trapc G sB |D ] }|}t |rt|trt|}|| jv r | S qdS )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)ra rb rc rX r re rf )r5 rs rt errr
r
r rq s
z
Failure.checkc C s | j | j)zf
raise the original exception, preserving traceback
information if available.
)rP with_tracebackr/ r5 r
r
r rr s zFailure.raiseExceptionc C s | | 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.
)throwrO rP r/ )r5 gr
r
r throwExceptionIntoGenerator s z#Failure.throwExceptionIntoGeneratorc C s t d }|s
dS d}|}|jr|}|j}|js|j}|j| jju r)|jdS |jj r7|jj |j
| j kr9dS |rK|j}|j| j ju rK|jdS |jj
}|r^|j| j ju r`|jdS dS dS )zV
Find the failure that represents the exception currently in context.
Nr5 )rV rW r) r2 r: rr rF r< getco_codetb_lasti _yieldOpcoder{ r= )clsr/ secondLastTblastTb lastFramer6 r
r
r rU s4 zFailure._findFailurereturnc C s" d t| jt| j| S )Nz <{} {}: {}>)formatr re rY rO getErrorMessagerx r
r
r __repr__& s
zFailure.__repr__c C s d| S )Nz[Failure instance: %s])getBriefTracebackrx r
r
r __str__- s zFailure.__str__c C s\ | j r| jS | j }dd | jD |d< d|d< | jdur(dd | jD |d< d|d < |S )
z(Avoid pickling objects in the traceback.c S 6 g | ]}|d |d |d t |d t |d gqS r r% r
_safeReprVars.0vr
r
r
6
z(Failure.__getstate__..r Nr/ c S r r r r r
r
r r G r r, r% pickled)r rm r] r r, )r5 cr
r
r __getstate__0 s
zFailure.__getstate__c C s( | | _t| jddrd| j_dS 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}.
rL N)r rm r\ rP rL rx r
r
r cleanFailureU s
zFailure.cleanFailurec C s0 | j dur| j S t| jdkrt| j| jS dS )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& r r0 r, rx r
r
r getTracebackObjecta s
zFailure.getTracebackObjectc C s" t | jtr | j S t| jS )zJ
Get a string of the exception which caused this Failure.
)rR rP rI r r safe_strrx r
r
r r r s
zFailure.getErrorMessagec C s t }| j|d | S )N)file)r printBriefTracebackgetvalue)r5 ior
r
r r z s zFailure.getBriefTracebackr elideFrameworkCoder c C s t }| j|||d | S )N)r r r )r printTracebackr )r5 r r r r
r
r getTraceback s
zFailure.getTracebackc C sb |du r
ddl m} |j}|j}|dkr| jsd}n|}|dkr/|d| j| jr)dp*df n"|d krM| jr9d
}nd }|d |t | j
t | j f n|d
| jrq|sit | j
t d || |t d t | j|| n|d ksy|d |d ks|t| j
dt | j d t| j tr|d | j ||| |dkr|d| j dS dS )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 )logr r z*--- Failure #%d%s---
z (pickled) r
Tracebackz"Traceback (failure with no frames)z %s: %s: %s
z#Traceback (most recent call last):
r z Failure: z: z (chained Failure)
z *--- End of Failure #%d ---
)twisted.pythonr logerrr rQ rN r r r r rO rP r" r,
traceupLengthEXCEPTION_CAUGHT_HEREre rR rI r )r5 r r r r r formatDetail hasFramesr
r
r r sL $
zFailure.printTracebackc C | j ||dd dS )z;
Print a traceback as densely as possible.
r
r Nr r5 r r r
r
r r zFailure.printBriefTracebackc C r )zQ
Print a traceback with detailed locals and globals information.
r r Nr r r
r
r printDetailedTraceback r z Failure.printDetailedTraceback)NNNF)r r )NFr )Nr ) r r r r$ r r, opcodeopmapr r7 rZ ru rq rr rH r{ classmethodrU rS r r r r r r r intr r r r r
r
r
r rI s4
'
:%
ErI c C s dd | D S )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.
c S s g | ] \}}|t |fqS r
)r safe_repr)r r objr
r
r r s z!_safeReprVars..r
)
varsDictItemsr
r
r r s r TFc C s |||fdkr:t }|d | jks:tr:zt|d }W n ty' d}Y nw td| ddl}| |d || |||| dS )z;
Initialize failure object, possibly spawning pdb.
)NNNr r% z
broken strz8Jumping into debugger for post-mortem of exception '{}':Nr )
rV rW rY DO_POST_MORTEMrS
BaseExceptionprintr pdb post_mortem) r5 rg rh ri rQ Failure__init__excstrreprr r
r
r
_debuginit s r c C s
t t_dS )z*
Enable debug hooks for Failures.
N)r rI r7 r
r
r
r startDebugMode s
r )r ) r$ r] ra r rV r r r r r r rN r rX r r" r r# r0 r( r' r9 rD rH r rI r r r7 r r r
r
r
r sF
0&