şg(SrSSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK r SSK J r J r SSKJr SSKJr SSKJrJrJrJr SSKJr SS KJr SS KJr SS KJrJr SS K J!r!J"r" SS K#J$r$ SSK%J&r&J'r' \!"\5r"SS5r("SS5r)\"SSS9"SS55r*"SS\5r+\,\&\-\.\\/\\/44r0"SS5r1"SS\15r2"SS\15r3"SS \15r4"S!S"\Rj5r6"S#S$5r7g)%zCode parsing for coverage.py.) annotationsN)IterableSequence) dataclass)CodeType)castCallableOptionalProtocol)env) code_objects) short_stack)NoSource NotPython)isolate_module nice_pair)generate_tokens)TArcTLineNoc \rSrSrSrSSSjjrSSjrSSjr\R"SS9SS j5r SS jr SS jr SS jr SS jrSSjrSSjrSSjr\RSSj5rS SjrS!SjrS!SjrSrg)" PythonParser!zParse code to find executable lines, excluded lines, etc. This information is all based on static analysis: no code execution is involved. NcU(dU(dS5eU=(d SUlUbXlOSSKJn U"UR5UlX0lSUl[5Ul [5Ul [5Ul [5Ul [5Ul SUl0UlSUlSUl0Ulg![a!n[ SURSU35UeSnAff=f) 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)filenametextcoverage.pythonrOSErrorrexclude _ast_rootset statementsexcludedraw_statements raw_excludedraw_docstrings show_tokens _multiline _all_arcs_missing_arc_fragments_with_jump_fixers)selfrrrrerrs P/var/www/blue/EV-Temp_rev04/venv/lib/python3.13/site-packages/coverage/parser.py__init__PythonParser.__init__(sxM!MM ,H  !I 9 Y-dmm<  *. ),'*e -0E+.%-0E!35,0<@#@BQ Y!6t}}oSNOUXX YsC C5C00C5c ^[5nSnSn[R"UTR[RS9HnUR 5upgUTRR SX65-nUTRR SX75-n URU4Sj[US-U S-555 UnUnM U$)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 c3X># UH nTRRX5v M" g7fNr(get).0ir,s r. .PythonParser.lines_matching..vs%b>a4??..q44>as'*) r!refinditerr MULTILINEspancountupdaterange) r,regexmatches last_startlast_start_linematchstartend start_lineend_lines ` r.lines_matchingPythonParser.lines_matchingfs!$ [[ FEJE(499??4+SSJ&z)OOH NNbeJQRNT\_`T`>ab bJ(O Gc  UR(a:URUR5Ul[UR5UlSnSnSnSnSnSnUR ce[ UR 5nUGHupupupn UR(aD[[RRX5<SS[X45<SSU <SSU <35 U[R:XaUS - nOU[R:XaUS -nOU[R :XayU S :Xa[US:XaUURR#[%XLS -55nU(d&U(aURR'U 5 UnSnO]U S ;aUS - nOQU S ;aUS -nOEU[R(:Xa1U(a(X:wa#[%XLS -5HnX@R*U'M SnU R-5(dGMU[R.:wdGMSnU(aGMU nU(aX::aSnU(dGMURR'U 5 GM U(dG[1UR UR2S 9nUR4R7UR955 [:R<R>(a3UR*(a"[AUR45UR*S 'URCUR5UlURDce[FRH"URD5GH n[KU[FRL[FRN[FRP[FRR45(aURT(aURTSn[KU[FRV5(a[KURX[FRZ5(as[KURXRX[\5(aJUR^R7[%UR`[c[dURf5S -55 [KU[FRL[FRN[FRP45(dGMm[ASURh5UR`S9nURR#[%UUR`S -55(dGMURR7[%U[c[dURf5S -55 GM g)zgParse the source to find the interesting facts about its lines. A handful of attributes are updated. rFTNz>10 z>520r<:z([{z)]})rc36# UHoRv M g7fr5lineno)r8ds r.r:*PythonParser._raw_parse..s!H4Gq((4Gs)default)5rrNr%r!r#rrr'printtokenizetok_namer7rtokenINDENTDEDENTOP intersectionrDaddNEWLINEr(stripCOMMENT ByteParserrr$rC_find_statementsr PYBEHAVIORmodule_firstline_1min first_linesr astwalk isinstanceClassDef FunctionDefAsyncFunctionDefModulebodyExprvalueConstantstrr&rWrint end_linenodecorator_list)r,indentexclude_indent excluding first_lineemptynestingtokgentoktypettextslineno_elinenoltextshould_excludel byte_parsernodefirsts r. _raw_parsePythonParser._raw_parse{s << $ 3 3DLL AD  1 12DM  yy$$$ +AG =GLW,7%%))';w015%%,,&! ELL(! EHH$C> , ,!$T%8%8!9DOOA ((7 ~~)))HHT^^,D$s@T@TVYV`V` abb99 IIaLE"5#((33&u{{CLLAA&u{{'8'8#>>++22!%,,S%:J:J0Ka0OP $s@T@T UVV !HD4G4G!HRVR]R]^ ==--eJ a.PQQMM((z4T__;UXY;Y)Z[%-rPi)maxsizecUS:a!URRU*U*5*nU$URRX5nU$)zAReturn the first line number of the statement including `lineno`.rr6)r,rWs r.rPythonParser.first_linesJ A:oo))6'F7;;F __((8F rPcLUVs1sHo RU5iM sn$s snf)zrMap the line numbers in `linenos` to the correct first line of the statement. Returns a set of the first lines. )r)r,linenosrs r.rlPythonParser.first_liness#-44Gq"G444s!c$URU5$)z)Implement `FileReporter.translate_lines`.)rl)r,liness r.translate_linesPythonParser.translate_liness&&rPcURU5VVs1sH'up#URU5URU54iM) snn$s snnf)z(Implement `FileReporter.translate_arcs`.)fix_with_jumpsr)r,arcsabs r.translate_arcsPythonParser.translate_arcssAGKGZGZ[_G`aG`Va#T__Q%78G`aaas-Ac[R"UR5UlUR 5 URUR-nUR U- nUR#U5U- Ulg![ R [[4aen[US5(a URnOURSSn[SURS3URS<SU3-5UeSnAff=f)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. rWr<rzCouldn't parse 'z' as Python source: z at line N)rmparserr rr\ TokenErrorIndentationError SyntaxErrorhasattrrWargsrrr#r&r$rlr")r,r-rWignorestartss r. parse_sourcePythonParser.parse_sources  YYtyy1DN OO !4!44$$v-**62V;##%5{C sH%%!Q"4==/1EF88A;/6(34   s5A99C=A C88C=crURcUR5 URceUR$)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. )r) _analyze_astr,s r.rPythonParser.arcss4 >> !    ~~)))~~rPcRURce[URURURUR5nUR 5 UR n[RR(a7UR5Ul UR(aURU5n[5UlUHJup4URU5nURU5nXV:wdM.URR!XV45 ML UR"Ulg)z[Run the AstArcAnalyzer and save its results. `_all_arcs` is the set of arcs in the code. N)r AstArcAnalyzerrr$r(analyzerr riexit_through_withwith_jump_fixersr+rr!r)rrcmissing_arc_fragmentsr*)r,aaarl1l2fl1fl2s r.rPythonParser._analyze_ast&s ~~)))T]]DNND> + +%(%9%9%;D "%%**40FB//"%C//"%Cz""C:.  '*&?&?#rPc[5n[5nUHnX@R;dMUSnURU5 URUupgX`R;aDURU5 URUupgURU5 X`R;aMDURXWS45 URU5 M [U5U-U- nU$)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+rc)r,r to_removeto_addarcend0 start_nextend_nexts r.rPythonParser.fix_with_jumps>s0E C,,,1v c"'+'='=c'B$  $:$::MM*-+/+A+A*+M(JMM(+!$:$:: D1+./ j)D F"i/ rPc[R"[5nUR5HQup#US:dSU<SUR35eX R ;aM4X0R ;aMEX==S- ss'MS U$)zIGet a count of exits from that each line. Excluded lines are excluded. rzl1=z should be greater than zero in r<) collections defaultdictryrrr#)r, exit_countsrrs r.rPythonParser.exit_countsfsw+6*A*A#*F iikFB6 RcbU"B4==/R R6]]"]]" Oq O"rPc@Uc US:aSnOSnURUS9nU$)z=Apply some defaulting and formatting to an arc's description.rzjump to the function exitzjump to line {lineno}rV)format)r, action_msgrKs r._finish_action_msgPythonParser._finish_action_msgzs2  Qw8 4 &&c&2 rPcVURcUR5 URceURRX4S/5n/nUHGupVURXb5nSUSU3nUbUSUR US93- nUR U5 MI SR U5$)z5Provide an English sentence describing a missing arc.NNzline z didn't z because rVz or )r*rr7rrappendjoin)r,rJrKfragment_pairsmsgsmissing_cause_msgrmsgs r.missing_arc_description$PythonParser.missing_arc_descriptions  & & .    ..: ::4488% ~V-; ) 00AJ% 5C ,#4#;#;5#;#I"JKK KK  .<{{4  rPcURcUR5 URceURRX4S/5nURUSSU5nU$)z2Provide an English description of an arc's effect.rrr<)r*rr7r)r,rJrKrrs r.arc_descriptionPythonParser.arc_descriptionsj  & & .    ..: ::4488% ~V,,^A->q-A3G rP)r)r r*r(r+rr#rr&r%r$r'r"r)NNN)r str | NonerrrrreturnNone)rErxr set[TLineNo]rr)rWrrr)rIterable[TLineNo]rr)rrrr)rzIterable[TArc]r set[TArc])rr)rzdict[TLineNo, int])rrrKrrrx)rJrrKrrrx)__name__ __module__ __qualname____firstlineno____doc__r/rNr functools lru_cacherrlrrrrrrrrrr__static_attributes__rPr.rr!s #" <C<C<C <C  <C|*k\Z&'5'b<0 @0&P&!&rPrcV\rSrSrSrS S SjjrS SjrS SjrS SjrSr g) rgiz3Parse bytecode to understand the structure of code.NcNXlUbX lgUce[XSSS9Ulg)NexecT) dont_inherit)rcodecompile)r,rrrs r.r/ByteParser.__init__s2   I' '' TJDIrPcB^U4Sj[TR55$)aLIterate 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. c3n># UH+nURS:wdM[TRUS9v M- g7f) __annotate__)rN)co_namergr)r8cr,s r.r:+ByteParser.child_parsers..s1 ,yyN* *Jtyyq ),s55)r rrs`r. child_parsersByteParser.child_parserss !$)),  rPc## [URS5(a2URR5Hu pU(dMUv M gURRSSS2nURRSSS2nSnURRnSn[ X45H*upU(aXe:waUv UnXx- nU S:aU S-n Xi- nM, Xe:waUv gg7f)zYield the line numbers possible in this code object. Uses co_lnotab described in Python/compile.c to find the line numbers. Produces a sequence: l0, l1, ... co_linesrNr=r<)rrr co_lnotabco_firstlinenozip) r,rlinebyte_incrementsline_increments last_line_numline_numbyte_num byte_incr line_incrs r. _line_numbersByteParser._line_numberss 499j ) )"ii002 14J3 #ii11!$Q$7O"ii11!$Q$7O Myy//HH(+O(M$ 0&(0 )H$&I%)N()s AC&BC&c#n# UR5HnUR5ShvN M gN 7f)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,bps r.rhByteParser._find_statementss/$$&B'') ) )' )s '53 5)rrr)rrxrzCodeType | Nonerrrr)rzIterable[ByteParser])rr) rrrrrr/rr rhrrrPr.rgrgsL= !%# K K K K  K "> *rPrgT)frozenorderc2\rSrSr%SrS\S'SrS\S'Srg ) ArcStartiaThe 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." rrWrxcauserN)rrrrr__annotations__rrrrPr.rrs8 OE3OrPrc<\rSrSrSrSSSjjrSrg) TAddArcFniz&The type for AstArcAnalyzer.add_arc().Ncg)a* 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'." Nrr,rJrKrrs r.__call__TAddArcFn.__call__srPrr rJrrKrrrrrrr)rrrrrrrrrPr.rrsG0 )-!%    &       rPrc@\rSrSrSrS SjrS SjrS SjrS SjrSr g) Blocki.a# 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. cg)zProcess break exits.Frr,exitsadd_arcs r.process_break_exitsBlock.process_break_exits8rPcg)zProcess continue exits.Frrs r.process_continue_exitsBlock.process_continue_exits<r$rPcg)zProcess raise exits.Frrs r.process_raise_exitsBlock.process_raise_exits@r$rPcg)zProcess return exits.Frrs r.process_return_exitsBlock.process_return_exitsDr$rPrNr  set[ArcStart]r!rrbool) rrrrrr"r&r)r,rrrPr.rr.srPrc6\rSrSrSrSSjrS SjrS SjrSrg) LoopBlockiIz@A block on the block stack representing a `for` or `while` loop.c.Xl[5Ulgr5)rJr! break_exits)r,rJs r.r/LoopBlock.__init__Ks *-%rPc:URRU5 gNT)r4rCrs r.r"LoopBlock.process_break_exitsQs &rPcfUH+nU"URURUR5 M- gr7)rWrJrr,r r!xits r.r& LoopBlock.process_continue_exitsUs'C CJJ CII 6rP)r4rJN)rJrrrr.) rrrrrr/r"r&rrrPr.r2r2IsJ0 rPr2c6\rSrSrSrSSjrS SjrS SjrSrg) FunctionBlocki[z>A block on the block stack representing a function definition.cXlX lgr5rJname)r,rJrAs r.r/FunctionBlock.__init__]s   rPcUH;nU"URUR*URSUR<35 M= g)Nzexcept from function TrWrJrrAr:s r.r)!FunctionBlock.process_raise_exitsc<C  TZZK' }5  rPcUH;nU"URUR*URSUR<35 M= g)Nzreturn from function TrDr:s r.r,"FunctionBlock.process_return_exitskrFrP)rArJN)rJrrArxrrr.) rrrrrr/r)r,rrrPr.r>r>[sH rPr>c,\rSrSrSrSSjrSSjrSrg) TryBlockitz6A block on the block stack representing a `try` block.cXlX lgr5) handler_start final_start)r,rLrMs r.r/TryBlock.__init__vs*&rPcURb1UH+nU"URURUR5 M- gr7)rLrWrr:s r.r)TryBlock.process_raise_exits|s5    ) D$6$6 BrP)rMrLN)rLTLineNo | NonerMrQrrr.)rrrrrr/r)rrrPr.rJrJts@' rPrJc"\rSrSrSrSSjrSrg)NodeListizA synthetic fictitious node, containing a sequence of nodes. This is used when collapsing optimized if-statements, to represent the unconditional execution of one of the clauses. c8XlUSRUlgNrrtrW)r,rts r.r/NodeList.__init__s 1gnn rPrVN)rtSequence[ast.AST]rr)rrrrrr/rrrPr.rSrSs  %rPrSc\rSrSrSrS,SjrS-SjrS.SjrS/SjrS0Sjr \ r S1Sjr S2S3S jjr S4S jr S5S jrS6S jrS7Sjr\rS8Sjr\r\rS9SjrS:Sjr1SkrS;SjrS2SSjrS?SjrS@SjrSASjrSBSjrSBSjr SBSjr!SBSjr"SCSjr#SDSjr$\$r%SES jr&SFS!jr'\'r(\$r)\$r*SGS"jr+\,RZS#:aSHS$jr.SIS%jr/SJS&jr0SKS'jr1SLS(jr2SMS)jr3SNS*jr4\4r5S+r6g )OriaAnalyze 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. cXlX lUVs1sHoTRXU5iM snUlX@l[ [ [R"SS555nU(aY[SUR35 [SUR35 [[R"URSSS95 [5Ul [R"[ 5Ul/Ul[5Ul[5Ul[5Ul[5Ul[ [ [R"SS555Ulgs snf) NCOVERAGE_AST_DUMP0z Statements: zMultiline map: T)include_attributesr|COVERAGE_TRACK_ARCS)r root_noder7r" multiliner0ryosgetenvr[rmdumpr!rrrlistr block_stackcurrent_with_startsall_with_starts with_entries with_exitsdebug)r,rr`r"rardump_asts r.r/AstArcAnalyzer.__init__s! "8BC 1==. C"BII&93?@A  L 12 3 ODNN#34 5 #((4>>d1M N"u 4?4K4KD4Q"(* 25 -0U'*u%(U#bii(=sCDE 7DsE!c[R"UR5H6nURRn[ USU-S5nUcM.U"U5 M8 g)zFExamine the AST tree from `self.root_node` to determine possible arcs._code_object__N)rmrnr` __class__rgetattr)r,r node_namecode_object_handlers r.rAstArcAnalyzer.analyzesKHHT^^,D//I")$0@90Ld"S ".#D) -rPc0nURVs1sH+nUSUR;dMX R;dM)UiM- nnURHnUVs1sHo"SU:XdM USiM nnU(dM*[U5S:XdSUSU<35eUR 5nUR Vs1sHo"SU:XdM USiM nnUH nXF4X44XU4'M M U$s snfs snfs snf)a#Get 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. rr<zExpected one arc, got z with start = )rrhrilenpoprj) r,fixersr with_nextsrJnextsnxtendsrKs r.rAstArcAnalyzer.with_jump_fixerssyy  1v--- 25=N=N2N    ))E'1EzVu_VSVzEEu:? T&rArrtr,rwr,rrJr s r._code_object__FunctionDef(AstArcAnalyzer._code_object__FunctionDefsc""4(  E JK!!$)), !!%( rPcURU5nURUR5nUH:nURURU*UR SUR <35 M< g)Nz exit class )rrrtr!rWrrArs r._code_object__ClassDef%AstArcAnalyzer._code_object__ClassDefsW""4(!!$)),C LLeVSYY+dii]8S TrPNc XUR(a+[SUSUSU<SU<35 [[5SS9 URR X45 XR ;aUR R X45 UcUb!URX4RX445 gg)z@Add an arc, including message fragments to use if it is missing.zAdding possible arc: (z, z): z )rKN) rkr[rrrcrgrirrrs r.r!AstArcAnalyzer.add_arc s :: *5'C5> , , YY%%diil3 3rP> ruPassAssertAssignDeleteGlobalImportNonlocal AnnAssign AugAssign ImportFromcnURRn[[[[ R /[[4[USU-S55nUb U"U5nU$[R(aX R;a[SU35e[URU551nU$)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: )rprrr r rmrr!rrqr TESTING OK_TO_DEFAULT RuntimeErrorr)r,rrrr arc_startss r. node_exitsAstArcAnalyzer.node_exitshs"NN++  XswwiX67 8 D+ 14 8    J {{$6$66&'?@@#4#5#5d#;<=JrPc^UcUc [5nO U1nOUbeUHnURU5nXPR;a)URU5nUcM9UnURU5nUH)nUR UR XWR 5 M+ URU5nM U$)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. )r!rr"find_non_missing_noder!rWrr)r,rt from_start prev_starts body_noderWmaybe_body_node prev_starts r.rAstArcAnalyzer.process_bodys(  !!e )l % %%I'' 2F__,"&"<">+rPcpURU5n[USS9nURU15 [5$)Nz*the break on line {lineno} wasn't executedr)rrr"r!)r,rhere break_starts r._handle__BreakAstArcAnalyzer._handle__Break=s6!!$'t+WX    +/u rPcURnURnURnU(aSnUH/nURU5nUbXc:waURX65 UnM1 UceURX25 UnUR(d/SUR<SUR SUR35eUce[ U51$)zBAdd arcs for things that can be decorated (classes and functions).NzOops: node.body = z in @)rWr{rr!rtrr)r,r main_linelastdecsdec_node dec_starts r._handle_decorated AstArcAnalyzer._handle_decoratedCs![[ #{{"" D  ..x8 # (9LL1  ! # ## LL )D 99 V 3tyynDq V V9rPcpURU5n[USS9nURU15 [5$)Nz-the continue on line {lineno} wasn't executedr)rrr&r!)r,rrcontinue_starts r._handle__Continue AstArcAnalyzer._handle__Continue]s7!!$'!$.]^ ##^$45u rPc8URUR5nURR[ US95 [ USS9nUR URUS9nUH)nURURX%R5 M+ URR5n[U[5(deURn[ USS9nUR(a UR URUS9nXG-nU$URU5 U$)NrJz'the loop on line {lineno} never startedrrz)the loop on line {lineno} didn't complete)riterrfrr2rrrtr!rWrrwror4rrc)r,rrJrr r;my_block else_exitss r. _handle__ForAstArcAnalyzer._handle__Forcs""499-   67e+TU !!$)) !CC LLUII 6##'')(I....$$e+VW ;;**4;;:*NJ  E  IIj ! rPcURUR5n[USS9nURURUS9n[USS9nX@RUR US9-nU$)N-the condition on line {lineno} was never truerr.the condition on line {lineno} was always true)rrrrrtr)r,rrJrr s r. _handle__IfAstArcAnalyzer._handle__If|sj""499-e+Z[ !!$)) !Ce+[\  ""4;;:"FF rP) cZURU5nUn[5nURHXnURUR5nUR X6S5 [ USS9nX@R URUS9-nUnMZ WRn[U[R5(a0URSn[U[R5(aM0[U[R5(aGURb:URn[U[R5(aURbM:[U[R5=(a# URSL=(a URSLn U (dUR[ WSS95 U$)Nz+the pattern on line {lineno} always matchedz*the pattern on line {lineno} never matchedrr)rr!casespatternr!rrrtrormMatchOrpatternsMatchAsguardrc) r,rrJrGr case case_startrr had_wildcards r._handle__MatchAstArcAnalyzer._handle__MatchsZ&&t,EJEE !// =  Z5bc%F **499*LL' #llGWckk22!**2.Wckk22Wckk22w7R!//Wckk22w7R7CKK0'OOt+'JJ$&    Z/\]LrPcnURU5nURUR[U5S9nU$)Nr)rrrtrrs r._handle__NodeList AstArcAnalyzer._handle__NodeLists4""4(!!$))!H rPcpURU5n[USS9nURU15 [5$)Nz*the raise on line {lineno} wasn't executedr)rrr)r!)r,rr raise_starts r._handle__RaiseAstArcAnalyzer._handle__Raises6!!$'t+WX    +/u rPcpURU5n[USS9nURU15 [5$)Nz+the return on line {lineno} wasn't executedr)rrr,r!)r,rr return_starts r._handle__ReturnAstArcAnalyzer._handle__Returns6!!$',YZ  !!<.1u rPcUR(aURURS5nOSnUR(aURURS5nOSnUcUce[X#5nURR U5 URU5nUR UR[U5S9nUR(aSUl OURR5 [5nUR(aKURH;nURU5nSn [X)S9n XpR URU S9-nM= UR(aUR URUS9nXg-nUR(a?URR5 Un UR URU S9n U(aU nU$)Nrrz3the exception caught by line {lineno} didn't happenr)r) handlersr finalbodyrJrfrrrtrrLrwr!r) r,rrLrM try_blockrJr  handler_exits handler_node from_causer final_from final_exitss r. _handle__TryAstArcAnalyzer._handle__Trys == ..t}}Q/?@M M >>,,T^^A->?KK(K,CCC]8   *""4(!!$))!H >>&*I #    "'*u == $ $ 2 2< @ R %mF !2!2<3D3DQ[!2!\\ !. ;;%%dkku%EE  >>    "J++DNN +SK$ rPcRURUR5=p#URUR5nSnU(aSn[RR (aSnU(aURUR S5nURR[US95 [USS9nURUR US9nUH)nURURX8R5 M+ [5nURR!5n [#U [5(deUR%U R&5 [USS9nUR((a URUR(US9n Xz-nU$U(dUR+U5 U$) NFTrrr rrr )rrrr rikeep_constant_testrtrfrr2rrr!rWrr!rwrorCr4rrc) r,rrJto_top constant_test top_is_body0rr r;rrs r._handle__WhileAstArcAnalyzer._handle__WhilesX++DII66--dii8  L >> , , L '' ! 5F   78e+Z[ !!$)) !CC LLVYY 7##'')(I.... X))*e+[\ ;;**4;;:*NJ  E  ! *% rPc"[RR(a4URVs/sHo R UR 5PM nnOUR U5/n[RR (a?UH9nURRU5 URRU5 M; URUR[US5S9n[RR (aUSnURRU5 [U51nU(aNUHFnURURU5 UR RURU45 MH UnU$s snf)Nrr)r riexit_with_through_ctxmgritemsr context_exprrrgrcrhrrtrremover!rWrj)r,ritemrrJr  with_exitr;s r. _handle__WithAstArcAnalyzer._handle__With s0 >> 2 2HL S (():):; FSF((./F >> + +((,,U3$$((/ !!$))8L!M >> + +2JE  $ $ + +E 2!%)I CLLU3OO''U(;<!" )Ts#F ) rhrrfrgrkrrrar`r"rirj) rrxr`ast.ASTr"rrazdict[TLineNo, TLineNo]rrr)rzdict[TArc, tuple[TArc, TArc]])r ast.Modulerr)rast.FunctionDefrr)rz ast.ClassDefrrrr)rzIterable[Block])rrErr)rrGrr)rz ast.Assignrr)rzast.Dictrr)rzast.Listrr)rrFrr)rrErr/)rtrXrzArcStart | Nonerzset[ArcStart] | Nonerr/)rrErast.AST | None)rast.IfrrH)rrSrrH)r ast.WhilerrH)rrErr)r r/rr)rz ast.Breakrr/)rrGrr/)rz ast.Continuerr/)rzast.Forrr/)rrIrr/)rz ast.Matchrr/)rrSrr/)rz ast.Raiserr/)rz ast.Returnrr/)rzast.Tryrr/)rrJrr/)rzast.Withrr/)7rrrrrr/rrrr_code_object__AsyncFunctionDefrr!rrrr_line__ClassDefr_line__FunctionDef_line__AsyncFunctionDefrrrrrrrrrrr"r&r)r,rr_handle__ClassDefrr _handle__AsyncFor_handle__FunctionDef_handle__AsyncFunctionDefrsys version_inforr r$r(r3r:rC_handle__AsyncWithrrrPr.rrs($F$F$F! $F * $F  $FL*>(&?"U)-!% ]]]& ]  ]  ]$*.,.&O )- M !L'+,0 ))$)* )  )VB . 2   "  0* (%, 1 7" @ 5n:0'rPr)8r __future__rrmrrrbr>rSr^r\collections.abcrr dataclassesrtypesrtypingrr r r coverager coverage.bytecoder coverage.debugrcoverage.exceptionsrr coverage.miscrrcoverage.phystokensrcoverage.typesrrrrgrrdictretuplerx TArcFragmentsrr2r>rJrrSrrrPr.res $"  .!55*&33/(B~~B K*K*d $d#$B  ,T4hsmXc]&B CDDE 6$E2 u  %sww %S 'S 'rP