.Ph wdZddlZddlZddlZgdZGddZGddZGdd ZGd d ZGd d eZ GddeZ GddeZ dZ dZ dZddZdZejdZejdZejdZGddZeZdS)aOne of the oft-cited tenets of Python is that it is better to ask forgiveness than permission. That is, there are many cases where it is more inclusive and correct to handle exceptions than spend extra lines and execution time checking for conditions. This philosophy makes good exception handling features all the more important. Unfortunately Python's :mod:`traceback` module is woefully behind the times. The ``tbutils`` module provides two disparate but complementary featuresets: 1. With :class:`ExceptionInfo` and :class:`TracebackInfo`, the ability to extract, construct, manipulate, format, and serialize exceptions, tracebacks, and callstacks. 2. With :class:`ParsedException`, the ability to find and parse tracebacks from captured output such as logs and stdout. There is also the :class:`ContextualTracebackInfo` variant of :class:`TracebackInfo`, which includes much more information from each frame of the callstack, including values of locals and neighboring lines of code. N) ExceptionInfo TracebackInfo CallpointContextualExceptionInfoContextualTracebackInfoContextualCallpointprint_exceptionParsedExceptionceZdZdZdZ d dZdZed dZedZ ed Z fd Z d Z xZ S)raThe Callpoint is a lightweight object used to represent a single entry in the code of a call stack. It stores the code-related metadata of a given frame. Available attributes are the same as the parameters below. Args: func_name (str): the function name lineno (int): the line number module_name (str): the module name module_path (str): the filesystem path of the module lasti (int): the index of bytecode execution line (str): the single-line code content (if available)  func_namelineno module_name module_pathlastilineNcZ||_||_||_||_||_||_dSNr )selfrrr rrrs O/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/boltons/tbutils.py__init__zCallpoint.__init__Zs2" &&  ci}|jD]L} t||}t|trt |n|||<=#t $rYIwxYw|S)zDGet a :class:`dict` copy of the Callpoint. Useful for serialization.) __slots__getattr isinstance _DeferredLinestrAttributeError)rretslotvals rto_dictzCallpoint.to_dictcs~N P PD PdD)))33 (F(FOCHHHCD "     sA AAcTtj|}||S)z>Creates a Callpoint from the location of the calling function.)sys _getframe from_frame)clslevelframes r from_currentzCallpoint.from_currentos% e$$~~e$$$rc|jj}|j}|jdd}|jj}|j}t|||j}|||||||S)zCCreate a Callpoint object from data extracted from the given frame.__name__r)f_codeco_namef_lineno f_globalsget co_filenamef_lastir)r)r+r rrrrrs rr(zCallpoint.from_frameusvL( o))*b99 l.  [&%/BBs; Y5t--- -rc|jjj}|j}|j}|jjdd}|jjj}t|||jj}|||||||S)a>Create a Callpoint from the traceback of the current exception. Main difference with :meth:`from_frame` is that ``lineno`` and ``lasti`` come from the traceback, which is to say the line that failed in the try block, not the line currently being executed (in the except block). r.r/r0) tb_framer1r2 tb_linenotb_lastir4r5r6r)r)tbr rrrrrs rfrom_tbzCallpoint.from_tbsK&.  k+// B?? k(4 [&"+2GHHs; Y5t--- -rcjj}fdjD}t|s t Sd|dd|DS)Nc2g|]}t|dSr)r).0srs r z&Callpoint.__repr__..s%???1a&&???rz{}({}), c,g|]}t|S)repr)r@as rrBz&Callpoint.__repr__..s1H1H1Ha$q''1H1H1Hr) __class__r.ranysuper__repr__formatjoin)rcnargsrHs` rrKzCallpoint.__repr__s} ^ $???????4yy K77##%% %??2tyy1H1H41H1H1H'I'IJJ Jrcd|j|j|j}|jr-|dt |jdz }|S)zRender the Callpoint as it would appear in a standard printed Python traceback. Returns a string with filename, line number, function name, and the actual code line of the error on up to two lines. z File "{}", line {}, in {}   )rLrrr rrstriprr s r tb_frame_strzCallpoint.tb_frame_strse .44T5E1515AA 9 5 4#di....00444 4C rr)r$)r. __module__ __qualname____doc__rrr# classmethodr,r(r=rKrU __classcell__rHs@rrrHs  I&*   %%%[%  - -[ ---[- KKKKK       rrc<eZdZdZdZd dZdZdZdZdZ d Z dS) ra3The _DeferredLine type allows Callpoints and TracebackInfos to be constructed without potentially hitting the filesystem, as is the normal behavior of the standard Python :mod:`traceback` and :mod:`linecache` modules. Calling :func:`str` fetches and caches the line. Args: filename (str): the path of the file containing the line lineno (int): the number of the line in question module_globals (dict): an optional dict of module globals, used to handle advanced use cases using custom module loaders. )filenamer_line _mod_name _mod_loaderNc||_||_|d|_d|_dS|d|_|d|_dS)Nr. __loader__)r]rr_r`r5)rr]rmodule_globalss rrz_DeferredLine.__init__s\    !!DN#D   +// ;;DN-11,??D   rc>|j|jf|j|jfkSr)rr]rothers r__eq__z_DeferredLine.__eq__s T]+ en/MMMrc||k SrrEres r__ne__z_DeferredLine.__ne__s5=  rct|dd}||S tj|j|j|jd}tj|j|j|}|}n#t$rd}YnwxYw||_ |S)Nr^)r.rbr/) r linecache checkcacher]r_r`getlinerrstripKeyErrorr^)rr mod_globalsrs r__str__z_DeferredLine.__str__sdGT** ?J    / / /'+~)-)9;;K$T]%)[%022D;;==DD   DDD   sAA44 BBc:tt|Sr)rFrrs rrKz_DeferredLine.__repr__sCIIrc:tt|Sr)lenrrss r__len__z_DeferredLine.__len__s3t99~~rr) r.rVrWrXrrrgrirqrKrvrErrrrs  LI@@@@NNN!!!"rrceZdZdZeZdZeddZeddZ edZ dZ d Z d Z d Zd Zd ZdS)raThe TracebackInfo class provides a basic representation of a stack trace, be it from an exception being handled or just part of normal execution. It is basically a wrapper around a list of :class:`Callpoint` objects representing frames. Args: frames (list): A list of frame objects in the stack. .. note :: ``TracebackInfo`` can represent both exception tracebacks and non-exception tracebacks (aka stack traces). As a result, there is no ``TracebackInfo.from_current()``, as that would be ambiguous. Instead, call :meth:`TracebackInfo.from_frame` without the *frame* argument for a stack trace, or :meth:`TracebackInfo.from_traceback` without the *tb* argument for an exception traceback. c||_dSrframes)rrzs rrzTracebackInfo.__init__s  rNr$c:g}|tj|}|ttdd}d}|I||krC|j|}|||j}|dz }|||kC|||S)aCreate a new TracebackInfo *frame* by recurring up in the stack a max of *limit* times. If *frame* is unset, get the frame from :func:`sys._getframe` using *level*. Args: frame (types.FrameType): frame object from :func:`sys._getframe` or elsewhere. Defaults to result of :func:`sys.get_frame`. level (int): If *frame* is unset, the desired frame is this many levels up the stack from the invocation of this method. Default ``1`` (i.e., caller of this method). limit (int): max number of parent frames to extract (defaults to :data:`sys.tracebacklimit`) Ntracebacklimitrr$)r&r'rcallpoint_typer(appendf_backreverse)r)r+r*limitr nitems rr(zTracebackInfo.from_frames" =M%((E =C!1488E AII%0077D JJt   LE FA AII s3xxrc>g}|*tjd}|td|ttdd}d}|I||krC|j|}|||j}|dz }|||kC||S)aCreate a new TracebackInfo from the traceback *tb* by recurring up in the stack a max of *limit* times. If *tb* is unset, get the traceback from the currently handled exception. If no exception is being handled, raise a :exc:`ValueError`. Args: frame (types.TracebackType): traceback object from :func:`sys.exc_info` or elsewhere. If absent or set to ``None``, defaults to ``sys.exc_info()[2]``, and raises a :exc:`ValueError` if no exception is currently being handled. limit (int): max number of parent frames to extract (defaults to :data:`sys.tracebacklimit`) Nz(no tb set and no exception being handledr|r}rr$)r&exc_info ValueErrorrr~r=rtb_next)r)r<rr rrs rfrom_tracebackzTracebackInfo.from_tracebacks$ :"Bz !KLLL =C!1488E nU%--b11D JJt   B FA nU s3xxrc$||dS)z*Complements :meth:`TracebackInfo.to_dict`.rzrE)r)ds r from_dictzTracebackInfo.from_dict9ss1X;rc(dd|jDiS)z\Returns a dict with a list of :class:`Callpoint` frames converted to dicts. rzc6g|]}|SrE)r#r@fs rrBz)TracebackInfo.to_dict..Cs <<<1199;;<<)rHr.rzru)rrN frame_parts rrKzTracebackInfo.__repr__KsX ^ $ ; 5$+b/55JJJ>2>>s4;//>>>>>rc*|Sr) get_formattedrss rrqzTracebackInfo.__str__Us!!###rcXd}|dd|jDz }|S)zReturns a string as formatted in the traditional Python built-in style observable when an exception is not caught. In other words, mimics :func:`traceback.format_tb` and :func:`traceback.format_stack`. z#Traceback (most recent call last): r/c6g|]}|SrE)rUrs rrBz/TracebackInfo.get_formatted.._s">>>Q((>>>r)rMrzrTs rrzTracebackInfo.get_formattedXs5 5 rww>>$+>>>??? r)Nr$NNN)r.rVrWrXrr~rrYr(rrr#rvrrKrqrrErrrrs$N[<[@  [ >>>    !!!???$$$rrc`eZdZdZeZdZedZedZ dZ dZ dZ dZ d S) ra#An ExceptionInfo object ties together three main fields suitable for representing an instance of an exception: The exception type name, a string representation of the exception itself (the exception message), and information about the traceback (stored as a :class:`TracebackInfo` object). These fields line up with :func:`sys.exc_info`, but unlike the values returned by that function, ExceptionInfo does not hold any references to the real exception or traceback. This property makes it suitable for serialization or long-term retention, without worrying about formatting pitfalls, circular references, or leaking memory. Args: exc_type (str): The exception type name. exc_msg (str): String representation of the exception value. tb_info (TracebackInfo): Information about the stack trace of the exception. Like the :class:`TracebackInfo`, ExceptionInfo is most commonly instantiated from one of its classmethods: :meth:`from_exc_info` or :meth:`from_current`. c0||_||_||_dSr)exc_typeexc_msgtb_info)rrrrs rrzExceptionInfo.__init__s    rc|j}|j}|dvr|d|}t|}|j|}||||S)zCreate an :class:`ExceptionInfo` object from the exception's type, value, and traceback, as returned by :func:`sys.exc_info`. See also :meth:`from_current`. )__main__ __builtin__ exceptionsbuiltins.)r.rV _some_str tb_info_typer)r)r exc_value tracebacktype_strtype_modval_strrs r from_exc_infozExceptionInfo.from_exc_infosj $& P P P"//X//HI&&"11)<<s8Wg...rc8|jtjS)zCreate an :class:`ExceptionInfo` object from the current exception being handled, by way of :func:`sys.exc_info`. Will raise an exception if no exception is currently being handled. )rr&r)r)s rr,zExceptionInfo.from_currents !s #,..11rcP|j|j|jdS)zjGet a :class:`dict` representation of the ExceptionInfo, suitable for JSON serialization. )rrexc_tb)rrrr#rss rr#zExceptionInfo.to_dicts.!M<,..0022 2rc|jj} t|jj}d|jjd}n#t $rd}d}YnwxYw||j|j||f}d|zS)Nz, last=rrr/z<%s [%s: %s] (%s frames%s)>)rHr.rurrz Exceptionrr)rrN len_frames last_framerOs rrKzExceptionInfo.__repr__s ^ $ T\011J>4<#6r#:>>JJ   JJJJ DM4<ZH,t33s.=A Ac|j}d||jd|jgS)zReturns a string formatted in the traditional Python built-in style observable when an exception is not caught. In other words, mimics :func:`traceback.format_exception`. r/: )rrrMrr)rtb_strs rrzExceptionInfo.get_formatteds@ ++--ww4= B BDL B BCDDDrc$|jd|jS)Nr)rrrss rget_formatted_exception_onlyz*ExceptionInfo.get_formatted_exception_onlys-114<111rN)r.rVrWrXrrrrYrr,r#rKrrrErrrrcs2!L  / /[ /22[2222 4 4 4EEE22222rrcneZdZdZfdZefdZefdZd dZdZ fdZ xZ S) ra`The ContextualCallpoint is a :class:`Callpoint` subtype with the exact same API and storing two additional values: 1. :func:`repr` outputs for local variables from the Callpoint's scope 2. A number of lines before and after the Callpoint's line of code The ContextualCallpoint is used by the :class:`ContextualTracebackInfo`. c|di|_|dg|_|dg|_t j|i|dS)N local_reprs pre_lines post_lines)poprrrrJr)rrGkwrHs rrzContextualCallpoint.__init__se66-44 R00&&r22!"r"""""rct|}||j||S)z)Identical to :meth:`Callpoint.from_frame`)rJr(_populate_local_reprsf_locals_populate_context_lines)r)r+r rHs rr(zContextualCallpoint.from_framesIgg  '' !!%.111 ##%%% rct|}||jj||S)z&Identical to :meth:`Callpoint.from_tb`)rJr=rr9rr)r)r<r rHs rr=zContextualCallpoint.from_tbsJggoob!! !!"+"6777 ##%%% rcJtjc} jjn#t$rdYnwxYwt d||z }fdt ||D}|jdd<fdt |dz|dz|zD}|jdd<dS)Nrc4g|]}j|SrErr@lnDLrcrs rrBz?ContextualCallpoint._populate_context_lines..s::::R("n==:::rc4g|]}j|SrErrs rrBz?ContextualCallpoint._populate_context_lines..s@GGGb)2~>>GGGrr$) rrrrcrmaxrangerr)rpivotr start_linerrrrcs` @@rrz+ContextualCallpoint._populate_context_liness "DK F "!Y5NN " " "!NNN "FUN++ ::::::$Z88::: %qqqGGGGGG %fqj&1*u2D E EGGG 's ! 00c|j}|D]D\}} t|||<#t$rdt |jz}|||<YAwxYwdSNz)ritemsrFrtyper.)rrrkv surrogates rrz)ContextualCallpoint._populate_local_reprss& NN$$ + +DAq +!%a A + + +5Q8HH !* A + s5&AAct}tj|d<jt jz fdtjD}t|D]\}}|drn|r ||d}||d<fdtjD}d}t|D]\}}|dr|}|d|dz}||d <|S) a Same principle as :meth:`Callpoint.to_dict`, but with the added contextual values. With ``ContextualCallpoint.to_dict()``, each frame will now be represented like:: {'func_name': 'print_example', 'lineno': 0, 'module_name': 'example_module', 'module_path': '/home/example/example_module.pyc', 'lasti': 0, 'line': 'print "example"', 'locals': {'variable': '"value"'}, 'pre_lines': ['variable = "value"'], 'post_lines': []} The locals dictionary and line lists are copies and can be mutated freely. localsc@g|]\}}|zt|dS)rr)r)r@ilrs rrBz/ContextualCallpoint.to_dict.. s?<<<A!+QA??<<.sA>>>!Q"&q#a&&AA>>>rrr$r) rJr#dictrrrur enumerater) rr rrrr_lastrrHs ` @rr#zContextualCallpoint.to_dictsO&ggooT-..H [3t~#6#66 <<<!:!:<<< !++  GAtF|    &!!"" I$K>>>>"+DO"<"<>>>  ,,  GAtF|   + &L r)r) r.rVrWrXrrYr(r=rrr#rZr[s@rrrs##### [[    ,,,,,,,,,rrceZdZdZeZdS)rzThe ContextualTracebackInfo type is a :class:`TracebackInfo` subtype that is used by :class:`ContextualExceptionInfo` and uses the :class:`ContextualCallpoint` as its frame-representing primitive. N)r.rVrWrXrr~rErrrr"s )NNNrrceZdZdZeZdS)ra>The ContextualTracebackInfo type is a :class:`TracebackInfo` subtype that uses the :class:`ContextualCallpoint` as its frame-representing primitive. It carries with it most of the exception information required to recreate the widely recognizable "500" page for debugging Django applications. N)r.rVrWrXrrrErrrr+s+LLLrrc|t||gS|j}|j}|dvr|dz|z}t|tst||gSg}|jpd}t |jpd}|d|d|d|j }|j }||d | z|f| dd| } d | D} |d d | z|jpd } ||d| d|S)aFormat the exception part of a traceback. The arguments are the exception type and value such as given by sys.last_type and sys.last_value. The return value is a list of strings, each ending in a newline. Normally, the list contains a single string; however, for SyntaxError exceptions, it contains several lines that (when printed) display detailed information about where the syntax error occurred. The message indicating which exception occurred is always the last string in the list. N)rrrrz?z File "z", line rRz %s c3FK|]}|r|pdVdS) N)isspace)r@cs r z(format_exception_only..as4II199;;,13IIIIIIrz %s^ r/zr)_format_final_exc_liner.rV issubclass SyntaxErrorr]rrrtextoffsetrSrnlstriprMmsg) etypevaluestypesmodlinesr]rbadliner caretspacers rformat_exception_onlyr8s$ }&ue4455 NE  D 999s U" e[ ) )6&ue4455 E~+H    %#F LL8H88f888999jG \F Z'--//1222   --gvg6==??JIIjIIIJ LLbggj&9&99 : : : ) ..C LLE$$S$$$%%% Lrcp t|S#t$rYnwxYwdt|jzSr)rrrr.)rs rrrjsG 5zz      $tE{{'; ;;s  cHt|}||sd|z}n|d|d}|S)Nz%s rrR)r)rrvaluestrrs rrrrs>H }H}~''8''' Krc| tj}|r:t||}t t |d|t ||D]}t |d|dS)aPrint exception up to 'limit' stack trace entries from 'tb' to 'file'. This differs from print_tb() in the following ways: (1) if traceback is not None, it prints a header "Traceback (most recent call last):"; (2) it prints the exception type and value after the stack trace; (3) if type is SyntaxError and value has the appropriate format, it prints the line where the syntax error occurred with a caret on the next line indicating the approximate position of the error. Nr/)endfile)r&stderrrrprintrr)rrr<rrtbirs rr r {s |z +**2u55 c#hhBT****%eU33'' d&&&&&''rc(tt_dS)z Sets the default exception hook :func:`sys.excepthook` to the :func:`tbutils.print_exception` that uses all the ``tbutils`` facilities to provide a consistent output behavior. N)r r& excepthookrErrfix_print_exceptionr s %CNNNrzD^File "(?P.+)", line (?P\d+), in (?P.+)$z.^File "(?P.+)", line (?P\d+)z^[~^ ]*$cXeZdZdZd dZedZdZdZdZ e dZ dS) r zStores a parsed traceback and exception as would be typically output by :func:`sys.excepthook` or :func:`traceback.print_exception`. .. note: Does not currently store SyntaxError details such as column. NcN||_||_t|pg|_dSrrrlistrz)r exc_type_namerrzs rrzParsedException.__init__s'%  6O;@?;@;LNN O O O ))M22K 3 1K11222 < - LLDM;;T\;; < < < < LLDM+ , , ,yyrct|ts|d}|}|rJ|d}|dr*|dr|nn|J|r(|ddkr d}t}nYt|dkr7|dd r d}t}ntd g}|} ||}| |} | r| } ||dz} n#t$rd } YnwxYw| } | | s| d sd | d<n | | d<|dz }t ||dzr|dz }nn|dz }||  d||d} | d\}}}n#t($rd\}}YnwxYw||||S)a/Parse a traceback and exception from the text *tb_str*. This text is expected to have been decoded, otherwise it will be interpreted as UTF-8. This method does not search a larger body of text for tracebacks. If the first line of the text passed does not match one of the known patterns, a :exc:`ValueError` will be raised. This method will ignore trailing text after the end of the first traceback. Args: tb_str (str): The traceback text (:class:`unicode` or UTF-8 bytes) zutf-8rz Exception ignoredrrr$^z$unrecognized traceback string formatTr/rrrRNr)r/r/)rrdecoder splitlines startswithendswithrrS _frame_reru _se_frame_rermatch groupdictr _underline_rerrM partitionr)r)rtb_linesclrframe_rerzline_no frame_line frame_match frame_dict next_linenext_line_strippedexc_liner_rs r from_stringzParsedException.from_strings&#&& ,]]7++F==??--//  "B}}\** r{{9/E/E      E ))++/SSSJ HH ]]Q  8B<#6#6#8#8#C#CC#H#H J#HHCDD D &!'*0022J"..44K (2244 # (1 5II!### "III#&/__%6%6" '9:: ! &0055 !13J}--0BJ}-qLG &&x! '<==Q,' qLG MM* % % %; &> 'yy'((!344H#+#5#5d#;#; Ha ' ' ' & Hggg 's8Wf---s$+ E77 FF6II&%I&r) r.rVrWrXrpropertyrr#rKrrYr7rErrr r s)))) X--- BBB    8N.N.[N.N.N.rr r)rXrer&rk__all__rrrrrrrrrrr r compiler&r'r*r ParsedTBrErrr=sP>,  H H H ]]]]]]]]@55555555rDU2U2U2U2U2U2U2U2pddddd)dddN)))))m))) + + + + +m + + +...d<<<'''',%%% BJ1 2 2 rzKLL  ;'' P.P.P.P.P.P.P.P.f r