o ~Z @sdZddlZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z m Z ddl mZddlmZddlmZmZmZmZmZdd lmZmZmZdd lmZmZmZGd d d eZGd ddeZ GdddeZ!GdddeZ"GdddeZ#Gddde$ddZ%eddde&e'ej()ddZ*GdddeZ+Gdd d eZ,e*rd!gZ-d"d#Z.d&d$d%Z/dSdS)'zCode parsing for coverage.py.N)env)range) bytes_to_ints string_class) CodeObjects) short_stack)contract join_regex new_contract nice_pairone_of)NoSource NotPythonStopEverything)compile_unicodegenerate_tokensneuter_encoding_declarationc@seZdZdZedddddZeddZd d Zd d Z d dZ ddZ ddZ ddZ ddZddZddZddZd ddZdS)! PythonParserzParse code to find executable lines, excluded lines, etc. This information is all based on static analysis: no code execution is involved. z unicode|NonetextNc Cs|s|sJd|p d|_||_|js7ddlm}z||j|_Wnty6}z td|j|fd}~ww||_|jd|_t |_ t |_ t |_ t |_ t |_t |_d|_i|_d|_d|_d|_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. z*PythonParser needs either text or filenamezr)get_python_sourcezNo source for code: '%s': %sN F)filenamercoverage.pythonrIOErrorr excludesplitlinesset statementsexcludedraw_statements raw_excluded raw_classdefsraw_docstrings show_tokens _multiline _byte_parser _all_arcs_missing_arc_fragments)selfrrrrerrr,A/var/www/html/env/lib/python3.10/site-packages/coverage/parser.py__init__s4    zPythonParser.__init__cCs|js t|j|jd|_|jS)zCreate a ByteParser on demand.)r)r' ByteParserrrr*r,r,r- byte_parser\szPythonParser.byte_parsercGsXt|}tjr |d}t|}t}t|jddD]\}}| |r)| |q|S)zFind the lines matching one of a list of regexes. Returns a set of line numbers, the lines that contain a match for one of the regexes in `regexes`. The entire line needn't match, just a part of it. utf8start) r rPY2decoderecompiler enumeratersearchadd)r*regexescombinedregex_cmatchesiltextr,r,r-lines_matchingcs    zPythonParser.lines_matchingcCs|jr ||j|_d}d}d}d}tj}d}d}d}t|j} | D]\} } \} } \}} }|jrCtdt j | | t | |f| |f| tjkrM|d7}n| tj krW|d8}n}| tjkrg| dkrf|j| nm| tjkr| dkr||jvpv|}|s|r|j||}d}d}nL| d kr|r||jvrd}|r|j|n6| tjkr|tjkr|jt| |dn | tjkr|dur||krt||dD]}||j|<qd}d}| r| t jkrd}|dur| }|r||krd}|r|j|d}| }q"|s|j|jdSdS) zwParse the source to find the interesting facts about its lines. A handful of attributes are updated. rFNTz%10s %5s %-20r %rr3class:@)rrCr"tokenINDENTrrr%printtokenizetok_namegetr DEDENTNAMEr#r<OPSTRINGr$updaterNEWLINEr&stripCOMMENTr!r1_find_statements)r*indentexclude_indent excludingexcluding_decorators prev_toktype first_lineempty first_on_linetokgentoktypettextslineno_elinenorBshould_excludelr,r,r- _raw_parseusz                 zPythonParser._raw_parsecCs|j||S)z?Return the first line number of the statement including `line`.)r&rL)r*liner,r,r-r[szPythonParser.first_linecstfdd|DS)zMap the line numbers in `lines` to the correct first line of the statement. Returns a set of the first lines. c3s|]}|VqdSNr[.0rer0r,r- z+PythonParser.first_lines..)rr*rr,r0r- first_linesszPythonParser.first_linescCs ||S)z)Implement `FileReporter.translate_lines`.)rornr,r,r-translate_lines zPythonParser.translate_linescsfdd|DS)z(Implement `FileReporter.translate_arcs`.cs$g|]\}}||fqSr,ri)rkabr0r,r- s$z/PythonParser.translate_arcs..r,)r*arcsr,r0r-translate_arcsszPythonParser.translate_arcsc Csz|Wn,tjtfy2}zt|dr|j}n|jdd}td|j|jd|fd}~ww| |j |_ |j |j B}|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. linenor3r5Couldn't parse '%s' as Python source: '%s' at line %dN)rfrJ TokenErrorIndentationErrorhasattrrwargsrrror"r r$r!r)r*r+rwignorestartsr,r,r- parse_sources"    zPythonParser.parse_sourcecCs|jdur ||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_astr0r,r,r-rus zPythonParser.arcscCsjt|j|j|j}|t|_|jD]\}}||}||}||kr.|j ||fq|j |_ dS)zkRun the AstArcAnalyzer and save its results. `_all_arcs` is the set of arcs in the code. N) AstArcAnalyzerrr!r&analyzerr(rur[r<missing_arc_fragmentsr))r*aaal1l2fl1fl2r,r,r-r s   zPythonParser._analyze_astcCsvtt}|D]\}}|dkrq ||jvrq ||jvrq ||d7<q |jD]}||vr8||d8<q*|S)zYGet a count of exits from that each line. Excluded lines are excluded. rr3) collections defaultdictintrur r#)r* exit_countsrrrer,r,r-rs    zPythonParser.exit_countsc Cs|jdur ||}|r(|dkr(|| kr(||f|vr(||f|jvr(||}}|j||fdg}g}|D]F}|\}} | durZ|dkrX| |f|jvrU|| |Sd} nd} | j|d} dj|| d} |durw| d j|j|dd 7} || q6d |S) z5Provide an English sentence describing a missing arc.NrNNz didn't jump to the function exitzdidn't jump to line {lineno}rwzline {start} {emsg})r5emsgz, because {smsg})smsg or )r)rrLmissing_arc_descriptionformatappendjoin) r*r5end executed_arcs actual_startfragment_pairsmsgs fragment_pairrrmsgr,r,r-r7s2      z$PythonParser.missing_arc_description)NNNrh)__name__ __module__ __qualname____doc__rr.propertyr1rCrfr[rorprvrrurrrr,r,r,r-rs" = [  rc@s<eZdZdZeddd ddZddZd d Zd d ZdS)r/z3Parse bytecode to understand the structure of code.unicoderNc Csv||_|r ||_n!z t||d|_Wnty)}z td||j|jfd}~wwdD] }t|j|s8tdq,dS)Nexecrx) co_lnotabco_firstlinenozsThis implementation of Python doesn't support code analysis. Run coverage.py under another Python for this command.) rcoder SyntaxErrorrrrwr{r)r*rrrsynerrattrr,r,r-r.ds(  zByteParser.__init__cstj}fdd|DS)z~Iterate over all the code objects nested within this one. The iteration includes `self` as its first value. c3s|] }tj|dVqdS))rN)r/rrkcr0r,r-rlsz+ByteParser.child_parsers..)rr)r*childrenr,r0r- child_parsers|s zByteParser.child_parsersccst|jjddd}t|jjddd}d}|jj}d}t||D]\}}|r9||kr5||fV|}||7}||7}q$||krI||fVdSdS)a&Map byte offsets to line numbers in `code`. Uses co_lnotab described in Python/compile.c to map byte offsets to line numbers. Produces a sequence: (b0, l0), (b1, l1), ... Only byte offsets that correspond to line numbers are included in the results. rNr3)rrrrzip)r*byte_incrementsline_increments last_line_numline_numbyte_num byte_incr line_incrr,r,r- _bytes_liness    zByteParser._bytes_linesccs,|D]}|D]\}}|Vq qdS)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*bprbrer,r,r-rUs  zByteParser._find_statementsr) rrrrrr.rrrUr,r,r,r-r/as  r/c@s"eZdZdZeedddZdS) LoopBlockz@A block on the block stack representing a `for` or `while` loop.r4cCs||_t|_dSrh)r5r break_exits)r*r5r,r,r-r.s zLoopBlock.__init__N)rrrrrrr.r,r,r,r-rsrc@s$eZdZdZeeedddZdS) FunctionBlockz>A block on the block stack representing a function definition.r5namecCs||_||_dSrhr)r*r5rr,r,r-r.s zFunctionBlock.__init__N)rrrrrrstrr.r,r,r,r-r rc@s$eZdZdZedddddZdS)TryBlockz6A block on the block stack representing a `try` block.zint|None) handler_start final_startcCs0||_||_t|_t|_t|_t|_dSrh)rrr break_from continue_from return_from raise_from)r*rrr,r,r-r.s  zTryBlock.__init__N)rrrrrr.r,r,r,r-rrrcs"eZdZdZdfdd ZZS)ArcStartaThe information needed to start an arc. `lineno` is the line number the arc starts from. `cause` is an English text fragment used as the `startmsg` 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. Ncstt||||Srh)superr__new__)clsrwcause __class__r,r-rszArcStart.__new__rh)rrrrr __classcell__r,r,rr-rs rArcz lineno, cause ArcStartscCstdd|DS)Ncss|]}t|tVqdSrh) isinstancer)rkxr,r,r-rlrmz..)all)seqr,r,r-srCOVERAGE_AST_DUMPc@seZdZdZddZdS)NodeListzA 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. cCs||_|dj|_dSNr)bodyrw)r*rr,r,r-r.szNodeList.__init__N)rrrrr.r,r,r,r-rs rc@s~eZdZdZededddZddZdZd d Zd d Z ee d ddZ ddZ ddZ ddZddZegdZedd ddZededd dZddZdd Zd!d"Zd#d$Zd%d&Zedd'd(d)Zedd'd*d+Zedd'd,d-Zedd'd.d/Zedd d0d1Zedd d2d3ZeZedd d4d5Zedd d6d7Z e Z!eZ"eZ#edd d8d9Z$edd d:d;Z%edd dd?Z'edd d@dAZ(eddddBdCdDZ)edd dEdFZ*edd dGdHZ+edd dIdJZ,edd dKdLZ-e-Z.dMdNZ/dOdPZ0e0Z1dQdRZ2dSdTZ3e3dUZ4e3dVZ5e3dWZ6e3dXZ7e8j9r=e3dYZ:dSdS)[rz>Analyze source text with an AST to find executable code paths.r)rrcstt||_tfdd|D|_|_tr.td |jtd |jt |jt|_ t t|_g|_tttjdd|_dS)Nc3s|] }||VqdSrh)rLrj multiliner,r-rlz*AstArcAnalyzer.__init__..zStatements: {0}zMultiline map: {0}COVERAGE_TRACK_ARCSr)astparser root_noderrrAST_DUMPrIrast_dumprurrlistr block_stackboolrosenvironrLdebug)r*rrrr,rr-r.s  zAstArcAnalyzer.__init__cCs>t|jD]}|jj}t|d|d}|dur||qdS)zExamine the AST tree from `root_node` to determine possible arcs. This sets the `arcs` attribute to be a set of (from, to) line number pairs. _code_object__N)rwalkrrrgetattr)r*node node_namecode_object_handlerr,r,r-rszAstArcAnalyzer.analyzeNcCsh|jrtd||||ttdd|j||f|dus$|dur2|j||f||fdSdS)z@Add an arc, including message fragments to use if it is missing.z! Adding arc: ({}, {}): {!r}, {!r})limitN)rrIrrrur<rr)r*r5rrrr,r,r-add_arc#szAstArcAnalyzer.add_arccCs t|jS)z.Yield the blocks in nearest-to-farthest order.)reversedrr0r,r,r-nearest_blocks-rqzAstArcAnalyzer.nearest_blocks)returnscCs.|jj}t|d|d}|dur||S|jS)z}What is the right line number to use for this node? This dispatches to _line__Node functions where needed. _line__N)rrrrwr*rrhandlerr,r,r- line_for_node1s zAstArcAnalyzer.line_for_nodecCs ||jSrh)rvaluer*rr,r,r- _line__Assign?s zAstArcAnalyzer._line__AssigncCs<tjdkr|jr|jddur|jdjS|jdjS|jS)N)r)r PYVERSIONkeysrwvaluesrr,r,r- _line__DictBs   zAstArcAnalyzer._line__DictcCs|jr ||jdS|jSr)eltsrrwrr,r,r- _line__ListNszAstArcAnalyzer._line__ListcCs|jr ||jdSdS)Nrr3)rrrr,r,r- _line__ModuleTszAstArcAnalyzer._line__Module) AssignAssert AugAssignDeleteExecExprGlobalImport ImportFromNonlocalPassPrintrcCs>|jj}t|d|d}|dur||S tt||gS)aAdd the arcs for `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 two exits from line 1: they start at line 3 and line 5. _handle__N) rrr OK_TO_DEFAULTrIrrrrrr,r,r-add_arcsas zAstArcAnalyzer.add_arcszfrom_start, prev_startscCs|dur t|g}|D]5}||}|j||}||jvr-||}|dur(q ||}|D] }||j||jq/| |}q |S)auAdd arcs for the body of a compound statement. `body` is the body node. `from_start` is a single `ArcStart` that can be the previous line in flow before this body. `prev_starts` is a set of ArcStarts that can be the previous line. Only one of them should be given. Returns a set of ArcStarts, the exits from this body. N) rrrrLrfind_non_missing_noderrwrr)r*r from_start prev_starts body_noderwr[ prev_startr,r,r- add_body_arcss      zAstArcAnalyzer.add_body_arcscCsR||}|j||}||jvr|St|d|jjd}|r%||}|Sd}|S)aSearch `node` looking for a child that has not been optimized away. This might return the node you started with, or it will work recursively to find a child node in self.statements. Returns a node, or None if none of the node remains. _missing__N)rrrLrrrr)r*rrwr[ missing_fnr,r,r-rs  z$AstArcAnalyzer.find_non_missing_nodecCs2|t|j}|r |S|jr|t|jSdSrh)rrrorelse)r*r non_missingr,r,r- _missing__Ifs zAstArcAnalyzer._missing__IfcCsPg}|jD]}||}|dur||q|sdSt|dkr$|dSt|S)Nr3r)rrrlenr)r*rnon_missing_childrenchildr,r,r-_missing__NodeLists    z!AstArcAnalyzer._missing__NodeListcCs.|jj}|dvr dS|dkr|jdvrdSdS)z Is this a compile-time constant?) NameConstantNumr$Name)TrueFalseNone __debug__N)rrid)r*rrr,r,r-is_constant_exprs zAstArcAnalyzer.is_constant_expr)exitscCsT|D]#}t|tr|j|dSt|tr'|jdur'|j|dSqdS)z0Add arcs due to jumps from `exits` being breaks.N)rrrrrQrrr)r*r,blockr,r,r-process_break_exitss    z"AstArcAnalyzer.process_break_exitscCsf|D],}t|tr|D] }||j|j|jq dSt|tr0|jdur0|j |dSqdS)z3Add arcs due to jumps from `exits` being continues.N) rrrrrwr5rrrrrQr*r,r-xitr,r,r-process_continue_exitss   z%AstArcAnalyzer.process_continue_exitsc Cs|D]J}t|tr1|jdur"|D] }||j|j|jqdS|jdur0|j |dSqt|t rN|D]}||j|j |jd |j q8dSqdS)z0Add arcs due to jumps from `exits` being raises.Nz!didn't except from function '{0}')rrrrrrwrrrrQrr5rrr/r,r,r-process_raise_exitss&       z"AstArcAnalyzer.process_raise_exitsc Csr|D]2}t|tr|jdur|j|dSt|tr6|D]}||j|j |j d |j q dSqdS)z1Add arcs due to jumps from `exits` being returns.Nz!didn't return from function '{0}') rrrrrrQrrrwr5rrrr/r,r,r-process_return_exitss    z#AstArcAnalyzer.process_return_exitscC(||}t|dd}||gtS)Nz*the break on line {lineno} wasn't executedr)rrr.r)r*rhere break_startr,r,r-_handle__Break-   zAstArcAnalyzer._handle__BreakcCs||}|jrH|jD]}||}||kr||||}q |jrH||jd}|j||}t|d|D]}||jvrG||||}q8tt |gS)zBAdd arcs for things that can be decorated (classes and functions).rr3) rdecorator_listrrrrLrrrr)r*rlastdec_node dec_start body_startrwr,r,r-_handle_decorated4s"      z AstArcAnalyzer._handle_decoratedcCr4)Nz-the continue on line {lineno} wasn't executedr5)rrr1r)r*rr6continue_startr,r,r-_handle__ContinueNr9z AstArcAnalyzer._handle__ContinuecCs||j}|jt|dt|dd}|j|j|d}|D] }||j ||j q|j }|j }t|dd}|j rJ|j|j |d}||O}|S|||S)Nr4z'the loop on line {lineno} never startedr5rz)the loop on line {lineno} didn't complete)riterrrrrrrrrwrpoprrr<)r*rr5rr,r0my_block else_exitsr,r,r- _handle__ForUs     zAstArcAnalyzer._handle__ForcCsL||j}t|dd}|j|j|d}t|dd}||j|j|dO}|S)N-the condition on line {lineno} was never truer5rB.the condition on line {lineno} was never false)rtestrrrr)r*rr5rr,r,r,r- _handle__Ifns   zAstArcAnalyzer._handle__IfcC"||}|j|jt|d}|SNrBrrrrr*rr5r,r,r,r-_handle__NodeListw z AstArcAnalyzer._handle__NodeListcCr4)Nz*the raise on line {lineno} wasn't executedr5)rrr2r)r*rr6 raise_startr,r,r-_handle__Raise}   zAstArcAnalyzer._handle__RaisecCr4)Nz+the return on line {lineno} wasn't executedr5)rrr3r)r*rr6 return_startr,r,r-_handle__ReturnrTzAstArcAnalyzer._handle__ReturncCs|jr ||jd}nd}|jr||jd}nd}t||}|j|||}|j|jt|d}|jrEd|_ |jrDt g|_ n|j t }|jr{d}|jD]%} || }|durf| |||}d} t|| d} ||j| j| dO}qU|jr|j|j|d}||O}|jr|j ||jB|jB|j B|jB} |j|j| d} |jr|||j| |jr|||j| |j r|||j | |jr|||j| |r| }|S)NrrBz3the exception caught by line {lineno} didn't happenr5)r)handlersr finalbodyrrrrrrrrrrDrrrrrr._combine_finally_startsr1r2r3)r*rrr try_blockr5r, handler_exitslast_handler_start handler_node from_causer final_from final_exitsr,r,r- _handle__Trys|              zAstArcAnalyzer._handle__Try)r~r,rcsVg}t|D]}|jdur||jj|jdqd|tfdd|D}|S)aHelper for building the cause of `finally` branches. "finally" clauses might not execute their exits, and the causes could be due to a failure to execute any of the exits in the try block. So we use the causes from `starts` as the causes for `exits`. Nrrc3s|] }t|jVqdSrh)rrw)rkr0r5r,r-rlrz9AstArcAnalyzer._combine_finally_starts..)sortedrrrrwrr)r*r~r,causesr5r,r5r-rYs   z&AstArcAnalyzer._combine_finally_startscCsg|_||Srh)rXrarr,r,r-_handle__TryExcepts z!AstArcAnalyzer._handle__TryExceptcCsbg|_g|_|jd}|jjdkr,|j|jkr,t|jdks J|j|_|j|_|j|_||S)Nr TryExceptr3)rWrrrrrwrra)r*rfirstr,r,r-_handle__TryFinallys  z"AstArcAnalyzer._handle__TryFinallyc Cs||j}||j}}|rtjs|dkr||jd}|jt|dt |dd}|j |j|d}|D] }| |j ||j q8t}|j}||jt |dd}|jri|j |j|d} || O}|S|sp|||S)Nr$rr4rHr5rBrI)r+rJrrPY3rrrrrrrrwrrrDrQrrr<) r*r constant_testr5to_toprr,r0rErFr,r,r-_handle__While s(      zAstArcAnalyzer._handle__WhilecCrLrMrNrOr,r,r- _handle__With#rQzAstArcAnalyzer._handle__WithcCsj||}|jr%|j|jt| d}|D] }||j| |jdqdS|| |||| dS)NrBzdidn't exit the module)rrrrrrwrr*rr5r,r0r,r,r-_code_object__Module+s z#AstArcAnalyzer._code_object__ModulecCsN||}|jt||jd|j|jt| d}|||j dS)NrrB) rrrrrrrrr3rDrOr,r,r-_code_object__FunctionDef6s  z(AstArcAnalyzer._code_object__FunctionDefc CsX||}|| ||j|jt|d}|D]}||j| |jd|jqdS)NrBz#didn't exit the body of class '{0}') rrrrrrwrrrrmr,r,r-_code_object__ClassDef?s   z%AstArcAnalyzer._code_object__ClassDefcsfdd}|S)zFA function to make methods for online callable _code_object__ methods.c sB||}|| |dd|||| dd|dS)Nzdidn't run the {0} on line {1}z!didn't finish the {0} on line {1})rrr)r*rr5nounr,r-_code_object__oneline_callableKs  zPAstArcAnalyzer._make_oneline_code_method.._code_object__oneline_callabler,)rrrsr,rqr-_make_oneline_code_methodIs z(AstArcAnalyzer._make_oneline_code_methodlambdazgenerator expressionzdictionary comprehensionzset comprehensionzlist comprehensionr);rrrrrrr.rrrrrrrrrrrr rrrr"r+r.r1r2r3r8r?_handle__ClassDefrArG_handle__AsyncFor_handle__FunctionDef_handle__AsyncFunctionDefrKrPrSrVrarYrdrgrkrl_handle__AsyncWithrnro_code_object__AsyncFunctionDefrprt_code_object__Lambda_code_object__GeneratorExp_code_object__DictComp_code_object__SetComprrh_code_object__ListCompr,r,r,r-rs                        T         rctxcCs$|dgditfvpt|tttfS)z:Is `value` simple enough to be displayed on a single line?Nr,)rrrrfloat)rr,r,r-_is_simple_valueasrc Cs|d|}t|tjstd||jj|dSt|dd}|dur(d|j}nd}d||jj|}dd t |D}|sHtd |dSt |d krgt |d d rg|d \}}td |||dSt| |d} |D]B\}}d| |} t |rtd| |qrt|trtd| |D] } t| |dqtd| qrt| t||dqrtd |dS)zhDump the AST for `node`. This recursively walks the AST, printing a readable version.  z{0}<{1} {2!r}>Nrwz @ {0}z {0}<{1}{2}cSs g|] \}}|tvr||fqSr,)SKIP_DUMP_FIELDS)rkrrr,r,r-rtzs zast_dump..z{0}>r3rz{0} {1}: {2!r}>z {0}# mro: {1}z, css|]}|jVqdSrh)rrr,r,r-rlszast_dump..z z{0}{1}:z {0} {1!r}z{0} [z{0}])rrASTrIrrrrrw iter_fieldsrrr__mro__rr) rdepthrVrwlinemarkhead named_fields field_namer next_indentprefixnr,r,r-rhs@      r)r)0rrrrr8rGrJcoveragercoverage.backwardrrrcoverage.bytecodercoverage.debugr coverage.miscrr r r r r rrcoverage.phystokensrrrobjectrr/rrr namedtuplerrrrrLrrrrrrr,r,r,r-sH    LP   f