Why Gemfury?
Push, build, and install
RubyGems
npm packages
Python packages
Maven artifacts
PHP packages
Go Modules
Debian packages
RPM packages
NuGet packages
dfinimundi / wlanpi-profiler deb
Repository URL to install this package:
|
Version:
1.0.8-1 ▾
|
wlanpi-profiler
/
opt
/
wlanpi-profiler
/
lib
/
python3.7
/
site-packages
/
coverage
/
__pycache__
/
parser.cpython-37.pyc
|
|---|
B
ÿ¼bIã @ s d Z ddlZddlZddlZddlZddlZddlZddlmZ ddl m
Z
ddl m Z m Z ddl
mZ ddlmZ ddlmZmZmZmZmZ dd lmZmZmZ dd
lmZm Z m Z G d d d e Z G d
d de Z G dd de Z!G dd de Z"G dd de Z#G dd de $dd¡Z%eddd e&e'ej( )d d¡Z*G d d d e Z+G d d d e Z,e*rd!gZ-d"d# Z.d&d$d%Z/dS )'z Code parsing for coverage.py.é N)Úenv)Úrange)Ú
bytes_to_intsÚ string_class)Ú code_objects)Ú short_stack)ÚcontractÚ
join_regexÚ new_contractÚ nice_pairÚone_of)ÚNoSourceÚ NotPythonÚStopEverything)Úcompile_unicodeÚgenerate_tokensÚneuter_encoding_declarationc @ s e Zd ZdZeddd ddZedd Zd d
Zd d Z d
d Z
dd Z dd Z dd Z
dd Zdd Zdd Zdd Zd d d ZdS )!Ú PythonParserzParse code to find executable lines, excluded lines, etc.
This information is all based on static analysis: no code execution is
involved.
z unicode|None)ÚtextNc
C sÞ |s|st d|pd| _|| _| jsxddlm} y|| j| _W n4 tk
rv } ztd| j|f W dd}~X Y nX || _| j d¡| _ 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 filenamez<code>r )Úget_python_sourcez No source for code: '%s': %sNÚ
F)ÚAssertionErrorÚfilenamer Zcoverage.pythonr ÚIOErrorr
ÚexcludeÚsplitÚlinesÚsetÚ
statementsÚexcludedÚraw_statementsÚ raw_excludedÚ
raw_classdefsÚraw_docstringsÚ show_tokensÚ
_multilineÚ _byte_parserÚ _all_arcsÚ_missing_arc_fragments)Úselfr r r r Úerr© r+ ú/build/wlanpi-profiler-MIf3Xw/wlanpi-profiler-1.0.8/debian/wlanpi-profiler/opt/wlanpi-profiler/lib/python3.7/site-packages/coverage/parser.pyÚ__init__ s.
"zPythonParser.__init__c C s | j st| j| jd| _ | j S )z Create a ByteParser on demand.)r )r& Ú
ByteParserr r )r) r+ r+ r, Ú byte_parser\ s zPythonParser.byte_parserc G s\ t |}tjr| d¡}t |¡}t }x.t| jddD ] \}}| |¡r8|
|¡ q8W |S )zêFind 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.
Úutf8é )Ústart) r r ÚPY2ÚdecodeÚreÚcompiler Ú enumerater ÚsearchÚadd)r) ZregexesZcombinedZregex_cÚmatchesÚiÚltextr+ r+ r, Úlines_matchingc s
zPythonParser.lines_matchingc C sj | j r| | j ¡| _d}d}d}d}tj}d}d}d}t| j} xè| D ]Þ\}
} \} }
\}}
}| jrtdt j
|
|
¡t | |f| |f |
tjkr¢|d7 }n0|
tj
kr¸|d8 }n|
tjkrØ| dkrÖ| j | ¡ nú|
tjkrV| dkr"|| jkpú|}|sT|rT| j |¡ |}d}d}n2| d krÒ|rÒ|| jkrBd}|rÒ| j |¡ n||
tjkr|tjkr| j t| |d ¡ nL|
tjkrÒ|dk rÊ||krÊx"t||d D ]}|| j|< q¶W d}d}| ¡ r$|
t jkr$d}|dkr$| }|r||krd}|r | j |¡ d}|
}qHW |sD| j | j ¡ ¡ t j j rf| jrft | j| jd< dS )
zwParse the source to find the interesting facts about its lines.
A handful of attributes are updated.
r FNTz%10s %5s %-20r %rr1 Úclassú:ú@)!r r= r! ÚtokenÚINDENTr r r$ ÚprintÚtokenizeÚtok_nameÚgetr ÚDEDENTÚNAMEr" r9 ÚOPÚSTRINGr# Úupdater ÚNEWLINEr% ÚstripÚCOMMENTr r/ Ú_find_statementsr Ú
PYBEHAVIORÚmodule_firstline_1Úmin)r) ÚindentZexclude_indentZ excludingZexcluding_decoratorsZ prev_toktypeÚ
first_lineÚemptyZ
first_on_lineZtokgenZtoktypeZttextZslinenoÚ_Zelinenor< Zshould_excludeÚlr+ r+ r, Ú
_raw_parseu st
zPythonParser._raw_parsec C s0 |dk r | j | | ¡ }n| j ||¡}|S )z?Return the first line number of the statement including `line`.r )r% rF )r) Úliner+ r+ r, rT Ö s zPythonParser.first_linec s fdd|D S )zMap the line numbers in `lines` to the correct first line of the
statement.
Returns a set of the first lines.
c s h | ]} |¡qS r+ )rT )Ú.0rW )r) r+ r, ú <setcomp>å s z+PythonParser.first_lines.<locals>.<setcomp>r+ )r) r r+ )r) r, Ú first_linesÞ s zPythonParser.first_linesc C s
| |¡S )z)Implement `FileReporter.translate_lines`.)r\ )r) r r+ r+ r, Útranslate_linesç s z PythonParser.translate_linesc s fdd|D S )z(Implement `FileReporter.translate_arcs`.c s$ g | ] \}} |¡ |¡fqS r+ )rT )rZ ÚaÚb)r) r+ r, ú
<listcomp>í s z/PythonParser.translate_arcs.<locals>.<listcomp>r+ )r) Úarcsr+ )r) r, Útranslate_arcsë s zPythonParser.translate_arcsc
C s¨ y | ¡ W nb tjtfk
rn } z>t|dr6|j}n|jd d }td| j|jd |f W dd}~X Y nX | | j
¡| _ | j | j B }| j
| }| |¡| | _dS )zÁParse source text to find executable lines, excluded lines, etc.
Sets the .excluded and .statements attributes, normalized to the first
line of multi-line statements.
Úlinenor1 r z5Couldn't parse '%s' as Python source: '%s' at line %dN)rX rD Ú
TokenErrorÚIndentationErrorÚhasattrrc Úargsr r r\ r! r r# r r )r) r* rc ÚignoreÚstartsr+ r+ r, Ú parse_sourceï s
(
zPythonParser.parse_sourcec C s | j dkr| ¡ | j S )zÃGet 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_ast)r) r+ r+ r, ra s
zPythonParser.arcsc C sn t | j| j| j}| ¡ t | _x>|jD ]4\}}| |¡}| |¡}||kr*| j ||f¡ q*W |j
| _ dS )zkRun the AstArcAnalyzer and save its results.
`_all_arcs` is the set of arcs in the code.
N) ÚAstArcAnalyzerr r r% Úanalyzer r' ra rT r9 Úmissing_arc_fragmentsr( )r) ZaaaÚl1Úl2Zfl1Zfl2r+ r+ r, rk s
zPythonParser._analyze_astc C s~ t t¡}xF| ¡ D ]:\}}|dk r&q|| jkr2q|| jkr>q|| d7 < qW x&| jD ] }||krZ|| d8 < qZW |S )zYGet a count of exits from that each line.
Excluded lines are excluded.
r r1 )Ú collectionsÚ defaultdictÚintra r r" )r) Ú exit_countsro rp rW r+ r+ r, rt & s
zPythonParser.exit_countsc
C s | j dkr| ¡ |}|rP|dk rP|| krP||f|krP||f| j krP|| }}| j ||fdg¡}g }x|D ]\}}|dkr®|dk rª| |f| j kr¤| | |¡S d}nd}|j|d}dj||d} |dk rè| d j|j|dd
7 } | | ¡ qnW d |¡S ) z5Provide an English sentence describing a missing arc.Nr )NNz didn't jump to the function exitz didn't jump to line {lineno})rc zline {start} {emsg})r2 Úemsgz, because {smsg})Úsmsgz or )r( rk rF Úmissing_arc_descriptionÚformatÚappendÚjoin)
r) r2 ÚendZ
executed_arcsZ actual_startZfragment_pairsZmsgsrv ru Úmsgr+ r+ r, rw A s.
z$PythonParser.missing_arc_description)NNN)N)Ú__name__Ú
__module__Ú __qualname__Ú__doc__r r- Úpropertyr/ r= rX rT r\ r] rb rj ra rk rt rw r+ r+ r+ r, r s = a r c @ s< e Zd ZdZeddd
ddZdd Zd d
Zd d ZdS )r. z3Parse bytecode to understand the structure of code.Úunicode)r Nc
C s || _ |r|| _nLyt||d| _W n8 tk
r\ } ztd||j|jf W d d }~X Y nX x dD ]}t| j|sdtdqdW d S )NÚexecz5Couldn't parse '%s' as Python source: '%s' at line %d)Ú co_lnotabÚco_firstlinenozsThis implementation of Python doesn't support code analysis.
Run coverage.py under another Python for this command.) r Úcoder Ú SyntaxErrorr r| rc rf r )r) r r r ZsynerrÚattrr+ r+ r, r- l s $
zByteParser.__init__c s fddt jD S )z~Iterate over all the code objects nested within this one.
The iteration includes `self` as its first value.
c 3 s | ]}t j|d V qdS ))r N)r. r )rZ Úc)r) r+ r, ú <genexpr> s z+ByteParser.child_parsers.<locals>.<genexpr>)r r )r) r+ )r) r, Ú
child_parsers s zByteParser.child_parsersc
c sÚ t | jdr6xÈ| j ¡ D ]\}}}|dk r|V qW n t| jjddd
}t| jjddd
}d}| jj}d}xTt||D ]F\}} |r¤||kr|V |}||7 }tjj r¼| dkr¼| d8 } || 7 }q~W ||krÖ|V dS )z·Yield 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_linesNr é r1 é é )
rf r r r r r
Úzipr rP Znegative_lnotab)
r) rV rY Úbyte_incrementsÚline_incrementsZ
last_line_numÚline_numZbyte_numÚ byte_incrÚ line_incrr+ r+ r, Ú
_line_numbers s( zByteParser._line_numbersc c s. x(| ¡ D ] }x| ¡ D ]
}|V qW q
W dS )z´Find the statements in `self.code`.
Produce a sequence of line numbers that start statements. Recurses
into all code objects reachable from `self.code`.
N)r r )r) ZbprW r+ r+ r, rO ª s zByteParser._find_statements)NN) r} r~ r r r r- r r rO r+ r+ r+ r, r. i s r. c @ s" e Zd ZdZeeddd ZdS )Ú LoopBlockz@A block on the block stack representing a `for` or `while` loop.)r2 c C s || _ t | _d S )N)r2 r Ú break_exits)r) r2 r+ r+ r, r- ½ s zLoopBlock.__init__N)r} r~ r r r rs r- r+ r+ r+ r, r » s r c @ s$ e Zd ZdZeeeddd ZdS )Ú
FunctionBlockz>A block on the block stack representing a function definition.)r2 Únamec C s || _ || _d S )N)r2 r )r) r2 r r+ r+ r, r- Ç s zFunctionBlock.__init__N)r} r~ r r r rs Ústrr- r+ r+ r+ r, r Å s r c @ s$ e Zd ZdZeddddd ZdS )ÚTryBlockz6A block on the block stack representing a `try` block.zint|None)Ú
handler_startÚ final_startc C s0 || _ || _t | _t | _t | _t | _d S )N)r r r Ú
break_fromÚ
continue_fromÚ return_fromÚ
raise_from)r) r r r+ r+ r, r- Ñ s zTryBlock.__init__N)r} r~ r r r r- r+ r+ r+ r, r Ï s r c s" e Zd ZdZd fdd Z ZS )Ú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 `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.
Nc s t t| | ||¡S )N)Úsuperr£ Ú__new__)Úclsrc Úcause)Ú __class__r+ r, r¥ ì s zArcStart.__new__)N)r} r~ r r r¥ Ú
__classcell__r+ r+ )r¨ r, r£ à s r£ ZArcz
lineno, causeÚ ArcStartsc C s t dd | D S )Nc s s | ]}t |tV qd S )N)Ú
isinstancer£ )rZ Úxr+ r+ r, r ò s z<lambda>.<locals>.<genexpr>)Úall)Úseqr+ r+ r, Ú<lambda>ò ó r¯ ZCOVERAGE_AST_DUMPc @ s e Zd ZdZdd ZdS )ÚNodeListzÁA 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.
c C s || _ |d j| _d S )Nr )Úbodyrc )r) r² r+ r+ r, r- s zNodeList.__init__N)r} r~ r r r- r+ r+ r+ r, r± ù s r± c @ s² e Zd ZdZededdd Zdd Zeeeddjd
d Z d d
Z
eeddd Z dd Z dd Z
e Zdd Ze Ze Zdd Zdd Zdd d d d d d!d"d#d$d%d&h Zed'dd(d) Zed*ed'ddkd+d,Zd-d. Zd/d0 Zd1d2 Zd3d4 Zd5d6 Z ed'd7d8d9 Z ed'd7d:d; Z ed'd7d<d= Z ed'd7d>d? Z ed'dd@dA Z!ed'ddBdC Z"e"Z#ed'ddDdE Z$ed'ddFdG Z%e%Z&e"Z'e"Z(ed'ddHdI Z)ed'ddJdK Z*ed'ddLdM Z+ed'ddNdO Z,ed'ddPdQ Z-ed'd'd'dRdSdT Z.ed'ddUdV Z/ed'ddWdX Z0ed'ddYdZ Z1ed'dd[d\ Z2e2Z3d]d^ Z4d_d` Z5e5Z6dadb Z7dcdd Z8e8deZ9e8dfZ:e8dgZ;e8dhZ<e=j>r®e8diZ?d S )lrl z>Analyze source text with an AST to find executable code paths.r )r r c s t t|¡| _ fdd|D | _ | _trXtd | j¡ td | j¡ t | j t
| _ t
t¡| _g | _tttj dd¡| _d S )Nc s h | ]} ||¡qS r+ )rF )rZ rW )Ú multiliner+ r, r[ s z*AstArcAnalyzer.__init__.<locals>.<setcomp>zStatements: {}zMultiline map: {}ZCOVERAGE_TRACK_ARCSr )ÚastÚparser Ú root_noder r³ ÚAST_DUMPrC rx Úast_dumpr ra rq rr Úlistrn Ú block_stackÚboolrs ÚosÚenvironrF Údebug)r) r r r³ r+ )r³ r, r- s
zAstArcAnalyzer.__init__c C sB x<t | j¡D ],}|jj}t| d| d}|dk r|| qW dS )z¨Examine 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.
Z_code_object__N)r´ Úwalkr¶ r¨ r} Úgetattr)r) ÚnodeÚ node_nameZcode_object_handlerr+ r+ r, rm & s
zAstArcAnalyzer.analyze)r2 r{ Nc C sd | j r(td ||||¡ ttdd | j ||f¡ |dk sH|dk r`| j||f ||f¡ dS )z@Add an arc, including message fragments to use if it is missing.z!
Adding arc: ({}, {}): {!r}, {!r}é )ÚlimitN)r¾ rC rx r ra r9 rn ry )r) r2 r{ rv ru r+ r+ r, Úadd_arc3 s zAstArcAnalyzer.add_arcc C s
t | jS )z.Yield the blocks in nearest-to-farthest order.)Úreversedrº )r) r+ r+ r, Únearest_blocks> s z AstArcAnalyzer.nearest_blocks)Úreturnsc C s2 |j j}t| d| d}|dk r(||S |jS dS )z}What is the right line number to use for this node?
This dispatches to _line__Node functions where needed.
Z_line__N)r¨ r} rÀ rc )r) rÁ r Úhandlerr+ r+ r, Ú
line_for_nodeB s
z AstArcAnalyzer.line_for_nodec C s$ |j }tjjr |jr |jd j }|S )zSCompute first line number for things that can be decorated (classes and functions).r )rc r rP Útrace_decorated_defÚdecorator_list)r) rÁ rc r+ r+ r, Ú_line_decoratedP s
z AstArcAnalyzer._line_decoratedc C s | |j¡S )N)rÊ Úvalue)r) rÁ r+ r+ r, Ú
_line__AssignX s z AstArcAnalyzer._line__Assignc C sB t jdkr8|jr8|jd d k r*|jd jS |jd jS n|jS d S )N)é é r )r Z PYVERSIONÚkeysrc Úvalues)r) rÁ r+ r+ r, Ú _line__Dict] s
zAstArcAnalyzer._line__Dictc C s |j r| |j d ¡S |jS d S )Nr )ZeltsrÊ rc )r) rÁ r+ r+ r, Ú _line__Listl s zAstArcAnalyzer._line__Listc C s* t jjr dS |jr"| |jd ¡S dS d S )Nr1 r )r rP rQ r² rÊ )r) rÁ r+ r+ r, Ú
_line__Moduler s
z AstArcAnalyzer._line__ModuleZAssignZAssertZ AugAssignZDeleteZExecZExprZGlobalZImportZ
ImportFromZNonlocalZPassZPrintrª c C s< |j j}t| d| d}|dk r(||S t| |¡hS dS )aÆ Add 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.
Z _handle__N)r¨ r} rÀ r£ rÊ )r) rÁ r rÉ r+ r+ r, Úadd_arcs s
zAstArcAnalyzer.add_arcszfrom_start, prev_startsc C s |dkr|h}xv|D ]n}| |¡}| j ||¡}|| jkrX| |¡}|dkrNq| |¡}x |D ]}| |j||j¡ q^W | |¡}qW |S )au Add 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) rÊ r³ rF r Úfind_non_missing_noderÅ rc r§ r× )r) r² Ú
from_startÚ prev_startsZ body_noderc rT Z
prev_startr+ r+ r, Ú
add_body_arcs¡ s
z AstArcAnalyzer.add_body_arcsc C sP | |¡}| j ||¡}|| jkr&|S t| d|jj d}|rH||}nd}|S )a Search `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.
Z
_missing__N)rÊ r³ rF r rÀ r¨ r} )r) rÁ rc rT Z
missing_fnr+ r+ r, rØ ½ s
z$AstArcAnalyzer.find_non_missing_nodec C s2 | t|j¡}|r|S |jr.| t|j¡S d S )N)rØ r± r² Úorelse)r) rÁ Z non_missingr+ r+ r, Ú _missing__IfÜ s zAstArcAnalyzer._missing__Ifc C sT g }x*|j D ] }| |¡}|d k r | |¡ q W |s8d S t|dkrL|d S t|S )Nr1 r )r² rØ ry Úlenr± )r) rÁ Znon_missing_childrenÚchildr+ r+ r, Ú_missing__NodeListç s
z!AstArcAnalyzer._missing__NodeListc C sV | t|j¡}|sd S t ¡ }|j|_t ¡ |_|j|j_d|j_|j|_d |_ |S )NÚTrue)
rØ r± r² r´ ZWhilerc ÚNameÚtestÚidrÜ )r) rÁ Z
body_nodesZ new_whiler+ r+ r, Ú_missing__While÷ s
z AstArcAnalyzer._missing__Whilec C s. |j j}|dkrdS |dkr*|jdkr*dS dS )z Is this a compile-time constant?)ZConstantÚ NameConstantÚNumrç râ )rá ÚFalseÚNoneÚ __debug__N)r¨ r} rä )r) rÁ r r+ r+ r, Úis_constant_expr s
z AstArcAnalyzer.is_constant_expr)Úexitsc C sR xL| ¡ D ]@}t|tr(|j |¡ P q
t|tr
|jdk r
|j |¡ P q
W dS )z0Add arcs due to jumps from `exits` being breaks.N)rÇ r« r r rK r r r )r) rì Úblockr+ r+ r, Úprocess_break_exits s
z"AstArcAnalyzer.process_break_exitsc C sh xb| ¡ D ]V}t|tr>x |D ]}| |j|j|j¡ q W P q
t|tr
|jdk r
|j
|¡ P q
W dS )z3Add arcs due to jumps from `exits` being continues.N) rÇ r« r rÅ rc r2 r§ r r r rK )r) rì rí Úxitr+ r+ r, Úprocess_continue_exits* s
z%AstArcAnalyzer.process_continue_exitsc
C s¤ x| ¡ D ]}t|trb|jdk rHx |D ]}| |j|j|j¡ q(W P q|jdk r|j |¡ P q
t|t
r
x,|D ]$}| |j|j |jd |j
¡¡ qrW P q
W dS )z0Add arcs due to jumps from `exits` being raises.Nz didn't except from function {!r})rÇ r« r r rÅ rc r§ r r¢ rK r r2 rx r )r) rì rí rï r+ r+ r, Úprocess_raise_exits6 s
z"AstArcAnalyzer.process_raise_exitsc
C st xn| ¡ D ]b}t|tr2|jdk r2|j |¡ P q
t|tr
x,|D ]$}| |j|j |j
d |j ¡¡ qBW P q
W dS )z1Add arcs due to jumps from `exits` being returns.Nz didn't return from function {!r})
rÇ r« r r r¡ rK r rÅ rc r2 r§ rx r )r) rì rí rï r+ r+ r, Úprocess_return_exitsJ s
z#AstArcAnalyzer.process_return_exitsc C s( | |¡}t|dd}| |g¡ t S )Nz*the break on line {lineno} wasn't executed)r§ )rÊ r£ rî r )r) rÁ ÚhereZ break_startr+ r+ r, Ú_handle__Breakb s
z AstArcAnalyzer._handle__Breakc C sÎ |j }}|jrÄtjjr d}x8|jD ].}| |¡}|dk rN||krN| ||¡ |}q$W tjjrn| ||¡ |}|jrÄ| |jd ¡}| j ||¡}x0t
|d |D ] }|| j kr¢| ||¡ |}q¢W t |hS )zBAdd arcs for things that can be decorated (classes and functions).Nr r1 )
rc rÌ r rP rË rÊ rÅ r² r³ rF r r r£ )r) rÁ Z main_lineÚlastZdec_nodeZ dec_startZ
body_startrc r+ r+ r, Ú_handle_decoratedi s(
z AstArcAnalyzer._handle_decoratedc C s( | |¡}t|dd}| |g¡ t S )Nz-the continue on line {lineno} wasn't executed)r§ )rÊ r£ rð r )r) rÁ ró Zcontinue_startr+ r+ r, Ú_handle__Continue s
z AstArcAnalyzer._handle__Continuec C s¤ | |j¡}| j t|d¡ t|dd}| j|j|d}x |D ]}| |j ||j
¡ q@W | j ¡ }|j }t|dd}|j
r| j|j
|d}||O }n
| |¡ |S )N)r2 z'the loop on line {lineno} never started)r§ )rÙ z)the loop on line {lineno} didn't complete)rÊ Úiterrº ry r r£ rÛ r² rÅ rc r§ Úpopr rÜ r9 )r) rÁ r2 rÙ rì rï Úmy_blockÚ
else_exitsr+ r+ r, Ú _handle__For s
zAstArcAnalyzer._handle__Forc C sL | |j¡}t|dd}| j|j|d}t|dd}|| j|j|dO }|S )Nz-the condition on line {lineno} was never true)r§ )rÙ z.the condition on line {lineno} was never false)rÊ rã r£ rÛ r² rÜ )r) rÁ r2 rÙ rì r+ r+ r, Ú _handle__If¨ s zAstArcAnalyzer._handle__Ifc C s" | |¡}| j|jt|d}|S )N)rÙ )rÊ rÛ r² r£ )r) rÁ r2 rì r+ r+ r, Ú_handle__NodeList± s
z AstArcAnalyzer._handle__NodeListc C s( | |¡}t|dd}| |g¡ t S )Nz*the raise on line {lineno} wasn't executed)r§ )rÊ r£ rñ r )r) rÁ ró Z raise_startr+ r+ r, Ú_handle__Raise· s
z AstArcAnalyzer._handle__Raisec C s( | |¡}t|dd}| |g¡ t S )Nz+the return on line {lineno} wasn't executed)r§ )rÊ r£ rò r )r) rÁ ró Z return_startr+ r+ r, Ú_handle__Return¿ s
z AstArcAnalyzer._handle__Returnc C sè |j r| |j d ¡}nd }|jr4| |jd ¡}nd }t||}| j |¡ | |¡}| j|jt|d}|jrd |_ |j rt
|_ n
| j ¡ t
}|j rød }xT|j D ]J} | | ¡}|d k rÌ|
||¡ |}d}
t||
d} || j| j| dO }qªW |jr| j|j|d}||O }|jrä| j ¡ ||jB |jB |j B |jB } | j|j| d}
|jrÎtjjr¶xD|jD ]:}|j}|jj|d}x |
D ]}|
|j||¡ qW qpW |j}n| |j|
¡}| |¡ |jrFtjjr.xD|jD ]:}|j}|jj|d}x |
D ]}|
|j||¡ qW qèW |j}n| |j|
¡}| |¡ |j rb| | |j |
¡¡ |jrÚtjjrÂxD|jD ]:}|j}|jj|d}x |
D ]}|
|j||¡ qW q|W |j}n| |j|
¡}| |¡ |rä|
}|S )Nr )rÙ z3the exception caught by line {lineno} didn't happen)r§ )rÚ )rc ) ÚhandlersrÊ Ú finalbodyr rº ry rÛ r² r£ r r r¢ rù rÅ rÜ r r r¡ r rP Zfinally_jumps_backrc r§ rx Ú_combine_finally_startsrî rð rñ rò )r) rÁ r r Z try_blockr2 rì Z
handler_exitsZlast_handler_startZ handler_nodeZ
from_causerÙ Z
final_fromZ final_exitsZ
break_linerc r§ Z
final_exitZbreaksZ
continue_lineZ continuesZ return_linerÈ r+ r+ r, Ú _handle__TryÇ s
zAstArcAnalyzer._handle__Try)ri rì rÈ c sV g }x0t |D ]$}|jdk r| |jj|jd¡ qW d |¡ fdd|D }|S )a Helper 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`.
N)rc z or c s h | ]}t |j qS r+ )r£ rc )rZ rï )r§ r+ r, r[ A s z9AstArcAnalyzer._combine_finally_starts.<locals>.<setcomp>)Úsortedr§ ry rx rc rz )r) ri rì Úcausesr2 r+ )r§ r, r 4 s
z&AstArcAnalyzer._combine_finally_startsc C s g |_ | |¡S )N)r r )r) rÁ r+ r+ r, Ú_handle__TryExceptD s z!AstArcAnalyzer._handle__TryExceptc C sb g |_ g |_|jd }|jjdkrX|j|jkrXt|jdks@t|j|_|j |_ |j|_| |¡S )Nr Z TryExceptr1 ) r rÜ r² r¨ r} rc rÞ r r )r) rÁ Úfirstr+ r+ r, Ú_handle__TryFinallyL s
z"AstArcAnalyzer._handle__TryFinallyc C sþ | |j¡ }}| |j¡}d}|r6tjs2|dkr6d}tjjrBd}|rV| |jd ¡}| j t
|d¡ t |dd}| j |j|d}x |D ]}|
|j||j¡ qW t }| j ¡ } | | j¡ t |d d}|jrì| j |j|d}
||
O }n|sú| |¡ |S )
NFrç Tr )r2 z-the condition on line {lineno} was never true)r§ )rÙ z.the condition on line {lineno} was never false)rÊ rã rë r ÚPY3rP Zkeep_constant_testr² rº ry r r£ rÛ rÅ rc r§ r rù rK r rÜ r9 ) r) rÁ r2 Zto_topZ
constant_testZ top_is_body0rÙ rì rï rú rû r+ r+ r, Ú_handle__While] s0
z AstArcAnalyzer._handle__Whilec C s" | |¡}| j|jt|d}|S )N)rÙ )rÊ rÛ r² r£ )r) rÁ r2 rì r+ r+ r, Ú
_handle__Withz s
z AstArcAnalyzer._handle__Withc C sl | |¡}|jrL| j|jt| d}x@|D ]}| |j| |jd¡ q,W n | | |¡ | || ¡ d S )N)rÙ zdidn't exit the module)rÊ r² rÛ r£ rÅ rc r§ )r) rÁ r2 rì rï r+ r+ r, Ú_code_object__Module s
z#AstArcAnalyzer._code_object__Modulec C sN | |¡}| j t||jd¡ | j|jt| d}| |¡ | j ¡ d S )N)r2 r )rÙ )
rÊ rº ry r r rÛ r² r£ rò rù )r) rÁ r2 rì r+ r+ r, Ú_code_object__FunctionDef s
z(AstArcAnalyzer._code_object__FunctionDefc C s\ | |¡}| | |¡ | j|jt|d}x*|D ]"}| |j| |jd |j¡¡ q2W d S )N)rÙ z"didn't exit the body of class {!r}) rÊ rÅ rÛ r² r£ rc r§ rx r )r) rÁ r2 rì rï r+ r+ r, Ú_code_object__ClassDef s
z%AstArcAnalyzer._code_object__ClassDefc s fdd}|S )zFA function to make methods for online callable _code_object__ methods.c sB | |¡}| | |d d |¡¡ | || d d |¡¡ d S )Nz didn't run the {} on line {}z didn't finish the {} on line {})rÊ rÅ rx )r) rÁ r2 )Únounr+ r, Ú _code_object__oneline_callable¢ s
zPAstArcAnalyzer._make_oneline_code_method.<locals>._code_object__oneline_callabler+ )r r r+ )r r, Ú_make_oneline_code_method s z(AstArcAnalyzer._make_oneline_code_methodÚlambdazgenerator expressionzdictionary comprehensionzset comprehensionzlist comprehension)NN)NN)@r} r~ r r r r r- rm rs rÅ rÇ rÊ rÍ rÏ Z_line__ClassDefrÔ Z_line__FunctionDefZ_line__AsyncFunctionDefrÕ rÖ Z
OK_TO_DEFAULTr× r rÛ rØ rÝ rà rå rë rî rð rñ rò rô rö Z_handle__ClassDefr÷ rü Z_handle__AsyncForZ_handle__FunctionDefZ_handle__AsyncFunctionDefrý rþ rÿ r r r r r r r Z_handle__AsyncWithr
r Z _code_object__AsyncFunctionDefr r Z_code_object__LambdaZ_code_object__GeneratorExpZ_code_object__DictCompZ_code_object__SetCompr r
Z_code_object__ListCompr+ r+ r+ r, rl sx
m
rl Úctxc C s$ | dg di t gkp"t| tttfS )z:Is `value` simple enough to be displayed on a single line?Nr+ )r r« r rs Úfloat)rÎ r+ r+ r, Ú_is_simple_value¸ s r c C s d| }t | tjs.td || jj| ¡ dS t| dd}|dk rPd | j¡}nd}d || jj|¡}dd t | ¡D }|std
|¡ nòt
|d krÊt |d d rÊ|d \}}td
|||¡ n¶t| |d } x|D ]\}}d | |¡}
t |rtd |
|¡ qàt |t rXtd |
¡ x |D ]} t
| |d q0W td | ¡ qàt|
t
||d qàW td
|¡ dS )zhDump the AST for `node`.
This recursively walks the AST, printing a readable version.
ú z {}<{} {!r}>Nrc z @ {}Ú z{}<{}{}c S s g | ]\}}|t kr||fqS r+ )ÚSKIP_DUMP_FIELDS)rZ r rÎ r+ r+ r, r` Ò s z ast_dump.<locals>.<listcomp>z{}>r1 r z {} {}: {!r}>z z{}{}:z{} {!r}z{} [é z{}])r« r´ ÚASTrC rx r¨ r} rÀ rc Ú iter_fieldsrÞ r r¹ r¸ ) rÁ ÚdepthrS rc ZlinemarkÚheadZ named_fieldsÚ
field_namerÎ Z next_indentÚprefixÚnr+ r+ r, r¸ ¿ s<
r¸ )r )0r r´ rq r¼ r5 rA rD Zcoverager Zcoverage.backwardr r r Zcoverage.bytecoder Zcoverage.debugr Z
coverage.miscr r r
r r r
r r Zcoverage.phystokensr r r Úobjectr r. r r r Ú
namedtupler£ r» rs r½ rF r· r± rl r r r¸ r+ r+ r+ r, Ú<module> sF TR
/