pgpro-pytest-html-merger 0.2.0__py3-none-any.whl

pgpro_pytest_html_merger/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

pgpro_pytest_html_merger/__main__.py

@@ -0,0 +1,448 @@
+import argparse
+import bs4
+import copy
+import json
+import logging
+import os
+import sys
+import re
+import glob
+import typing
+import collections
+
+from packaging.version import Version
+
+log = logging.getLogger(__name__)
+
+
+def parse_arguments():
+    command_parser = argparse.ArgumentParser(
+        description="A professional tool to merge multiple pytest-html reports into a single one with consistent metadata.",  # noqa: E501
+        epilog="Example: pgpro-pytest-html-merger -i ./reports -o summary.html --title 'Nightly Build'",  # noqa: E501
+    )
+
+    command_parser.add_argument(
+        "--out",
+        "-o",
+        help="name of the output html report",
+        action="store",
+        dest="out",
+        default="merged.html",
+        type=str,
+    )
+
+    command_parser.add_argument(
+        "--input-dir",
+        "-i",
+        help="directory containing html reports to merge (can be used multiple times)",  # noqa: E501
+        action="append",
+        dest="input_dirs",
+        type=str,
+    )
+
+    command_parser.add_argument(
+        "--title",
+        "-t",
+        help="title of the output html report",
+        action="store",
+        dest="title",
+        type=str,
+    )
+
+    command_parser.add_argument(
+        "--verbose",
+        "-v",
+        help="level of logging verbosity",
+        default=3,
+        action="count",
+    )
+
+    command_parser.add_argument(
+        "html_files",
+        help="html files generated by pytest-html",
+        action="store",
+        nargs="*",
+        type=str,
+    )
+
+    # parse options
+    options = command_parser.parse_args()
+
+    return options
+
+
+class PytestHTMLReportMerger:
+    C_MININAL_PYTEST_HTML_VERSION = "4.0.2"
+
+    _summary_count: int
+    _summary_duration: float
+    _summary_outcome: typing.Dict[str, int]
+    _summary_tests: typing.Dict[str, typing.Any]
+    _summary_envs: typing.Dict[str, typing.Any]
+
+    def __init__(self):
+        self.base = None
+        self._summary_count = 0
+        self._summary_duration = 0.0
+        self._summary_outcome = {}
+        self._summary_tests = {}
+        self._summary_envs = {}
+        return
+
+    @staticmethod
+    def _parse_frac(frac_str: str) -> float:
+        assert type(frac_str) is str
+
+        main_part = frac_str[:6]
+        tail = frac_str[6:7]
+
+        fraction_val = int(main_part) if main_part else 0
+        power_of_10 = len(main_part)
+
+        if tail and int(tail[0]) > 4:
+            fraction_val += 1
+
+        return fraction_val / (10**power_of_10)
+
+    @staticmethod
+    def _parse_duration_to_seconds(duration_val: typing.Any) -> float:
+        if isinstance(duration_val, (int, float)):
+            return float(duration_val)
+
+        val_str = str(duration_val).strip()
+
+        # 1. HH:MM:SS.mmmmmm (fractional is optional)
+        hms_match = re.fullmatch(r"(\d+):(\d{2}):(\d{2})(?:\.(\d+))?", val_str)
+        if hms_match:
+            h, m, s, frac_str = hms_match.groups()
+
+            total_seconds = int(h) * 3600 + int(m) * 60 + int(s)
+
+            if frac_str is not None:
+                total_seconds += __class__._parse_frac(frac_str)
+
+            return float(total_seconds)
+
+        # 2. Forma "number ms"
+        ms_match = re.fullmatch(r"^(\d+(?:\.\d+)?)\s*ms$", val_str)
+        if ms_match:
+            return float(ms_match.group(1)) / 1000.0
+
+        # 3. Clear seconds (with/without fraction)
+        sec_match = re.fullmatch(r"^(\d+(?:\.\d+)?)$", val_str)
+        if sec_match:
+            return float(sec_match.group(1))
+
+        raise ValueError(f"Invalid duration format: '{duration_val}'")
+
+    @staticmethod
+    def _format_time(duration):
+        assert type(duration) is float
+        assert duration >= 0
+
+        if duration < 1:
+            return "{} ms".format(int(duration * 1000))
+
+        minutes, seconds = divmod(int(duration), 60)
+        hours, minutes = divmod(minutes, 60)
+        return "{:02d}:{:02d}:{:02d}".format(
+            int(hours),
+            int(minutes),
+            int(seconds),
+        )
+
+    # --------------------------------------------------------------------
+    @staticmethod
+    def _extract_pytest_html_version(
+        report_path,
+        report_soup: bs4.BeautifulSoup,
+    ) -> str:
+        assert report_path is not None
+        assert isinstance(report_soup, bs4.BeautifulSoup)
+
+        """
+        Robustly extract pytest-html version from the report footer/header.
+        Example text: '... by pytest-html v4.0.2'
+        """
+        link = report_soup.find("a", href=re.compile(r"pytest-html"))
+        if link is None:
+            raise RuntimeError(
+                "Report does not have section with pytest-html link.",
+            )
+
+        parent_text = link.parent.get_text()
+
+        # Looking for pattern 'v' and digits (v4.0.2)
+        match = re.search(r"v(\d+\.\d+\.\d+[\w\.]*)", parent_text)
+        if not match:
+            __class__._raise_err__cant_extract_report_version(
+                report_path,
+                parent_text,
+            )
+
+        return match.group(1)
+
+    def _process_test(self, test: typing.Dict[str, typing.Any]) -> None:
+        assert test is not None
+        self._summary_duration += __class__._parse_duration_to_seconds(
+            test.get("duration", 0.0)
+        )
+        test_outcome = test.get("result", "unknown").lower()
+        self._summary_outcome[test_outcome] = (
+            self._summary_outcome.get(test_outcome, 0) + 1
+        )
+        return
+
+    def process_report(self, report_path):
+        html_doc = ""
+        with open(report_path, "r") as f:
+            html_doc = f.read()
+        soup = bs4.BeautifulSoup(html_doc, features="html.parser")
+
+        html_version = __class__._extract_pytest_html_version(
+            report_path,
+            soup,
+        )
+        assert type(html_version) is str
+
+        min_version = Version(__class__.C_MININAL_PYTEST_HTML_VERSION)
+        if Version(html_version) < min_version:
+            __class__._raise_err__unsupported_html_version(
+                report_path,
+                html_version,
+            )
+
+        # copy the base report
+        if self.base is None:
+            self.base = copy.copy(soup)
+
+        # load json data from the current report
+        report_data_container = soup.select("#data-container")[0]
+        report_jsonblob = report_data_container.get("data-jsonblob")
+        report_data = json.loads(report_jsonblob)
+
+        # Calculate summary
+        for _, test_data in report_data.get("tests", {}).items():
+            if type(test_data) is list:
+                # Reruns case ...
+                assert len(test_data) > 0
+                for test in test_data:
+                    self._process_test(test)
+            elif type(test_data) is dict:
+                self._process_test(test_data)
+            else:
+                raise RuntimeError(
+                    "Unexpected test_data type: {}.".format(
+                        type(test_data).__name__,
+                    ),
+                )
+
+            self._summary_count += 1
+            new_test_key = str(self._summary_count)
+            self._summary_tests[new_test_key] = copy.deepcopy(test_data)
+            continue
+
+        # Update envs
+        self._summary_envs.update(report_data.get("environment", {}))
+        return
+
+    def write_report(self, report_path, report_title):
+        assert type(self.base) is not None
+        if report_title is None:
+            report_title = os.path.basename(report_path)
+
+        # reset the title in the <head><title> element
+        ele = self.base.select("#head-title")[0]
+        ele.string = report_title
+
+        # reset the title in the <body><h1> element
+        ele = self.base.select("#title")[0]
+        ele.string = report_title
+
+        # save the updated total tests and total time.
+        base_element = self.base.select(".run-count")[0]
+        test_suffix = "test" if len(self._summary_tests) == 1 else "tests"
+        base_element.string = "{} {} took {}.".format(
+            len(self._summary_tests),
+            test_suffix,
+            __class__._format_time(self._summary_duration),
+        )
+
+        # update the filter counts
+        for key in [
+            "passed",
+            "skipped",
+            "failed",
+            "error",
+            "xfailed",
+            "xpassed",
+            "rerun",
+            "retried",
+        ]:
+            value = self._summary_outcome.get(key, 0)
+
+            # find the base's value for the key
+            base_elements = self.base.select(f".filters .{key}")
+            assert base_elements is not None
+
+            if len(base_elements) == 0:
+                # pytest-html 4.0.2 does not have "retried"
+                log.debug(
+                    f"Filter element for '{key}' not found in HTML template. Skipping UI update for this key."  # noqa: E501
+                )
+                continue
+
+            assert len(base_elements) == 1, "key: {}, len: {}.".format(
+                key, len(base_elements)
+            )
+            base_element0 = base_elements[0]
+            assert base_element0.string is not None, "key: {}".format(key)
+            matches = re.search(r"(\d+)", base_element0.string)
+            base_value = int(matches.groups()[0])
+
+            # save the updated count to the base
+            base_element0.string = re.sub(
+                r"\d+",
+                str(value),
+                base_element0.string,
+            )
+
+            # remove the base's disabled filter if the soup value was not zero
+            if base_value == 0 and value > 0:
+                ele = self.base.select(f"[data-test-result='{key}']")[0]
+                del ele["disabled"]
+
+        # load json data from the base report
+        base_data_container = self.base.select("#data-container")[0]
+        base_jsonblob = base_data_container.get("data-jsonblob")
+        base_data = json.loads(base_jsonblob)
+
+        # reset the title in the footer's data-jsonblob
+        base_data["title"] = report_title
+
+        base_data["tests"] = self._summary_tests
+        base_data["environment"] = self._summary_envs
+
+        # write the json data back to the html element's attribute
+        base_data_container["data-jsonblob"] = json.dumps(base_data)
+
+        # write to file
+        with open(report_path, "w", encoding="utf-8") as f:
+            f.write(str(self.base.prettify(formatter="html5")))
+        return
+
+    @staticmethod
+    def _raise_err__no_section_with_version(report_path) -> typing.NoReturn:
+        err_msg = "Report [{}] does not have section with pytest-html link.".format(  # noqa: E501
+            report_path
+        )
+        raise RuntimeError(err_msg)
+
+    @staticmethod
+    def _raise_err__cant_extract_report_version(
+        report_path,
+        text,
+    ) -> typing.NoReturn:
+        assert report_path is not None
+        err_msg = "Cannot extract pytest-html version from {0!r}. Source file is [{1}]".format(  # noqa: E501
+            text,
+            report_path,
+        )
+        raise RuntimeError(err_msg)
+
+    @staticmethod
+    def _raise_err__unsupported_html_version(
+        report_path, version: str
+    ) -> typing.NoReturn:
+        assert report_path is not None
+        assert type(version) is str
+        err_msg = "Source file [{}] has an unsupported version [{}]. The minimal supported version is [{}].".format(  # noqa: E501
+            report_path,
+            version,
+            __class__.C_MININAL_PYTEST_HTML_VERSION,
+        )
+        raise RuntimeError(err_msg)
+
+
+def main(arguments):
+    raw_files = []
+    has_errors = False
+
+    # 1. Collect from directories
+    if arguments.input_dirs:
+        for directory in arguments.input_dirs:
+            abs_dir = os.path.abspath(directory)
+            if not os.path.isdir(abs_dir):
+                log.error(f"Input directory does not exist: '{directory}'")
+                has_errors = True
+                continue
+
+            pattern = os.path.join(abs_dir, "*.html")
+            found = glob.glob(pattern)
+            raw_files.extend(found)
+
+    # 2. Collect from positional files
+    if arguments.html_files:
+        for f in arguments.html_files:
+            abs_file = os.path.abspath(f)
+            if not os.path.isfile(abs_file):
+                log.error(
+                    f"Invalid input: '{f}' is not a file or does not exist.",
+                )
+                has_errors = True
+                continue
+            raw_files.append(abs_file)
+
+    # --- THE DEDUPLICATION CHECK ---
+    counts = collections.Counter(raw_files)
+    duplicates = [path for path, count in counts.items() if count > 1]
+
+    if duplicates:
+        for d in duplicates:
+            log.error(f"Duplicate input file detected: '{d}'")
+        has_errors = True
+
+    # 3. Final check
+    if has_errors:
+        log.error(
+            "Termination due to input errors (duplicates or missing files).",
+        )
+        sys.exit(1)
+
+    if not raw_files:
+        log.error("No HTML reports found to process.")
+        return
+
+    # 4. Sorting
+    raw_files.sort()
+
+    # Process each report file
+    report_merger = PytestHTMLReportMerger()
+
+    for infile in raw_files:
+        log.info(f"Processing report: {infile}")
+        report_merger.process_report(infile)
+
+    # Finalize and write the aggregated report to disk
+    report_merger.write_report(arguments.out, arguments.title)
+    log.info(
+        f"Successfully merged {len(raw_files)} reports into {arguments.out}",
+    )
+    return
+
+
+def cli():
+    arguments = parse_arguments()
+
+    logging.basicConfig(level=int((6 - arguments.verbose) * 10))
+
+    log.debug(f"opts = {arguments}")
+
+    main(arguments)
+
+    log.debug("exiting")
+    return
+
+
+if __name__ == "__main__":
+    cli()

