reporting-labs 0.1.0__tar.gz

reporting_labs-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Naveen Khunteta
+
+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.

reporting_labs-0.1.0/PKG-INFO

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: reporting-labs
+Version: 0.1.0
+Summary: A beautiful test report in one HTML file, for pytest, Playwright, Selenium and Robot Framework. It tells you what broke, who owns it, and whether it is new.
+Author-email: Naveen Khunteta <naveenanimation20@gmail.com>
+License: MIT
+Project-URL: Homepage, https://reportinglabs.dev
+Project-URL: Documentation, https://reportinglabs.dev/get-started/python
+Project-URL: Repository, https://github.com/naveenautomationlabs/reporting-labs-python
+Project-URL: Issues, https://github.com/naveenautomationlabs/reporting-labs-python/issues
+Keywords: pytest,playwright,selenium,robotframework,test-report,html-report,reporting,allure-alternative
+Classifier: Framework :: Pytest
+Classifier: Framework :: Robot Framework
+Classifier: Framework :: Robot Framework :: Tool
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: pytest
+Requires-Dist: pytest>=7.0; extra == "pytest"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-xdist>=3.0; extra == "dev"
+Requires-Dist: pytest-rerunfailures>=12.0; extra == "dev"
+Requires-Dist: pytest-timeout>=2.1; extra == "dev"
+Requires-Dist: requests>=2.25; extra == "dev"
+Requires-Dist: httpx>=0.23; extra == "dev"
+Requires-Dist: playwright>=1.40; extra == "dev"
+Requires-Dist: selenium>=4.10; extra == "dev"
+Requires-Dist: robotframework>=6.0; extra == "dev"
+Dynamic: license-file
+
+# reportingLabs for Python
+
+**One beautiful HTML report for pytest, Playwright, Selenium and Robot Framework.** It tells you what broke,
+who owns it, and whether it is new. The whole report is a single self-contained HTML file: no server, no
+upload, no login. Open it in a browser, attach it to a CI job, or drop it in Slack.
+
+The report is byte-for-byte the same layout as the [Node.js](https://github.com/naveenautomationlabs/reporting-labs)
+and [Java](https://github.com/naveenautomationlabs/reporting-labs-java) reporters, so one triage habit works
+across a whole company. Nothing from Node is needed at run time: the report is built entirely in Python.
+
+## Install
+
+```bash
+pip install reporting-labs
+```
+
+That is all. The pytest plugin turns on the moment the package is installed. For Robot Framework, add one
+listener flag (below).
+
+## pytest
+
+Run your tests as you always do:
+
+```bash
+pytest
+open reporting-labs/index.html        # run again to see the trend and flaky history
+```
+
+Add detail with a few optional helpers:
+
+```python
+import pytest
+from reporting_labs import meta, log, test_data, step, api, attach
+
+@pytest.mark.meta(priority="P1", owner="asha", feature="checkout", story="SHOP-231")
+def test_checkout(page):
+    test_data({"username": "demo", "password": "S3cret"}, "Login")   # sensitive keys are masked
+    log("cart total before coupons: 99.00")
+    with step("Apply coupon"):
+        ...
+```
+
+| What you get | How |
+|---|---|
+| A row per test: passed, failed, skipped (with the reason), xfail / xpass | automatic |
+| Flaky, with every attempt | `pytest-rerunfailures` |
+| Timed out | `pytest-timeout` |
+| Parallel runs merged into one report | `pytest-xdist` (`-n auto`) |
+| Priority, owner, feature charts and filters | `@pytest.mark.meta(...)` or `meta(...)` |
+| Every `requests` / `httpx` call in the API tab | automatic |
+| Captured stdout / stderr, with secrets masked | automatic |
+
+Turn it off for a run with `-p no:reporting_labs` or `--no-rl`.
+
+## Playwright
+
+Install `pytest-playwright` and write tests as usual. Every action, every `expect()` and a screenshot of the
+failing page land in the report with no extra code. pytest-playwright's trace and video are attached too:
+
+```bash
+pytest --tracing retain-on-failure --video retain-on-failure
+```
+
+The sync and async APIs both work. See `examples/pytest-playwright`.
+
+## Selenium
+
+Install `selenium` and write tests as usual. Every driver command (open, find, click, type, run script,
+perform actions, Appium taps) becomes a step, with the element named by the locator that found it, and a
+screenshot of the browser is attached when a test fails. No wrappers. See `examples/pytest-selenium`.
+
+## Robot Framework
+
+Add one listener flag:
+
+```bash
+robot --listener reporting_labs.RobotListener tests/
+```
+
+One row per test case, suites as the path, every keyword a step, setup and teardown as hooks, tags as
+filters, and the screenshots SeleniumLibrary or the Browser library embed in the log attached to the test.
+Options go after a colon: `--listener reporting_labs.RobotListener:title=Checkout:output=reports/rl`.
+See `examples/robot-selenium`.
+
+## Configuration
+
+Every option is optional. Put them in `reporting-labs.config.json` next to where you run, or under
+`[tool.reporting-labs]` in `pyproject.toml`. Keys may be written `camelCase` (as in the Node reporter) or
+`snake_case`.
+
+```json
+{
+  "title": "Checkout regression",
+  "project": { "name": "ShopLite", "version": "2.4.0", "team": "QA Platform" },
+  "metadata": { "env": "local" },
+  "logo": "logo.png",
+  "palette": "lab",
+  "links": { "story": "https://acme.atlassian.net/browse/{id}" },
+  "maskKeys": ["otp", "pan"],
+  "history": { "enabled": true, "keep": 30 }
+}
+```
+
+Common options: `title`, `logo`, `accent`, `theme` (`auto` / `light` / `dark`), `palette`
+(`lab` / `ocean` / `ember` / `mono`), `outputFolder`, `metadata`, `project`, `env`, `dimensions`,
+`links`, `maskKeys`, `maskValues`, `maskFromEnv`, `history`, `open` (`on-failure` / `always` / `never`).
+
+**The environment chip** is found for you from `ENV`, `TEST_ENV`, `APP_ENV`, `TARGET_ENV`,
+`CI_ENVIRONMENT_NAME`, or any variable ending in `_ENV`, so a config that says `local` still labels the
+pipeline's reports `dev`, `qa`, `stage`. Point it at your own variable with `"envVar": "TARGET"`.
+
+**Runtime overrides**, read from the environment and winning over the config, so CI can label a run without
+touching the file: `REPORTING_LABS_METADATA_<KEY>` sets a header chip
+(`REPORTING_LABS_METADATA_ENV=qa`), and `REPORTING_LABS_TITLE`, `_THEME`, `_PALETTE`, `_ACCENT`, `_LOGO`
+set the matching option.
+
+## Secrets are masked
+
+Passwords, tokens, cookies, auth headers, API keys (Stripe, GitHub, AWS, Google, GitLab, npm, SendGrid),
+JWTs and Luhn-valid card numbers are blanked in logs, request and response bodies, error messages, test
+data and step titles. A value seen once as a secret (`password=...`, a `PASSWORD` env var, or `maskValues`)
+is blanked everywhere it later appears. `maskKeys` adds your own keys; `maskFromEnv` (on by default) learns
+the values of `PASSWORD` / `*_TOKEN` / `*_SECRET` environment variables.
+
+## License
+
+MIT. The report is a file you own; nothing leaves your machine or your CI.

reporting_labs-0.1.0/README.md

@@ -0,0 +1,127 @@
+# reportingLabs for Python
+
+**One beautiful HTML report for pytest, Playwright, Selenium and Robot Framework.** It tells you what broke,
+who owns it, and whether it is new. The whole report is a single self-contained HTML file: no server, no
+upload, no login. Open it in a browser, attach it to a CI job, or drop it in Slack.
+
+The report is byte-for-byte the same layout as the [Node.js](https://github.com/naveenautomationlabs/reporting-labs)
+and [Java](https://github.com/naveenautomationlabs/reporting-labs-java) reporters, so one triage habit works
+across a whole company. Nothing from Node is needed at run time: the report is built entirely in Python.
+
+## Install
+
+```bash
+pip install reporting-labs
+```
+
+That is all. The pytest plugin turns on the moment the package is installed. For Robot Framework, add one
+listener flag (below).
+
+## pytest
+
+Run your tests as you always do:
+
+```bash
+pytest
+open reporting-labs/index.html        # run again to see the trend and flaky history
+```
+
+Add detail with a few optional helpers:
+
+```python
+import pytest
+from reporting_labs import meta, log, test_data, step, api, attach
+
+@pytest.mark.meta(priority="P1", owner="asha", feature="checkout", story="SHOP-231")
+def test_checkout(page):
+    test_data({"username": "demo", "password": "S3cret"}, "Login")   # sensitive keys are masked
+    log("cart total before coupons: 99.00")
+    with step("Apply coupon"):
+        ...
+```
+
+| What you get | How |
+|---|---|
+| A row per test: passed, failed, skipped (with the reason), xfail / xpass | automatic |
+| Flaky, with every attempt | `pytest-rerunfailures` |
+| Timed out | `pytest-timeout` |
+| Parallel runs merged into one report | `pytest-xdist` (`-n auto`) |
+| Priority, owner, feature charts and filters | `@pytest.mark.meta(...)` or `meta(...)` |
+| Every `requests` / `httpx` call in the API tab | automatic |
+| Captured stdout / stderr, with secrets masked | automatic |
+
+Turn it off for a run with `-p no:reporting_labs` or `--no-rl`.
+
+## Playwright
+
+Install `pytest-playwright` and write tests as usual. Every action, every `expect()` and a screenshot of the
+failing page land in the report with no extra code. pytest-playwright's trace and video are attached too:
+
+```bash
+pytest --tracing retain-on-failure --video retain-on-failure
+```
+
+The sync and async APIs both work. See `examples/pytest-playwright`.
+
+## Selenium
+
+Install `selenium` and write tests as usual. Every driver command (open, find, click, type, run script,
+perform actions, Appium taps) becomes a step, with the element named by the locator that found it, and a
+screenshot of the browser is attached when a test fails. No wrappers. See `examples/pytest-selenium`.
+
+## Robot Framework
+
+Add one listener flag:
+
+```bash
+robot --listener reporting_labs.RobotListener tests/
+```
+
+One row per test case, suites as the path, every keyword a step, setup and teardown as hooks, tags as
+filters, and the screenshots SeleniumLibrary or the Browser library embed in the log attached to the test.
+Options go after a colon: `--listener reporting_labs.RobotListener:title=Checkout:output=reports/rl`.
+See `examples/robot-selenium`.
+
+## Configuration
+
+Every option is optional. Put them in `reporting-labs.config.json` next to where you run, or under
+`[tool.reporting-labs]` in `pyproject.toml`. Keys may be written `camelCase` (as in the Node reporter) or
+`snake_case`.
+
+```json
+{
+  "title": "Checkout regression",
+  "project": { "name": "ShopLite", "version": "2.4.0", "team": "QA Platform" },
+  "metadata": { "env": "local" },
+  "logo": "logo.png",
+  "palette": "lab",
+  "links": { "story": "https://acme.atlassian.net/browse/{id}" },
+  "maskKeys": ["otp", "pan"],
+  "history": { "enabled": true, "keep": 30 }
+}
+```
+
+Common options: `title`, `logo`, `accent`, `theme` (`auto` / `light` / `dark`), `palette`
+(`lab` / `ocean` / `ember` / `mono`), `outputFolder`, `metadata`, `project`, `env`, `dimensions`,
+`links`, `maskKeys`, `maskValues`, `maskFromEnv`, `history`, `open` (`on-failure` / `always` / `never`).
+
+**The environment chip** is found for you from `ENV`, `TEST_ENV`, `APP_ENV`, `TARGET_ENV`,
+`CI_ENVIRONMENT_NAME`, or any variable ending in `_ENV`, so a config that says `local` still labels the
+pipeline's reports `dev`, `qa`, `stage`. Point it at your own variable with `"envVar": "TARGET"`.
+
+**Runtime overrides**, read from the environment and winning over the config, so CI can label a run without
+touching the file: `REPORTING_LABS_METADATA_<KEY>` sets a header chip
+(`REPORTING_LABS_METADATA_ENV=qa`), and `REPORTING_LABS_TITLE`, `_THEME`, `_PALETTE`, `_ACCENT`, `_LOGO`
+set the matching option.
+
+## Secrets are masked
+
+Passwords, tokens, cookies, auth headers, API keys (Stripe, GitHub, AWS, Google, GitLab, npm, SendGrid),
+JWTs and Luhn-valid card numbers are blanked in logs, request and response bodies, error messages, test
+data and step titles. A value seen once as a secret (`password=...`, a `PASSWORD` env var, or `maskValues`)
+is blanked everywhere it later appears. `maskKeys` adds your own keys; `maskFromEnv` (on by default) learns
+the values of `PASSWORD` / `*_TOKEN` / `*_SECRET` environment variables.
+
+## License
+
+MIT. The report is a file you own; nothing leaves your machine or your CI.

reporting_labs-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "reporting-labs"
+dynamic = ["version"]
+description = "A beautiful test report in one HTML file, for pytest, Playwright, Selenium and Robot Framework. It tells you what broke, who owns it, and whether it is new."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Naveen Khunteta", email = "naveenanimation20@gmail.com" }]
+keywords = ["pytest", "playwright", "selenium", "robotframework", "test-report", "html-report", "reporting", "allure-alternative"]
+classifiers = [
+    "Framework :: Pytest",
+    "Framework :: Robot Framework",
+    "Framework :: Robot Framework :: Tool",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Software Development :: Testing",
+]
+dependencies = []
+
+[project.optional-dependencies]
+pytest = ["pytest>=7.0"]
+dev = ["pytest>=7.0", "pytest-xdist>=3.0", "pytest-rerunfailures>=12.0", "pytest-timeout>=2.1", "requests>=2.25", "httpx>=0.23", "playwright>=1.40", "selenium>=4.10", "robotframework>=6.0"]
+
+[project.urls]
+Homepage = "https://reportinglabs.dev"
+Documentation = "https://reportinglabs.dev/get-started/python"
+Repository = "https://github.com/naveenautomationlabs/reporting-labs-python"
+Issues = "https://github.com/naveenautomationlabs/reporting-labs-python/issues"
+
+[project.entry-points.pytest11]
+reporting_labs = "reporting_labs.pytest_plugin"
+
+[tool.setuptools.dynamic]
+version = { attr = "reporting_labs._version.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+reporting_labs = ["template.html", "py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-p no:reporting_labs"

reporting_labs-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

reporting_labs-0.1.0/src/reporting_labs/__init__.py

@@ -0,0 +1,163 @@
+"""reportingLabs for Python: one HTML report for pytest, Playwright, Selenium and Robot Framework.
+
+Helpers to call from a test:
+
+    from reporting_labs import meta, log, test_data, step, api, attach
+
+    meta(priority="P1", owner="asha", feature="checkout")
+    log("cart total before coupons: 99.00")
+    test_data({"username": "demo", "password": "x"}, "Login")
+    with step("Apply coupon"):
+        ...
+    api(method="GET", url="/v1/orders", status=200, duration=120, response_body=body)
+    attach("screenshot", png_bytes, "image/png")
+
+Secrets (password=..., Bearer ..., tokens) are masked in the report.
+"""
+from __future__ import annotations
+
+import functools
+import inspect
+import json
+from contextlib import contextmanager
+from typing import Any, Callable, Dict, Iterator, Optional, Union
+
+from ._version import __version__
+from .core import context
+from .core.model import ErrorInfo, now_ms
+
+__all__ = ["meta", "log", "test_data", "step", "api", "attach", "RobotListener", "__version__"]
+
+
+def __getattr__(name: str) -> Any:
+    # `robot --listener reporting_labs.RobotListener`: imported lazily so a pytest project never loads Robot code
+    if name == "RobotListener":
+        from .robot.listener import ReportingLabsListener
+        return ReportingLabsListener
+    raise AttributeError(name)
+
+
+def meta(**values: Any) -> None:
+    """Attach report metadata to the current test: priority, severity, owner, feature, epic, story, issue... or any key.
+    A value can be a list (one chip per value) or a dict (the fields of a multi-parameter link, see `links`)."""
+    a = context.current()
+    if a is None:
+        return
+    for k, v in values.items():
+        if v is not None:
+            a.meta[str(k).lower()] = v
+
+
+def log(message: Any, *rest: Any) -> None:
+    """Add a timestamped log line to the current test. Lines containing "error"/"fail" show red, "warn" amber."""
+    a = context.current()
+    if a is None:
+        return
+    parts = [str(message)] + [r if isinstance(r, str) else json.dumps(r, default=str) for r in rest]
+    a.log(" ".join(parts))
+
+
+def test_data(data: Any, name: str = "Test data") -> None:
+    """Attach the data this test uses: a dict (key/value block), a list of dicts (table) or a CSV string (table).
+    Sensitive keys are masked."""
+    a = context.current()
+    if a is not None:
+        a.test_data(data, name)
+
+
+def api(method: str, url: str, status: Optional[int] = None, duration: Optional[float] = None, name: Optional[str] = None,
+        request_headers: Optional[Dict[str, str]] = None, request_body: Any = None,
+        response_headers: Optional[Dict[str, str]] = None, response_body: Any = None) -> None:
+    """Record an API call by hand. requests and httpx calls are recorded automatically."""
+    a = context.current()
+    if a is None:
+        return
+    call: Dict[str, Any] = {"method": str(method).upper(), "url": str(url)}
+    if status is not None:
+        call["status"] = int(status)
+    if duration is not None:
+        call["duration"] = float(duration)
+    if name:
+        call["name"] = name
+    if request_headers:
+        call["requestHeaders"] = dict(request_headers)
+    if request_body is not None:
+        call["requestBody"] = request_body
+    if response_headers:
+        call["responseHeaders"] = dict(response_headers)
+    if response_body is not None:
+        call["responseBody"] = response_body
+    a.api_call(call)
+
+
+def attach(name: str, body: Union[bytes, str, None] = None, content_type: Optional[str] = None, path: Optional[str] = None) -> None:
+    """Attach a file or bytes to the current test: a screenshot, a downloaded PDF, a log. Images are shown inline."""
+    a = context.current()
+    if a is None:
+        return
+    if isinstance(body, str):
+        body = body.encode("utf-8")
+        content_type = content_type or "text/plain"
+    if content_type is None:
+        ext = (path or name).lower().rsplit(".", 1)[-1] if "." in (path or name) else ""
+        content_type = {"png": "image/png", "jpg": "image/jpeg", "jpeg": "image/jpeg", "webp": "image/webp", "gif": "image/gif", "webm": "video/webm",
+                        "mp4": "video/mp4", "txt": "text/plain", "log": "text/plain", "json": "application/json", "html": "text/html", "csv": "text/csv",
+                        "zip": "application/zip", "pdf": "application/pdf"}.get(ext, "application/octet-stream")
+    a.attach(name, body, content_type, path)
+
+
+test_data.__test__ = False   # pytest must not collect the helper when a test module imports it
+
+
+class _StepContext:
+    """`with step("title"):` and `@step("title")` on a function (sync or async)."""
+
+    def __init__(self, title: str, category: str = "test.step") -> None:
+        self.title, self.category = title, category
+        self._st = None
+        self._attempt = None
+
+    def __enter__(self) -> "_StepContext":
+        self._attempt = context.current()
+        if self._attempt is not None:
+            self._st = self._attempt.begin_step(self.title, self.category)
+        return self
+
+    def __exit__(self, et, ev, tb) -> bool:
+        if self._attempt is not None and self._st is not None:
+            self._attempt.end_step(self._st, f"{et.__name__}: {ev}" if et else None)
+        return False
+
+    async def __aenter__(self) -> "_StepContext":
+        return self.__enter__()
+
+    async def __aexit__(self, et, ev, tb) -> bool:
+        return self.__exit__(et, ev, tb)
+
+    def __call__(self, fn: Callable) -> Callable:
+        if inspect.iscoroutinefunction(fn):
+            @functools.wraps(fn)
+            async def aw(*args: Any, **kw: Any) -> Any:
+                async with _StepContext(self.title or fn.__name__, self.category):
+                    return await fn(*args, **kw)
+            return aw
+
+        @functools.wraps(fn)
+        def w(*args: Any, **kw: Any) -> Any:
+            with _StepContext(self.title or fn.__name__, self.category):
+                return fn(*args, **kw)
+        return w
+
+
+def step(title: Union[str, Callable, None] = None, category: str = "test.step") -> Any:
+    """A named step in the report. Use as a context manager or a decorator; steps nest.
+
+        with step("Log in as admin"):
+            page.fill("#user", "admin")
+
+        @step("Open the cart")
+        def open_cart(page): ...
+    """
+    if callable(title):
+        return _StepContext(title.__name__, category)(title)
+    return _StepContext(str(title or "step"), category)

reporting_labs-0.1.0/src/reporting_labs/_version.py

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