File Manager

X7ROOT File Manager

Current Path: /opt/cloudlinux/venv/lib/python3.11/site-packages/coverage

opt / cloudlinux / venv / lib / python3.11 / site-packages / coverage /

ðŸ“ ..
ðŸ“„ __init__.py(1.25 KB)
ðŸ“„ __main__.py(257 B)
ðŸ“ __pycache__
ðŸ“„ annotate.py(3.67 KB)
ðŸ“„ bytecode.py(713 B)
ðŸ“„ cmdline.py(33.62 KB)
ðŸ“„ collector.py(20.08 KB)
ðŸ“„ config.py(21.47 KB)
ðŸ“„ context.py(2.42 KB)
ðŸ“„ control.py(50.49 KB)
ðŸ“„ data.py(7.33 KB)
ðŸ“„ debug.py(17.39 KB)
ðŸ“„ disposition.py(1.87 KB)
ðŸ“„ env.py(5.94 KB)
ðŸ“„ exceptions.py(1.33 KB)
ðŸ“„ execfile.py(11.85 KB)
ðŸ“„ files.py(18.92 KB)
ðŸ“ fullcoverage
ðŸ“„ html.py(22.62 KB)
ðŸ“ htmlfiles
ðŸ“„ inorout.py(23.34 KB)
ðŸ“„ jsonreport.py(4.64 KB)
ðŸ“„ lcovreport.py(4.82 KB)
ðŸ“„ misc.py(11.89 KB)
ðŸ“„ multiproc.py(3.76 KB)
ðŸ“„ numbits.py(4.56 KB)
ðŸ“„ parser.py(55.39 KB)
ðŸ“„ phystokens.py(7.62 KB)
ðŸ“„ plugin.py(19.07 KB)
ðŸ“„ plugin_support.py(10.11 KB)
ðŸ“„ py.typed(72 B)
ðŸ“„ python.py(7.88 KB)
ðŸ“„ pytracer.py(14.08 KB)
ðŸ“„ report.py(10.37 KB)
ðŸ“„ report_core.py(3.97 KB)
ðŸ“„ results.py(13.07 KB)
ðŸ“„ sqldata.py(50.09 KB)
ðŸ“„ templite.py(10.7 KB)
ðŸ“„ tomlconfig.py(7.39 KB)
ðŸ“„ tracer.cpython-311-x86_64-linux-gnu.so(28.77 KB)
ðŸ“„ types.py(5.4 KB)
ðŸ“„ version.py(1.4 KB)
ðŸ“„ xmlreport.py(9.57 KB)

Editing: jsonreport.py

# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt

"""Json reporting for coverage.py"""

from __future__ import annotations

import datetime
import json
import sys

from typing import Any, Dict, IO, Iterable, List, Optional, Tuple, TYPE_CHECKING

from coverage import __version__
from coverage.report_core import get_analysis_to_report
from coverage.results import Analysis, Numbers
from coverage.types import TMorf, TLineNo

if TYPE_CHECKING:
    from coverage import Coverage
    from coverage.data import CoverageData

class JsonReporter:
    """A reporter for writing JSON coverage results."""

report_type = "JSON report"

def __init__(self, coverage: Coverage) -> None:
        self.coverage = coverage
        self.config = self.coverage.config
        self.total = Numbers(self.config.precision)
        self.report_data: Dict[str, Any] = {}

def report(self, morfs: Optional[Iterable[TMorf]], outfile: IO[str]) -> float:
        """Generate a json report for `morfs`.

`morfs` is a list of modules or file names.

`outfile` is a file object to write the json to.

"""
        outfile = outfile or sys.stdout
        coverage_data = self.coverage.get_data()
        coverage_data.set_query_contexts(self.config.report_contexts)
        self.report_data["meta"] = {
            "version": __version__,
            "timestamp": datetime.datetime.now().isoformat(),
            "branch_coverage": coverage_data.has_arcs(),
            "show_contexts": self.config.json_show_contexts,
        }

measured_files = {}
        for file_reporter, analysis in get_analysis_to_report(self.coverage, morfs):
            measured_files[file_reporter.relative_filename()] = self.report_one_file(
                coverage_data,
                analysis
            )

self.report_data["files"] = measured_files

self.report_data["totals"] = {
            "covered_lines": self.total.n_executed,
            "num_statements": self.total.n_statements,
            "percent_covered": self.total.pc_covered,
            "percent_covered_display": self.total.pc_covered_str,
            "missing_lines": self.total.n_missing,
            "excluded_lines": self.total.n_excluded,
        }

if coverage_data.has_arcs():
            self.report_data["totals"].update({
                "num_branches": self.total.n_branches,
                "num_partial_branches": self.total.n_partial_branches,
                "covered_branches": self.total.n_executed_branches,
                "missing_branches": self.total.n_missing_branches,
            })

json.dump(
            self.report_data,
            outfile,
            indent=(4 if self.config.json_pretty_print else None),
        )

return self.total.n_statements and self.total.pc_covered

def report_one_file(self, coverage_data: CoverageData, analysis: Analysis) -> Dict[str, Any]:
        """Extract the relevant report data for a single file."""
        nums = analysis.numbers
        self.total += nums
        summary = {
            "covered_lines": nums.n_executed,
            "num_statements": nums.n_statements,
            "percent_covered": nums.pc_covered,
            "percent_covered_display": nums.pc_covered_str,
            "missing_lines": nums.n_missing,
            "excluded_lines": nums.n_excluded,
        }
        reported_file = {
            "executed_lines": sorted(analysis.executed),
            "summary": summary,
            "missing_lines": sorted(analysis.missing),
            "excluded_lines": sorted(analysis.excluded),
        }
        if self.config.json_show_contexts:
            reported_file["contexts"] = analysis.data.contexts_by_lineno(analysis.filename)
        if coverage_data.has_arcs():
            summary.update({
                "num_branches": nums.n_branches,
                "num_partial_branches": nums.n_partial_branches,
                "covered_branches": nums.n_executed_branches,
                "missing_branches": nums.n_missing_branches,
            })
            reported_file["executed_branches"] = list(
                _convert_branch_arcs(analysis.executed_branch_arcs())
            )
            reported_file["missing_branches"] = list(
                _convert_branch_arcs(analysis.missing_branch_arcs())
            )
        return reported_file

def _convert_branch_arcs(
    branch_arcs: Dict[TLineNo, List[TLineNo]],
) -> Iterable[Tuple[TLineNo, TLineNo]]:
    """Convert branch arcs to a list of two-element tuples."""
    for source, targets in branch_arcs.items():
        for target in targets:
            yield source, target

X7ROOT File Manager

Editing: jsonreport.py

Upload File

Create Folder