pgpro_pytest_html_merger-0.2.0.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: pgpro-pytest-html-merger
+Version: 0.2.0
+Summary: A professional tool to merge multiple pytest-html reports into a single one with consistent metadata
+Author-email: Postgres Professional <info@postgrespro.ru>
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: beautifulsoup4>=4.11.1
+Requires-Dist: packaging>=21.0
+Dynamic: license-file
+
+# pgpro-pytest-html-merger
+A professional tool to merge multiple pytest-html reports into a single, consistent HTML report. Developed and maintained by Postgres Professional.
+
+## Key Features
+- Smart Merging: Combines test results, logs, and metadata from multiple sources.
+- Flexible Input: Supports individual files and entire directories.
+- Customizable: Set your own report title and output filename.
+- Modern Support: Fully compatible with Python 3.8 through 3.14.
+
+## Installation
+You can install the package directly from the repository (until it's published to PyPI):
+```bash
+pip install pgpro-pytest-html-merger
+```
+
+## Usage
+After installation, the tool is available via the pgpro-pytest-html-merger command.
+
+### Basic Examples
+Merge all reports in a directory:
+```bash
+pgpro-pytest-html-merger -i ./reports -o summary.html
+```
+
+Merge specific files with a custom title:
+```bash
+pgpro-pytest-html-merger report1.html report2.html -o final.html --title "Nightly Build"
+```
+
+Combine directories and individual files:
+``` bash
+pgpro-pytest-html-merger -i ./unit-tests -i ./e2e-tests extra-report.html -o full-report.html
+```
+
+### Command Line Arguments
+
+| Argument | Shorthand | Description | Default |
+| :--- | :--- | :--- | :--- |
+| `--input-dir` | `-i` | Directory containing HTML reports (can be used multiple times) | None |
+| `--out` | `-o` | Name of the output HTML report | `merged.html` |
+| `--title` | `-t` | Title of the output HTML report | None |
+| `--verbose` | `-v` | Level of logging verbosity | 3 |
+| `html_files` | | Positional arguments for individual HTML files | None |
+
+## Contributing
+1. Fork the repository.
+2. Create your feature branch (`git checkout -b feature/amazing-feature`).
+3. Commit your changes (`git commit -m 'feat: add some amazing feature'`).
+4. Push to the branch (`git push origin feature/amazing-feature`).
+5. Open a Pull Request.
+
+## License
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+© 2026 Postgres Professional

pgpro_pytest_html_merger-0.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+pgpro_pytest_html_merger/__init__.py,sha256=Zn1KFblwuFHiDRdRAiRnDBRkbPttWh44jKa5zG2ov0E,22
+pgpro_pytest_html_merger/__main__.py,sha256=jA8p8-O8RR-XEiO5N6gKZWqtvCw17IRHFcpTI15_CbY,13720
+pgpro_pytest_html_merger-0.2.0.dist-info/licenses/LICENSE,sha256=5TohiMS-HQU-hcTbmFI5EX4qiR4jg3hyH3k92vT4oxI,1078
+pgpro_pytest_html_merger-0.2.0.dist-info/METADATA,sha256=tl6v2KT4s_vl1pCEJiQUF3C3RTGUSKaSnDaDUJYNsEM,2444
+pgpro_pytest_html_merger-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pgpro_pytest_html_merger-0.2.0.dist-info/entry_points.txt,sha256=HmadYgIgk4esiBCXRS7v6XWiQ_W9w6R20M9-cr2Qfdo,83
+pgpro_pytest_html_merger-0.2.0.dist-info/top_level.txt,sha256=KBFQOHGr6PRIQzg6oxq-aTlqlsx0CJPskaNh4Kyqmhs,25
+pgpro_pytest_html_merger-0.2.0.dist-info/RECORD,,

pgpro_pytest_html_merger-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pgpro_pytest_html_merger-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pgpro-pytest-html-merger = pgpro_pytest_html_merger.__main__:cli

pgpro_pytest_html_merger-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Postgres Professional
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pgpro_pytest_html_merger-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pgpro_pytest_html_merger