hTSrSSKJr SSKrSSKrSSKJr SSKJr SSK J r SSK J r SSK Jr SS KJrJrJrJr "S S 5r"S S 5r"SS\5r\R."SS55r\R2"SS\55rg)af .. versionadded:: 4.0 Plug-in interfaces for coverage.py. Coverage.py supports a few different kinds of plug-ins that change its behavior: * File tracers implement tracing of non-Python file types. * Configurers add custom configuration, using Python code to change the configuration. * Dynamic context switchers decide when the dynamic context has changed, for example, to record what test function produced the coverage. To write a coverage.py plug-in, create a module with a subclass of :class:`~coverage.CoveragePlugin`. You will override methods in your class to participate in various aspects of coverage.py's processing. Different types of plug-ins have to override different methods. Any plug-in can optionally implement :meth:`~coverage.CoveragePlugin.sys_info` to provide debugging information about their operation. Your module must also contain a ``coverage_init`` function that registers an instance of your plug-in class:: import coverage class MyPlugin(coverage.CoveragePlugin): ... def coverage_init(reg, options): reg.add_file_tracer(MyPlugin()) You use the `reg` parameter passed to your ``coverage_init`` function to register your plug-in object. The registration method you call depends on what kind of plug-in it is. If your plug-in takes options, the `options` parameter is a dictionary of your plug-in's options from the coverage.py configuration file. Use them however you want to configure your object before registering it. Coverage.py will store its own information on your plug-in object, using attributes whose names start with ``_coverage_``. Don't be startled. .. warning:: Plug-ins are imported by coverage.py before it begins measuring code. If you write a plugin in your own project, it might import your product code before coverage.py can start measuring. This can result in your own code being reported as missing. One solution is to put your plugins in your project tree, but not in your importable Python package. .. _file_tracer_plugins: File Tracers ============ File tracers implement measurement support for non-Python files. File tracers implement the :meth:`~coverage.CoveragePlugin.file_tracer` method to claim files and the :meth:`~coverage.CoveragePlugin.file_reporter` method to report on those files. In your ``coverage_init`` function, use the ``add_file_tracer`` method to register your file tracer. .. _configurer_plugins: Configurers =========== .. versionadded:: 4.5 Configurers modify the configuration of coverage.py during start-up. Configurers implement the :meth:`~coverage.CoveragePlugin.configure` method to change the configuration. In your ``coverage_init`` function, use the ``add_configurer`` method to register your configurer. .. _dynamic_context_plugins: Dynamic Context Switchers ========================= .. versionadded:: 5.0 Dynamic context switcher plugins implement the :meth:`~coverage.CoveragePlugin.dynamic_context` method to dynamically compute the context label for each measured frame. Computed context labels are useful when you want to group measured data without modifying the source code. For example, you could write a plugin that checks `frame.f_code` to inspect the currently executed method, and set the context label to a fully qualified method name if it's an instance method of `unittest.TestCase` and the method name starts with 'test'. Such a plugin would provide basic coverage grouping by test and could be used with test runners that have no built-in coveragepy support. In your ``coverage_init`` function, use the ``add_dynamic_context`` method to register your dynamic context switcher. ) annotationsN)Iterable) FrameType)Any)files_needs_to_implement)TArc TConfigurableTLineNoTSourceTokenLinesc\rSrSr%SrS\S'S\S'SSjrSSjrSS jrSS jr SS jr SS jr S r g)CoveragePluginz$Base class for coverage.py plug-ins.str_coverage_plugin_namebool_coverage_enabledcg)aGet a :class:`FileTracer` object for a file. Plug-in type: file tracer. Every Python source file is offered to your plug-in to give it a chance to take responsibility for tracing the file. If your plug-in can handle the file, it should return a :class:`FileTracer` object. Otherwise return None. There is no way to register your plug-in for particular files. Instead, this method is invoked for all files as they are executed, and the plug-in decides whether it can trace the file or not. Be prepared for `filename` to refer to all kinds of files that have nothing to do with your plug-in. The file name will be a Python file being executed. There are two broad categories of behavior for a plug-in, depending on the kind of files your plug-in supports: * Static file names: each of your original source files has been converted into a distinct Python file. Your plug-in is invoked with the Python file name, and it maps it back to its original source file. * Dynamic file names: all of your source files are executed by the same Python file. In this case, your plug-in implements :meth:`FileTracer.dynamic_source_filename` to provide the actual source file for each execution frame. `filename` is a string, the path to the file being considered. This is the absolute real path to the file. If you are comparing to other paths, be sure to take this into account. Returns a :class:`FileTracer` object to use to trace `filename`, or None if this plug-in cannot trace this file. Nselffilenames m/root/racknerd_01/codex-conversation/amazon-q-terraform/.venv/lib/python3.13/site-packages/coverage/plugin.py file_tracerCoveragePlugin.file_tracersLc[US5 g)agGet the :class:`FileReporter` class to use for a file. Plug-in type: file tracer. This will only be invoked if `filename` returns non-None from :meth:`file_tracer`. It's an error to return None from this method. Returns a :class:`FileReporter` object to use to report on `filename`, or the string `"python"` to have coverage.py treat the file as Python. file_reporterNrrs rrCoveragePlugin.file_reporters D/2rcg)aGet the dynamically computed context label for `frame`. Plug-in type: dynamic context. This method is invoked for each frame when outside of a dynamic context, to see if a new dynamic context should be started. If it returns a string, a new context label is set for this and deeper frames. The dynamic context ends when this frame returns. Returns a string to start a new dynamic context, or None if no new context should be started. Nr)rframes rdynamic_contextCoveragePlugin.dynamic_context"rc/$)aYield all of the executable files in `src_dir`, recursively. Plug-in type: file tracer. Executability is a plug-in-specific property, but generally means files which would have been considered for coverage analysis, had they been included automatically. Returns or yields a sequence of strings, the paths to files that could have been executed, including files that had been executed. r)rsrc_dirs rfind_executable_files$CoveragePlugin.find_executable_filess  rcg)anModify the configuration of coverage.py. Plug-in type: configurer. This method is called during coverage.py start-up, to give your plug-in a chance to change the configuration. The `config` parameter is an object with :meth:`~coverage.Coverage.get_option` and :meth:`~coverage.Coverage.set_option` methods. Do not call any other methods on the `config` object. Nr)rconfigs r configureCoveragePlugin.configures rc/$)zGet a list of information useful for debugging. Plug-in type: any. This method will be invoked for ``--debug=sys``. Your plug-in can return any information it wants to be displayed. Returns a list of pairs: `[(name, value), ...]`. rrs rsys_infoCoveragePlugin.sys_info  rrN)rrreturnzFileTracer | None)rrr3zFileReporter | str)r"rr3 str | None)r'rr3z Iterable[str])r+r r3None)r3zIterable[tuple[str, Any]]) __name__ __module__ __qualname____firstlineno____doc____annotations__rrr#r(r,r0__static_attributes__rrrrrsf.&P33 3" & $   rrc$\rSrSr%SrS\S'Srg)CoveragePluginBasezMPlugins produce specialized objects, which point back to the original plugin.r_coverage_pluginrN)r6r7r8r9r:r;r<rrrr>r>s W$$rr>cL\rSrSrSrS SjrS SjrS SjrS SjrSr g) FileTraceriaSupport needed for files during the execution phase. File tracer plug-ins implement subclasses of FileTracer to return from their :meth:`~CoveragePlugin.file_tracer` method. You may construct this object from :meth:`CoveragePlugin.file_tracer` any way you like. A natural choice would be to pass the file name given to `file_tracer`. `FileTracer` objects should only be created in the :meth:`CoveragePlugin.file_tracer` method. See :ref:`howitworks` for details of the different coverage.py phases. c[US5 g)aqThe source file name for this file. This may be any file name you like. A key responsibility of a plug-in is to own the mapping from Python execution back to whatever source file name was originally the source of the code. See :meth:`CoveragePlugin.file_tracer` for details about static and dynamic file names. Returns the file name to credit with this execution. source_filenameNrr/s rrDFileTracer.source_filenames D"34rcg)aDoes this FileTracer have dynamic source file names? FileTracers can provide dynamically determined file names by implementing :meth:`dynamic_source_filename`. Invoking that function is expensive. To determine whether to invoke it, coverage.py uses the result of this function to know if it needs to bother invoking :meth:`dynamic_source_filename`. See :meth:`CoveragePlugin.file_tracer` for details about static and dynamic file names. Returns True if :meth:`dynamic_source_filename` should be called to get dynamic source file names. Frr/s rhas_dynamic_source_filename&FileTracer.has_dynamic_source_filename&s rcg)a2Get a dynamically computed source file name. Some plug-ins need to compute the source file name dynamically for each frame. This function will not be invoked if :meth:`has_dynamic_source_filename` returns False. Returns the source file name for this frame, or None if this frame shouldn't be measured. Nr)rrr"s rdynamic_source_filename"FileTracer.dynamic_source_filename8r%rc URnX"4$)a/Get the range of source line numbers for a given a call frame. The call frame is examined, and the source line number in the original file is returned. The return value is a pair of numbers, the starting line number and the ending line number, both inclusive. For example, returning (5, 7) means that lines 5, 6, and 7 should be considered executed. This function might decide that the frame doesn't indicate any lines from the source file were executed. Return (-1, -1) in this case to tell coverage.py that no lines should be recorded for this frame. )f_lineno)rr"linenos rline_number_rangeFileTracer.line_number_rangeKs~rrNr3r)r3r)rrr"rr3r4)r"rr3ztuple[TLineNo, TLineNo]) r6r7r8r9r:rDrGrJrOr<rrrrBrBs7 5$  &rrBcL\rSrSr%SrS\S'S\S'S\S'S\S 'S S jrS rg ) CodeRegioni]zEData for a region of code found by :meth:`FileReporter.code_regions`.rkindnameintstartzset[int]linescURUR:Xa+[UR5[UR5:$URUR:$)z/To support sorting to make test-writing easier.)rUminrXrothers r__lt__CodeRegion.__lt__ssA 99 "tzz?S%55 5yy5::%%rrN)r\rSr3r)r6r7r8r9r:r;r]r<rrrrSrS]s&O I I J O&rrSc\rSrSrSrSSjrSSjrSSjrSSjrSSjr SSjr SS jr SS jr SS jr SS jrSS jrSSSjjrS SjrS!SjrS"SjrS#SjrS$SjrS$SjrSrSrg)% FileReporterizaSupport needed for files during the analysis and reporting phases. File tracer plug-ins implement a subclass of `FileReporter`, and return instances from their :meth:`CoveragePlugin.file_reporter` method. There are many methods here, but only :meth:`lines` is required, to provide the set of executable lines in the file. See :ref:`howitworks` for details of the different coverage.py phases. cXlg)zSimple initialization of a `FileReporter`. The `filename` argument is the path to the file being reported. This will be available as the `.filename` attribute on the object. Other method implementations on this base class rely on this attribute. Nrrs r__init__FileReporter.__init__s ! rcRSURRSUR<S3$)N) __class__r6rr/s r__repr__FileReporter.__repr__s'4>>**+:dmm5FaHHrcB[R"UR5$)zGet the relative file name for this file. This file path will be displayed in reports. The default implementation will supply the actual project-relative file path. You only need to supply this method if you have an unusual syntax for file paths. )rrelative_filenamerr/s rrlFileReporter.relative_filenames&&t}}55rc[URSS9nUR5sSSS5 $!,(df  g=f)zGet the source for the file. Returns a Unicode string. The base implementation simply reads the `self.filename` file and decodes it as UTF-8. Override this method if your file isn't readable as a text file, or if you need other encoding support. zutf-8)encodingN)openrread)rfs rsourceFileReporter.sources)$--' 2a6683 2 2s/ =c[US5 g)zGet the executable lines in this file. Your plug-in must determine which lines in the file were possibly executable. This method returns a set of those line numbers. Returns a set of line numbers. rXNrr/s rrXFileReporter.liness D'*rc[5$)zGet the excluded executable lines in this file. Your plug-in can use any method it likes to allow the user to exclude executable lines from consideration. Returns a set of line numbers. The base implementation returns the empty set. setr/s rexcluded_linesFileReporter.excluded_lines u rc[U5$)a Translate recorded lines into reported lines. Some file formats will want to report lines slightly differently than they are recorded. For example, Python records the last line of a multi-line statement, but reports are nicer if they mention the first line. Your plug-in can optionally define this method to perform these kinds of adjustment. `lines` is a sequence of integers, the recorded line numbers. Returns a set of integers, the adjusted line numbers. The base implementation returns the numbers unchanged. rx)rrXs rtranslate_linesFileReporter.translate_liness$5zrc[5$)aGet the executable arcs in this file. To support branch coverage, your plug-in needs to be able to indicate possible execution paths, as a set of line number pairs. Each pair is a `(prev, next)` pair indicating that execution can transition from the `prev` line number to the `next` line number. Returns a set of pairs of line numbers. The default implementation returns an empty set. rxr/s rarcsFileReporter.arcss u rc[5$)zGet the lines excused from branch coverage in this file. Your plug-in can use any method it likes to allow the user to exclude lines from consideration of branch coverage. Returns a set of line numbers. The base implementation returns the empty set. rxr/s rno_branch_linesFileReporter.no_branch_linesr|rc[U5$)zTranslate recorded arcs into reported arcs. Similar to :meth:`translate_lines`, but for arcs. `arcs` is a set of line number pairs. Returns a set of line number pairs. The default implementation returns `arcs` unchanged. rx)rrs rtranslate_arcsFileReporter.translate_arcss4yrc0$)awGet a count of exits from that each line. To determine which lines are branches, coverage.py looks for lines that have more than one exit. This function creates a dict mapping each executable line number to a count of how many exits it has. To be honest, this feels wrong, and should be refactored. Let me know if you attempt to implement this method in your plug-in... rr/s r exit_countsFileReporter.exit_countsr2rNcSUSU3$)auProvide an English sentence describing a missing arc. The `start` and `end` arguments are the line numbers of the missing arc. Negative numbers indicate entering or exiting code objects. The `executed_arcs` argument is a set of line number pairs, the arcs that were executed in this file. By default, this simply returns the string "Line {start} didn't jump to {end}". zLine z didn't jump to line r)rrWend executed_arcss rmissing_arc_description$FileReporter.missing_arc_descriptions$ug23%88rc SU3$)z2Provide an English description of an arc's effect.z jump to line r)rrWrs rarc_descriptionFileReporter.arc_description"s se$$rc#d# UR5R5H nSU4/v M g7f)aGenerate a series of tokenized lines, one for each line in `source`. These tokens are used for syntax-colored reports. Each line is a list of pairs, each pair is a token:: [("key", "def"), ("ws", " "), ("nam", "hello"), ("op", "("), ... ] Each pair has a token class, and the token text. The token classes are: * ``"com"``: a comment * ``"key"``: a keyword * ``"nam"``: a name, or identifier * ``"num"``: a number * ``"op"``: an operator * ``"str"``: a string literal * ``"ws"``: some white space * ``"txt"``: some other kind of text If you concatenate all the token texts, and then join them with newlines, you should have your original source back. The default implementation simply returns each line tagged as ``"txt"``. txtN)rs splitlines)rlines rsource_token_linesFileReporter.source_token_lines*s,8KKM,,.D4=/ !/s.0c/$)zIdentify regions in the source file for finer reporting than by file. Returns an iterable of :class:`CodeRegion` objects. The kinds reported should be in the possibilities returned by :meth:`code_region_kinds`. rr/s r code_regionsFileReporter.code_regionsIs  rc/$)a)Return the kinds of code regions this plugin can find. The returned pairs are the singular and plural forms of the kinds:: [ ("function", "functions"), ("class", "classes"), ] This will usually be hard-coded, but could also differ by the specific source file involved. rr/s rcode_region_kindsFileReporter.code_region_kindsRs  rcb[U[5=(a URUR:H$N isinstancer`rr[s r__eq__FileReporter.__eq__bs!%.R4==ENN3RRrcb[U[5=(a URUR:$rrr[s rr]FileReporter.__lt__es!%.Q4==5>>3QQrrb)rrr3r5rQ)r3 set[TLineNo])rXzIterable[TLineNo]r3r)r3 set[TArc])rzIterable[TArc]r3r)r3zdict[TLineNo, int]r)rWr rr rzIterable[TArc] | Noner3r)rWr rr r3r)r3r )r3zIterable[CodeRegion])r3zIterable[tuple[str, str]])r\rr3r)r6r7r8r9r:rcrirlrsrXrzr~rrrrrrrrrrr]__hash__r<rrrr`r`zs !I 6  + (    "04 999- 9 9(%%% %"> SRHrr`)r: __future__r dataclasses functoolscollections.abcrtypesrtypingrcoverager coverage.miscr coverage.typesr r r r rr>rB dataclassrStotal_orderingr`rrrrsm^#$-JJ}}@%% T#Tn &&&8 n%nnr