o v&i@sdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl m Z m Z ddl mZddlmZddlmZmZmZmZddlmZdd lmZdd lmZdd lmZmZdd lm Z m!Z!dd l"m#Z#ddl$m%Z%m&Z&e eZGdddZ'GdddZ(edddGdddZ)GdddeZ*e+e%e,e-ee.ee.ffZ/GdddZ0Gddde0Z1Gddde0Z2Gdd d e0Z3d)d%d&Z4Gd'd(d(Z5dS)*zCode parsing for coverage.py.) annotationsN)IterableSequence) dataclass)CodeType)CallableOptionalProtocolcast)env) code_objects) short_stack)NoSource NotPython)isolate_module nice_pair)generate_tokens)TArcTLineNoc@seZdZdZ   d8d9d d Zd:ddZd;ddZejdddddZ d?d"d#Z d;d$d%Z d@d&d'Zd;d(d)Zd?d*d+ZejdAd-d.ZdBd1d2ZdCd4d5ZdCd6d7ZdS)D PythonParserzParse code to find executable lines, excluded lines, etc. This information is all based on static analysis: no code execution is involved. Ntext str | NonefilenameexcludereturnNonec Cs|s|sJd|p d|_|dur||_n'ddlm}z||j|_Wnty;}z td|jd||d}~ww||_d|_t|_ t|_ t|_ t|_ t|_ d|_i|_d|_d|_i|_dS) z Source can be provided as `text`, the text itself, or `filename`, from which the text will be read. Excluded lines are those that match `exclude`, a regex string. z*PythonParser needs either text or filenamezNr)get_python_sourcezNo source for code: 'z': F)rrcoverage.pythonrOSErrorrr _ast_rootset statementsexcludedraw_statements raw_excludedraw_docstrings show_tokens multiline_map _all_arcs_missing_arc_fragments_with_jump_fixers)selfrrrrerrr-U/var/www/html/karishye-ai-python/venv/lib/python3.10/site-packages/coverage/parser.py__init__'s.   zPythonParser.__init__regexstr set[TLineNo]c st}d}d}tj|jtjdD]3}|\}}|jd||}|jd||} |fddt|d| dD|}|}q|S)zFind the lines matching a regex. Returns a set of line numbers, the lines that contain a match for `regex`. The entire line needn't match, just a part of it. Handles multiline regex patterns. r)flags c3s|] }j||VqdSNr'get).0ir+r-r. vs z.PythonParser.lines_matching..) r refinditerr MULTILINEspancountupdaterange) r+r0matches last_startlast_start_linematchstartend start_lineend_liner-r:r.lines_matchingfs zPythonParser.lines_matchingcCs|jr||j|_t|j|_d}d}d}d}d}d}|jdus#Jt|j}|D]\}} \} } \} } } |jrKtdt j ||t | | f| | f|t jkrU|d7}n_|t jkr_|d8}nU|t jkr| dkr|dkr|jt|| d}|s|r|j| |}d}n.| dvr|d7}n%| d vr|d8}n|t jkr|r| |krt|| dD]}||j|<qd}| r|t jkrd}|s| }|r||krd}|r|j| q*|st|j|jd }|j|||j|_|jdusJt |jD]u}t!|tj"tj#tj$tj%fr:|j&r:|j&d}t!|tj'r:t!|j(tj)r:t!|j(j(t*r:|j+t|j,t-t.|j/dt!|tj"tj#tj$frot0d d |j1D|j,d }|jt||j,dro|jt|t-t.|j/dqdS)zwParse the source to find the interesting facts about its lines. A handful of attributes are updated. rFTNz%10s %5s %-20r %rr<:z([{z)]})rcss|]}|jVqdSr5lineno)r8dr-r-r.r;sz*PythonParser._raw_parse..)default)2rrMr$r r"rrr&printtokenizetok_namer7rtokenINDENTDEDENTOP intersectionrDaddNEWLINEr'stripCOMMENT ByteParserrr#rC_find_statements first_linesrastwalk isinstanceClassDef FunctionDefAsyncFunctionDefModulebodyExprvalueConstantr1r%rPr int end_linenomindecorator_list)r+indentexclude_indent excluding first_lineemptynestingtokgentoktypettextslineno_elinenoltextshould_excludel byte_parsernodefirstr-r-r. _raw_parse}s                   zPythonParser._raw_parsei)maxsizerPrcCs2|dkr|j| |  }|S|j||}|S)zAReturn the first line number of the statement including `lineno`.rr6)r+rPr-r-r.rts zPythonParser.first_linelinenosIterable[TLineNo]csfdd|DS)zMap the line numbers in `linenos` to the correct first line of the statement. Returns a set of the first lines. csh|]}|qSr-rtr8rr:r-r. sz+PythonParser.first_lines..r-)r+rr-r:r.raszPythonParser.first_lineslinescCs ||S)z)Implement `FileReporter.translate_lines`.)ra)r+rr-r-r.translate_lines zPythonParser.translate_linesarcsIterable[TArc] set[TArc]csfdd|DS)z(Implement `FileReporter.translate_arcs`.cs$h|]\}}||fqSr-r)r8abr:r-r.rs$z.PythonParser.translate_arcs..)fix_with_jumps)r+rr-r:r.translate_arcsszPythonParser.translate_arcsc Csz t|j|_|Wn4tjttfyA}z$t |dr"|j }n|j dd}t d|j d|j dd||d}~ww|j|jB}|j|}||||_dS)zParse source text to find executable lines, excluded lines, etc. Sets the .excluded and .statements attributes, normalized to the first line of multi-line statements. rPr<rzCouldn't parse 'z' as Python source: z at line N)rbparserrrrT TokenErrorIndentationError SyntaxErrorhasattrrPargsrrr"r%r#rar!)r+r,rPignorestartsr-r-r. parse_sources&    zPythonParser.parse_sourcecCs&|jdur ||jdusJ|jS)zGet information about the arcs available in the code. Returns a set of line number pairs. Line numbers have been normalized to the first line of multi-line statements. N)r( _analyze_astr:r-r-r.rs zPythonParser.arcscCs|jdusJt|j|j|j|j}||j}||_|jr&| |}t |_ |D]\}}| |}| |}||krF|j ||fq,|j|_dS)zkRun the AstArcAnalyzer and save its results. `_all_arcs` is the set of arcs in the code. N)rAstArcAnalyzerrr#r'analyzerwith_jump_fixersr*rr r(rtr[missing_arc_fragmentsr))r+aaarl1l2fl1fl2r-r-r.r%s      zPythonParser._analyze_astcCst}t}|D]@}||jvrH|d}|||j|\}}||jvr:|||j|\}}||||jvs$|||df||qt||B|}|S)aAdjust arcs to fix jumps leaving `with` statements. Consider this code: with open("/tmp/test", "w") as f1: a = 2 b = 3 print(4) In 3.10+, we get traces for lines 1, 2, 3, 1, 4. But we want to present it to the user as if it had been 1, 2, 3, 4. The arc 3->1 should be replaced with 3->4, and 1->4 should be removed. For this code, the fixers dict is {(3, 1): ((1, 4), (3, 4))}. The key is the actual measured arc from the end of the with block back to the start of the with-statement. The values are start_next (the with statement to the next statement after the with), and end_next (the end of the with-statement to the next statement after the with). With nested with-statements, we have to trace through a few levels to correct a longer chain of arcs. rr<)r r*r[)r+r to_removeto_addarcend0 start_nextend_nextr-r-r.r<s"       zPythonParser.fix_with_jumpsdict[TLineNo, int]cCsftt}|D]'\}}|dksJd|d|j||jvr"q ||jvr(q ||d7<q |S)zYGet a count of exits from that each line. Excluded lines are excluded. rzl1=z should be greater than zero in r<) collections defaultdictrmrrr")r+ exit_countsrrr-r-r.rds   zPythonParser.exit_counts action_msgrJcCs*|dur |dkr d}nd}|j|d}|S)z=Apply some defaulting and formatting to an arc's description.Nrzjump to the function exitzjump to line {lineno}rO)format)r+rrJr-r-r._finish_action_msgxs  zPythonParser._finish_action_msgrIcCs|jdur||jdusJ|j||fdg}g}|D]&\}}|||}d|d|}|dur?|d|j|d7}||qd|S)z5Provide an English sentence describing a missing arc.NNNzline z didn't z because rOz or )r)rr7rrappendjoin)r+rIrJfragment_pairsmsgsmissing_cause_msgrmsgr-r-r.missing_arc_descriptions     z$PythonParser.missing_arc_descriptioncCsL|jdur||jdusJ|j||fdg}||dd|}|S)z2Provide an English description of an arc's effect.Nrrr<)r)rr7r)r+rIrJrrr-r-r.arc_descriptions zPythonParser.arc_description)NNN)rrrrrrrr)r0r1rr2rr)rPrrr)rrrr2)rrrr2)rrrr)rr)rr)rrrJrrr1)rIrrJrrr1)__name__ __module__ __qualname____doc__r/rMr functools lru_cachertrarrrrrrrrrrr-r-r-r.rs,  ?  j      (   rc@s>eZdZdZ  ddd d ZdddZdddZdddZdS)r_z3Parse bytecode to understand the structure of code.Nrr1codeCodeType | NonerrrrcCs:||_|dur ||_dS|dusJt||ddd|_dS)NexecT) dont_inherit)rrcompile)r+rrrr-r-r.r/s   zByteParser.__init__Iterable[ByteParser]csfddtjDS)a|Iterate over all the code objects nested within this one. The iteration includes `self` as its first value. We skip code objects named `__annotate__` since they are deferred annotations that usually are never run. If there are errors in the annotations, they will be caught by type checkers or other tools that use annotations. c3s(|]}|jdkrtj|dVqdS) __annotate__)rN)co_namer_r)r8cr:r-r.r;s  z+ByteParser.child_parsers..)r rr:r-r:r. child_parserss zByteParser.child_parsersrccs&|jD] \}}}|r|VqdS)zyYield the line numbers possible in this code object. Uses co_lines() to produce a sequence: l0, l1, ... N)rco_lines)r+r{liner-r-r. _line_numberss zByteParser._line_numbersccs"|D] }|EdHqdS)zFind the statements in `self.code`. Produce a sequence of line numbers that start statements. Recurses into all code objects reachable from `self.code`. N)rr)r+bpr-r-r.r`s zByteParser._find_statementsr)rr1rrrrrr)rr)rr)rrrrr/rrr`r-r-r-r.r_s   r_T)frozenorderc@s&eZdZUdZded<dZded<dS)ArcStarta?The information needed to start an arc. `lineno` is the line number the arc starts from. `cause` is an English text fragment used as the `missing_cause_msg` for AstArcAnalyzer.missing_arc_fragments. It will be used to describe why an arc wasn't executed, so should fit well into a sentence of the form, "Line 17 didn't run because {cause}." The fragment can include "{lineno}" to have `lineno` interpolated into it. As an example, this code:: if something(x): # line 1 func(x) # line 2 more_stuff() # line 3 would have two ArcStarts: - ArcStart(1, "the condition on line 1 was always true") - ArcStart(1, "the condition on line 1 was never true") The first would be used to create an arc from 1 to 3, creating a message like "line 1 didn't jump to line 3 because the condition on line 1 was always true." The second would be used for the arc from 1 to 2, creating a message like "line 1 didn't jump to line 2 because the condition on line 1 was never true." rrPr1causeN)rrrr__annotations__rr-r-r-r.rs rc@s eZdZdZ  d dd d ZdS) TAddArcFnz&The type for AstArcAnalyzer.add_arc().NrIrrJrrrrrcCdS)ab Record an arc from `start` to `end`. `missing_cause_msg` is a description of the reason the arc wasn't taken if it wasn't taken. For example, "the condition on line 10 was never true." `action_msg` is a description of what the arc does, like "jump to line 10" or "exit from function 'fooey'." Nr-r+rIrJrrr-r-r.__call__szTAddArcFn.__call__r rIrrJrrrrrrr)rrrrrr-r-r-r.rs rc@s8eZdZdZddd Zdd d Zdd d ZdddZdS)Blocka; Blocks need to handle various exiting statements in their own ways. All of these methods take a list of exits, and a callable `add_arc` function that they can use to add arcs if needed. They return True if the exits are handled, or False if the search should continue up the block stack. exits set[ArcStart]add_arcrrboolcCr)zProcess break exits.Fr-r+rrr-r-r.process_break_exits%zBlock.process_break_exitscCr)zProcess continue exits.Fr-rr-r-r.process_continue_exits)rzBlock.process_continue_exitscCr)zProcess raise exits.Fr-rr-r-r.process_raise_exits-rzBlock.process_raise_exitscCr)zProcess return exits.Fr-rr-r-r.process_return_exits1rzBlock.process_return_exitsNrrrrrr)rrrrrrrrr-r-r-r.rs   rc@s.eZdZdZdddZdd dZdddZdS) LoopBlockz@A block on the block stack representing a `for` or `while` loop.rIrrrcCs||_t|_dSr5)rIr break_exitsr+rIr-r-r.r/9s zLoopBlock.__init__rrrrrcCs|j|dSNT)rrCrr-r-r.r?s zLoopBlock.process_break_exitscCs |D] }||j|j|jqdSr)rPrIrr+rrxitr-r-r.rCsz LoopBlock.process_continue_exitsN)rIrrrr)rrrrr/rrr-r-r-r.r6s   rc@s.eZdZdZddd ZdddZdddZdS) FunctionBlockz>A block on the block stack representing a function definition.rIrnamer1rrcC||_||_dSr5rIr)r+rIrr-r-r.r/L zFunctionBlock.__init__rrrrrcC,|D]}||j|j |jd|jqdS)Nzexcept from function TrPrIrrrr-r-r.rR z!FunctionBlock.process_raise_exitscCr)Nzreturn from function Trrr-r-r.r\rz"FunctionBlock.process_return_exitsN)rIrrr1rrr)rrrrr/rrr-r-r-r.rIs    rc@s$eZdZdZdddZdddZdS)TryBlockz6A block on the block stack representing a `try` block. handler_startTLineNo | None final_startrrcCrr5)rr)r+rrr-r-r.r/jrzTryBlock.__init__rrrrrcCs*|jdur|D] }||j|j|jqdSr)rrPrrr-r-r.rps zTryBlock.process_raise_exitsN)rrrrrrr)rrrrr/rr-r-r-r.rgs rrast.ASTrtuple[bool, bool]cCs|tjdrdt|jfStjdr(|jdvr%dt|jfS d StjdrGt|j tj rDt |j \}}|| fS d Stj drzdd|jD}tdd|D}|rwt|j tjrjtnt}d|dd|DfS d Sd S) zIs this a compile-time constant test expression? We don't try to mimic all of CPython's optimizations. We just have to handle the kinds of constant expressions people might actually use. r-T)TrueFalser __debug__cSsg|]}t|qSr-)is_constant_test_expr)r8vr-r-r. sz)is_constant_test_expr..css|]\}}|VqdSr5r-)r8is_constr{r-r-r.r;z(is_constant_test_expr..css|]\}}|VqdSr5r-)r8r{rr-r-r.r;r)FF)rbrlrrkNameidevalUnaryOprdopNotroperandBoolOpvaluesallOrany)r is_constantvalretsr r-r-r.rzs0    rc@seZdZdZdmd d ZdnddZdoddZdpddZdqddZeZ drddZ  dsdtd$d%Z dud'd(Z dvd)d*Z dwd+d,Zdxd.d/ZeZdyd1d2ZeZeZdzd4d5Zd{d6d7Zhd8Zd|d:d;Z  dsd}dBdCZd~dEdFZd~dGdHZd~dIdJZd~dKdLZddNdOZddPdQZeZddSdTZ ddVdWZ!e!Z"eZ#eZ$ddYdZZ%dd\d]Z&dd_d`Z'ddbdcZ(ddedfZ)e)Z*ddhdiZ+ddkdlZ,e,Z-dS)raAnalyze source text with an AST to find executable code paths. The .analyze() method does the work, and populates these attributes: `arcs`: a set of (from, to) pairs of the the arcs possible in the code. `missing_arc_fragments`: a dict mapping (from, to) arcs to lists of message fragments explaining why the arc is missing from execution:: { (start, end): [(missing_cause_msg, action_msg), ...], } For an arc starting from line 17, they should be usable to form complete sentences like: "Line 17 didn't {action_msg} because {missing_cause_msg}". NOTE: Starting in July 2024, I've been whittling this down to only report arc that are part of true branches. It's not clear how far this work will go. rr1 root_noderr!r2 multilinedict[TLineNo, TLineNo]rrcs||_||_fdd|D|_|_tttdd}|r:td|jtd|jtt j |jddd t |_ t t|_g|_t |_t |_t |_t |_tttd d|_dS) Ncsh|]}||qSr-)r7rrr-r.rz*AstArcAnalyzer.__init__..COVERAGE_AST_DUMP0z Statements: zMultiline map: T)include_attributesrqCOVERAGE_TRACK_ARCS)rrr!rrrmosgetenvrSrbdumpr rrrlistr block_stackcurrent_with_startsall_with_starts with_entries with_exitsdebug)r+rrr!rdump_astr-rr.r/s" zAstArcAnalyzer.__init__cCs@t|jD]}|jj}t|d|d}|dur||qdS)zFExamine the AST tree from `self.root_node` to determine possible arcs._code_object__N)rbrcr __class__rgetattr)r+r node_namecode_object_handlerr-r-r.rszAstArcAnalyzer.analyzedict[TArc, tuple[TArc, TArc]]csi}fddjD}jD]=fdd|D}|sqt|dks-Jd|d|}fddjD}|D]}|f||ff||f<q=q|S)aKGet a dict with data for fixing jumps out of with statements. Returns a dict. The keys are arcs leaving a with-statement by jumping back to its start. The values are pairs: first, the arc from the start to the next statement, then the arc that exits the with without going to the start. cs(h|]}|djvr|jvr|qS)r)r$r%r8rr:r-r.rs z2AstArcAnalyzer.with_jump_fixers..c h|] }|dkr|dqS)rr<r-r/rIr-r.r r<zExpected one arc, got z with start = cr0)r<rr-r/r1r-r.rr2)rr$lenpopr&)r+fixers with_nextsnextsnxtendsrJr-rr.rs   zAstArcAnalyzer.with_jump_fixersr ast.ModulecCsR||}|jr ||j}|D] }||j| |jdqdS||| dS)Nzexit the module) line_for_noderi process_bodyrrPrr+rrIrrr-r-r._code_object__Modules  z#AstArcAnalyzer._code_object__Moduleast.FunctionDefcCsD||}|jt||jd||j}|||jdS)Nr) r;r"rrrr<rirr4)r+rrIrr-r-r._code_object__FunctionDefs   z(AstArcAnalyzer._code_object__FunctionDef ast.ClassDefcCsB||}||j}|D]}||j| |jd|jq dS)Nz exit class )r;r<rirrPrrr=r-r-r._code_object__ClassDef s   z%AstArcAnalyzer._code_object__ClassDefNrIrrJrrrc Cs|jrtd|d|d|d|ttdd|j||f||jvr/|j||f|dus7|durE|j||f||fdSdS)z@Add an arc, including message fragments to use if it is missing.zAdding possible arc: (z, z): z )rJN) r'rSr rr[r#r%rrrr-r-r.rs  zAstArcAnalyzer.add_arcIterable[Block]cCs t|jS)z.Yield the blocks in nearest-to-farthest order.)reversedr"r:r-r-r.nearest_blocks!rzAstArcAnalyzer.nearest_blockscCsV|jj}ttttjgtft|d|d}|dur!||}n|j }|j ||S)z}What is the right line number to use for this node? This dispatches to _line__Node functions where needed. _line__N) r*rr rrrbASTrr+rPrr7)r+rr,handlerrr-r-r.r;%s zAstArcAnalyzer.line_for_nodecCs |jr |jdj}|S|j}|S)zSCompute first line number for things that can be decorated (classes and functions).r)rprP)r+rrPr-r-r._line_decorated;s  zAstArcAnalyzer._line_decorated ast.AssigncCs ||jSr5)r;rkr+rr-r-r. _line__AssignCs zAstArcAnalyzer._line__Assignast.DictcCs2|jr|jddur|jdjS|jdjS|jSNr)keysrPr rKr-r-r. _line__DictHs   zAstArcAnalyzer._line__Dictast.ListcCs|jr ||jdS|jSrN)eltsr;rPrKr-r-r. _line__ListVszAstArcAnalyzer._line__ListcCr)Nr<r-rKr-r-r. _line__Module\szAstArcAnalyzer._line__Module> rjPassAssertAssignDeleteGlobalImportNonlocal AnnAssign AugAssign ImportFromrcCsz|jj}ttttjgttft |d|d}|dur$||}|St j r3||j vr3t d|t||h}|S)aFind the set of arc starts that exit this node. Return a set of ArcStarts, exits from this node to the next. Because a node represents an entire sub-tree (including its children), the exits from a node can be arbitrarily complex:: if something(1): if other(2): doit(3) else: doit(5) There are three exits from line 1: they start at lines 1, 3 and 5. There are two exits from line 2: lines 3 and 5. _handle__Nz*** Unhandled: )r*rr rrrbrGr rr+r TESTING OK_TO_DEFAULT RuntimeErrorr;)r+rr,rH arc_startsr-r-r. node_exitsns  zAstArcAnalyzer.node_exitsriSequence[ast.AST] from_startArcStart | None prev_startsset[ArcStart] | NonecCsv|dur|dur t}n |h}n|dusJ|D] }||}||jvr%q|D] }||j||jq'||}q|S)aProcess the body of a compound statement. `body` is the body node to process. `from_start` is a single `ArcStart` that starts an arc into this body. `prev_starts` is a set of ArcStarts that can all be the start of arcs into this body. Only one of `from_start` and `prev_starts` should be given. Records arcs within the body by calling `self.add_arc`. Returns a set of ArcStarts, the exits from this body. N)r r;r!rrPrrd)r+rirfrh body_noderP prev_startr-r-r.r<s    zAstArcAnalyzer.process_bodyrcC&|D] }|||jrdSqdS)z0Add arcs due to jumps from `exits` being breaks.N)rErrr+rblockr-r-r.r z"AstArcAnalyzer.process_break_exitscCrl)z3Add arcs due to jumps from `exits` being continues.N)rErrrmr-r-r.rroz%AstArcAnalyzer.process_continue_exitscCrl)z0Add arcs due to jumps from `exits` being raises.N)rErrrmr-r-r.rroz"AstArcAnalyzer.process_raise_exitscCrl)z1Add arcs due to jumps from `exits` being returns.N)rErrrmr-r-r.rroz#AstArcAnalyzer.process_return_exits ast.BreakcC(||}t|dd}||htS)Nz*the break on line {lineno} wasn't executedr)r;rrr )r+rhere break_startr-r-r._handle__Break   zAstArcAnalyzer._handle__BreakcCs|j}|j}|j}|rHd}|D]}||}|dur$||kr$||||}q|dus-J||||}|jsHJd|jd|jd|j|dusNJt|hS)zBAdd arcs for things that can be decorated (classes and functions).NzOops: node.body = z in @)rPrpr;rrirr)r+r main_linelastdecsdec_node dec_startr-r-r._handle_decorateds     &  z AstArcAnalyzer._handle_decorated ast.ContinuecCrq)Nz-the continue on line {lineno} wasn't executedrr)r;rrr )r+rrscontinue_startr-r-r._handle__Continuervz AstArcAnalyzer._handle__Continueast.ForcCs||j}|jt|dt|dd}|j|j|d}|D] }||j ||j q|j }t |ts7J|j }t|dd}|jrQ|j|j|d}||O}|S|||S)Nr1z'the loop on line {lineno} never startedrrrfz)the loop on line {lineno} didn't complete)r;iterr"rrrr<rirrPrr4rdrorelser[)r+rrIrfrrmy_block else_exitsr-r-r. _handle__For s     zAstArcAnalyzer._handle__Forast.IfcCst||j}t|j\}}t}|r|r$t|dd}||j|j|dO}|r(|s8t|dd}||j|j|dO}|S)N-the condition on line {lineno} was never truerrr.the condition on line {lineno} was always true)r;testrr rr<rir)r+rrI constant_testrrrfr-r-r. _handle__If"s   zAstArcAnalyzer._handle__If ast.Matchc Cs||}|}t}|jD]!}||j}|||dt|dd}||j|j|dO}|}q |j}t|t j rC|j d}t|t j s8t|t j r\|jdur\|j}t|t j r\|jdusNt|t j ok|jduok|j du} | sw|t|dd|S)Nz+the pattern on line {lineno} always matchedz*the pattern on line {lineno} never matchedrrr)r;r casespatternrrr<rirdrbMatchOrpatternsMatchAsguardr[) r+rrIrFrcase case_startrfr had_wildcardr-r-r._handle__Match.s4       zAstArcAnalyzer._handle__Match ast.RaisecCrq)Nz*the raise on line {lineno} wasn't executedrr)r;rrr )r+rrs raise_startr-r-r._handle__RaiseL   zAstArcAnalyzer._handle__Raise ast.ReturncCrq)Nz+the return on line {lineno} wasn't executedrr)r;rrr )r+rrs return_startr-r-r._handle__ReturnSrzAstArcAnalyzer._handle__Returnast.Tryc Cs,|jr ||jd}nd}|jr||jd}nd}|dus&|dus&Jt||}|j|||}|j|jt|d}|jrGd|_ n|j t }|jro|jD]}||}d} t|| d} ||j|j| dO}qU|j rz|j|j |d}||O}|jr|j |} |j|j| d} |r| }|S)Nrrz3the exception caught by line {lineno} didn't happenrr)rh) handlersr; finalbodyrr"rr<rirrr4r r) r+rrr try_blockrIr handler_exits handler_node from_causerf final_from final_exitsr-r-r. _handle__TryZs>        zAstArcAnalyzer._handle__Try ast.Whilec Cs||j}}t|j\}}|jt|dt|dd}|j|j|d}|D] }| |j ||j q(t }|j } t| tsCJ|| jt|dd}|jr`|j|j|d} || O}|S|sg|||S)Nr1rrrrr)r;rrr"rrrr<rirrPrr r4rdrCrrr[) r+rrIto_toprr{rfrrrrr-r-r._handle__Whiles&     zAstArcAnalyzer._handle__Whileast.Withcstjjrfdd|jD}n|g}|D]}j|j|qj|j t |dd}|d}j |t |h}|rZ|D]} |j |j|j |fqE|}|S)Ncsg|]}|jqSr-)r; context_expr)r8itemr:r-r.rrz0AstArcAnalyzer._handle__With..rr)r PYBEHAVIORexit_with_through_ctxmgritemsr;r#r[r$r<rirremoverrPr&)r+rrrIr with_exitrr-r:r. _handle__Withs     zAstArcAnalyzer._handle__With) rr1rrr!r2rrrrr)rr.)rr:rr)rr?rr)rrArrrr)rrC)rrrr)rr?rr)rrJrr)rrMrr)rrQrr)rr:rr)rrrr)rirerfrgrhrirr)rrrr)rrprr)rr?rr)rr~rr)rrrr)rrrr)rrrr)rrrr)rrrr)rrrr)rrrr)rrrr).rrrrr/rrr>r@_code_object__AsyncFunctionDefrBrrEr;rIrL_line__ClassDefrP_line__FunctionDef_line__AsyncFunctionDefrSrTrardr<rrrrrur}_handle__ClassDefrr_handle__AsyncFor_handle__FunctionDef_handle__AsyncFunctionDefrrrrr_handle__TryStarrr_handle__AsyncWithr-r-r-r.rs`  &              & /           7  r)rrrr)6r __future__rrbrrrr>rVrTcollections.abcrr dataclassesrtypesrtypingrrr r coverager coverage.bytecoder coverage.debugr coverage.exceptionsrr coverage.miscrrcoverage.phystokensrcoverage.typesrrrr_rrdictr!tupler1 TArcFragmentsrrrrrrr-r-r-r.sH        ="