U c±³eHã@sädZddlmZddlZddlZddlZddlmZddl m Z m Z m Z ddl mZddlmZmZmZmZdd lmZd d d d gZedddgeƒZdd„Zddd„ZGdd„de ƒZGdd„de ƒZGdd„de ƒZdd„ZdS)ak A Cython plugin for coverage.py Requires the coverage package at least in version 4.0 (which added the plugin API). This plugin requires the generated C sources to be available, next to the extension module. It parses the C file and reads the original source files from it, which are stored in C comments. It then reports a source file to coverage.py when it hits one of its lines during line tracing. Basically, Cython can (on request) emit explicit trace calls into the C code that it generates, and as a general human debugging helper, it always copies the current source code line (and its surrounding context) into the C files before it generates code for that line, e.g. :: /* "line_trace.pyx":147 * def cy_add_with_nogil(a,b): * cdef int z, x=a, y=b # 1 * with nogil: # 2 # <<<<<<<<<<<<<< * z = 0 # 3 * z += cy_add_nogil(x, y) # 4 */ __Pyx_TraceLine(147,1,__PYX_ERR(0, 147, __pyx_L4_error)) [C code generated for file line_trace.pyx, line 147, follows here] The crux is that multiple source files can contribute code to a single C (or C++) file (and thus, to a single extension module) besides the main module source file (.py/.pyx), usually shared declaration files (.pxd) but also literally included files (.pxi). Therefore, the coverage plugin doesn't actually try to look at the file that happened to contribute the current source line for the trace call, but simply looks up the single .c file from which the extension was compiled (which usually lies right next to it after the build, having the same name), and parses the code copy comments from that .c file to recover the original source files and their code as a line-to-file mapping. That mapping is then used to report the ``__Pyx_TraceLine()`` calls to the coverage tool. The plugin also reports the line of source code that it found in the C file to the coverage tool to support annotated source representations. For this, again, it does not look at the actual source files but only reports the source code that it found in the C code comments. Apart from simplicity (read one file instead of finding and parsing many), part of the reasoning here is that any line in the original sources for which there is no comment line (and trace call) in the generated C code cannot count as executed, really, so the C code comments are a very good source for coverage reporting. They already filter out purely declarative code lines that do not contribute executable code, and such (missing) lines can then be marked as excluded from coverage analysis. é)Úabsolute_importN)Ú defaultdict)ÚCoveragePluginÚ FileTracerÚ FileReporter)Úcanonical_filenameé)Úfind_root_package_dirÚis_package_dirÚis_cython_generated_fileÚopen_source_file©Ú __version__z.cz.cppz.ccz.cxxú.pyz.pyxz.pxdcCs.tjj}tD]}||}||ƒr |Sq dS©N)ÚosÚpathÚexistsÚC_FILE_EXTENSIONS)Ú base_pathZ file_existsÚextÚ file_name©rú.lib/python3.8/site-packages/Cython/Coverage.pyÚ_find_c_sourceEs  rFcCsDtj |¡}tj |¡sð| d¡s&|rðtj tj |¡|¡}tj |¡rTtj |¡}tj |¡d}tj |¡\}}tj |¡}tj |¡}t t |  tj ¡ƒt |  tj ¡ƒƒ}|D]\} } | | kr²qðq²tj |¡d|} tj | ¡rðt | ƒStj |¡srrrÚ file_reporter¢s ûzPlugin.file_reporterc Cstj |¡\}}| ¡}|tkr"nš|dkrPt d|tj¡}|r¼|d| ¡…}nl|dkr~t d|tj¡}|r¼|d| ¡…}n>|dkr¸|  tj  |¡|¡||j kr¼|j |ddfSndS|t krÈ|nt |ƒ}|dkr.t |¡}tj ||¡ tjj¡}t|ƒdkr.tj tj  |¡d  |¡¡}t |ƒ}d} |rˆtj |¡dd } tj | ¡s^d} t|d d sˆ| r„tj |¡r„d} d}|| fS) Nz.pydz[.]cp[0-9]+-win[_a-z0-9]*$z.soz&[.](?:cpython|pypy)-[0-9]+[-_a-z0-9]*$rr©NNrÚ.rF)Z if_not_found)rrr ÚlowerÚMODULE_FILE_EXTENSIONSÚreÚsearchÚIÚstartÚ_find_c_source_filesrr6rrr ZuncachedÚrelpathr$r%Úlenrrr ) r0r;ÚbasenamerZplatform_suffixr<Z package_rootÚ package_pathZ test_basepathZpy_source_filerrrr7»sD   zPlugin._find_source_filescCs†tj |¡sdStjj}t |¡D]B}||ƒd ¡}|tkr"| tj ||¡|¡||j kr"dSq"t |ƒr‚|  tj  |¡|¡dS)z¦ Desperately parse all C files in the directory or its package parents (not re-descending) to find the (included) source file in one of them. Nr) rrÚisdirr ÚlistdirrHrr8rr6r rNr)r0Zdir_pathÚ source_filer r;rrrrrNìs  zPlugin._find_c_source_filescCsš|jdkri|_||jkr&|j|}n| |¡}||j|<|jdkrJi|_| ¡D]&\}}t||dd}|||f|j|<qR||jkrˆdS|j|dd…S)zý Parse a Cython generated C/C++ source file and find the executable lines. Each executable line starts with a comment header that states source file and line number, as well as the surrounding range of source code lines. NT)r(rFr)Ú_parsed_c_filesÚ_parse_cfile_linesr6Úitemsr-)r0r<Z sourcefileÚ code_linesr;r?r)rrrr8þs       ÿ zPlugin._read_source_linesc CsÆt d¡j}t d¡j}t d¡j}t d¡j}t d¡j}|jrbt d dd„|jDƒ¡¡j}nd d „}ttƒ}ttƒ} d } |j d kr’ttƒ|_ t |ƒæ} t | ƒ} | D]Ò} || ƒ} | sîd | kr¨| d k r¨|| ƒ}|r¨| |   t | d ¡ƒ¡q¨|  ¡\}}|} t |ƒ}| D]n}||ƒ} | rh|  d ¡ ¡}||ƒr8q¨||ƒrV|j |  |¡q¨||||<q¨n||ƒr q¨q q¨W5QRX| ¡D]2\}} t| ƒ |  |d¡¡}|D] }| |=q°qŽ|S)zb Parse a C file and extract all source file lines that generated executable code. z */[*] +"(.*)":([0-9]+)$z *[*] (.*) # <<<<<<+$z *[*]/$z *__Pyx_TraceLine\(([0-9]+),zX\s*c(?:type)?def\s+(?:(?:public|external)\s+)?(?:struct|union|enum|class)(\s+[^:]+|)\s*:ú|cSsg|] }d|‘qS)z(?:%s)r)Ú.0ZregexrrrÚ 'sz-Plugin._parse_cfile_lines..cSsdS)NFr)ÚlinerrrÚ)óz+Plugin._parse_cfile_lines..Nz__Pyx_TraceLine(rr)rJÚcompileÚmatchr2rrKrÚdictÚsetrBÚopenÚiterÚaddÚintÚgroupÚgroupsÚrstriprXÚ differencerC)r0r<Zmatch_source_path_lineZmatch_current_code_lineZmatch_comment_endZmatch_trace_lineZnot_executableZline_is_excludedrYZexecutable_linesZcurrent_filenameÚlinesr]raZ trace_liner;ÚlinenoZ comment_lineÚ code_lineZ dead_linesrrrrWs\    ÿ         zPlugin._parse_cfile_lines)Ú__name__Ú __module__Ú __qualname__r9r6rVrBr2r1r3r@rEr7rNr8rWrrrrr.ps1r.cs0eZdZdZ‡fdd„Zdd„Zdd„Z‡ZS)r:zA Find the Python/Cython source file for a Cython module. cs0tt|ƒ ¡||_||_||_||_||_dSr)Úsuperr:Ú__init__Ú module_filer=r<r6r9)r0rtr=r<Z c_files_mapZ file_path_map©Ú __class__rrrsYs zCythonModuleTracer.__init__cCsdS)NTrr/rrrÚhas_dynamic_source_filenameasz.CythonModuleTracer.has_dynamic_source_filenamecCs˜|jj}z |j|WStk r(YnXt||ƒ}|jr`|dd… ¡dkr`|j|j|<|jS|jdk snt‚||jkrŠ|j |df|j|<||j|<|S)zR Determine source file path. Called by the function call tracer. éýÿÿÿNr) Úf_codeÚ co_filenamer9ÚKeyErrorr-r=rHr6ÚAssertionErrorr<)r0r;ÚframerUr)rrrÚdynamic_source_filenameds     z*CythonModuleTracer.dynamic_source_filename)rorprqÚ__doc__rsrwr~Ú __classcell__rrrurr:Us r:csHeZdZdZ‡fdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z ‡Z S)rAzP Provide detailed trace information for one source file to coverage.py. cs,tt|ƒ |¡||_||_||_||_dSr)rrrArsÚnamer<Ú_codeÚ_excluded_lines)r0r<rUr*r?Úexcluded_linesrurrrss zCythonModuleReporter.__init__cCs t|jƒS)zJ Return set of line numbers that are possibly executable. )rcr‚r/rrrrl†szCythonModuleReporter.linescCs|jS)zM Return set of line numbers that are excluded from coverage. )rƒr/rrrr„Œsz#CythonModuleReporter.excluded_linesccsLd}t|j ¡ƒD]4\}}||kr2gV|d7}qd|fgV|d7}qdS)NrÚtxt)Úsortedr‚rX)r0Z current_lineZline_nornrrrÚ_iter_source_tokens’s  z(CythonModuleReporter._iter_source_tokensc CsRtj |j¡r6t|jƒ}| ¡W5QR£SQRXnd dd„| ¡Dƒ¡SdS)zA Return the source code of the file as a string. Ú css"|]}|r|ddndVqdS)rrÚNr)r[ÚtokensrrrÚ £sÿz.CythonModuleReporter.source..N)rrrr;r Úreadrr‡)r0ÚfrrrÚsource›s   þzCythonModuleReporter.sourcec cs`tj |j¡rBt|jƒ"}|D]}d| d¡fgVqW5QRXn| ¡D]}d|fgVqJdS)z6 Iterate over the source code tokens. r…rˆN)rrrr;r rjr‡)r0rr]rrrÚsource_token_lines§s    z'CythonModuleReporter.source_token_lines) rorprqrrsrlr„r‡rŽrr€rrrurrA{s   rAcCstƒ}| |¡| |¡dSr)r.Zadd_configurerZadd_file_tracer)ZregZoptionsZpluginrrrÚ coverage_init´s r)F)rZ __future__rrJÚos.pathrr&Ú collectionsrZcoverage.pluginrrrZcoverage.filesrZUtilsr r r r r‰rrrcrIrr-r.r:rArrrrrÚs$0      "f&9