godot-release-dashboard-kit 0.1.0__tar.gz

godot_release_dashboard_kit-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Godot Release Dashboard Kit contributors
+
+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.

godot_release_dashboard_kit-0.1.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: godot-release-dashboard-kit
+Version: 0.1.0
+Summary: Build static release dashboards from Godot Production Toolkit reports.
+Author: Godot Release Dashboard Kit contributors
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/NonniGB/godot-production-toolkit/tree/main/godot-release-dashboard-kit
+Project-URL: Issues, https://github.com/NonniGB/godot-production-toolkit/issues
+Keywords: godot,dashboard,release,qa,gamedev,ci
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Godot Release Dashboard Kit
+
+`godot-release-dashboard-kit` builds a small static dashboard from JSON and
+Markdown reports produced by Godot Production Toolkit commands.
+
+It is intentionally simple: point it at a reports folder and it writes a
+self-contained HTML file suitable for a CI artifact or release checklist.
+
+## Install
+
+```powershell
+python -m pip install godot-release-dashboard-kit
+```
+
+From a source checkout:
+
+```powershell
+python -m pip install -e .\godot-release-dashboard-kit
+```
+
+## Quick Start
+
+```powershell
+godot-release-dashboard build reports\godot-project-doctor --output reports\dashboard.html
+```
+
+Write a machine-readable dashboard summary:
+
+```powershell
+godot-release-dashboard build reports\godot-project-doctor --format json --output reports\dashboard.json
+```
+
+## Inputs
+
+The first release scans a folder recursively for `.json` and `.md` files.
+Toolkit JSON reports are summarized through their `tool`, `kind`, and `summary`
+fields when available.
+
+## Outputs
+
+- `html`: self-contained static dashboard.
+- `json`: summary for scripts or later dashboard tooling.

godot_release_dashboard_kit-0.1.0/README.md

@@ -0,0 +1,42 @@
+# Godot Release Dashboard Kit
+
+`godot-release-dashboard-kit` builds a small static dashboard from JSON and
+Markdown reports produced by Godot Production Toolkit commands.
+
+It is intentionally simple: point it at a reports folder and it writes a
+self-contained HTML file suitable for a CI artifact or release checklist.
+
+## Install
+
+```powershell
+python -m pip install godot-release-dashboard-kit
+```
+
+From a source checkout:
+
+```powershell
+python -m pip install -e .\godot-release-dashboard-kit
+```
+
+## Quick Start
+
+```powershell
+godot-release-dashboard build reports\godot-project-doctor --output reports\dashboard.html
+```
+
+Write a machine-readable dashboard summary:
+
+```powershell
+godot-release-dashboard build reports\godot-project-doctor --format json --output reports\dashboard.json
+```
+
+## Inputs
+
+The first release scans a folder recursively for `.json` and `.md` files.
+Toolkit JSON reports are summarized through their `tool`, `kind`, and `summary`
+fields when available.
+
+## Outputs
+
+- `html`: self-contained static dashboard.
+- `json`: summary for scripts or later dashboard tooling.

godot_release_dashboard_kit-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "godot-release-dashboard-kit"
+version = "0.1.0"
+description = "Build static release dashboards from Godot Production Toolkit reports."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [{ name = "Godot Release Dashboard Kit contributors" }]
+keywords = ["godot", "dashboard", "release", "qa", "gamedev", "ci"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Topic :: Software Development :: Quality Assurance",
+  "Topic :: Utilities"
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/NonniGB/godot-production-toolkit/tree/main/godot-release-dashboard-kit"
+Issues = "https://github.com/NonniGB/godot-production-toolkit/issues"
+
+[project.scripts]
+godot-release-dashboard = "godot_release_dashboard_kit.cli:entrypoint"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"

godot_release_dashboard_kit-0.1.0/setup.cfg

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

godot_release_dashboard_kit-0.1.0/src/godot_release_dashboard_kit/__init__.py

@@ -0,0 +1,3 @@
+"""Static release dashboards for Godot toolkit reports."""
+
+__version__ = "0.1.0"

godot_release_dashboard_kit-0.1.0/src/godot_release_dashboard_kit/__main__.py

@@ -0,0 +1,5 @@
+from .cli import entrypoint
+
+
+if __name__ == "__main__":
+    entrypoint()

godot_release_dashboard_kit-0.1.0/src/godot_release_dashboard_kit/cli.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+import sys
+
+from .dashboard import build_dashboard, render_html, render_json
+
+VERSION_LABEL = "godot-release-dashboard 0.1.0"
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Build a static dashboard from Godot toolkit reports.")
+    parser.add_argument("--version", action="version", version=VERSION_LABEL)
+    subparsers = parser.add_subparsers(dest="command")
+
+    build_parser = subparsers.add_parser("build", help="Build a dashboard from a reports directory.")
+    build_parser.add_argument("reports_dir")
+    build_parser.add_argument("--title", default="Godot Release Dashboard")
+    build_parser.add_argument("--format", choices=["html", "json"], default="html")
+    build_parser.add_argument("--output", default="release-dashboard.html")
+
+    args = parser.parse_args(argv)
+    if args.command != "build":
+        parser.print_help()
+        return 2
+    dashboard = build_dashboard(Path(args.reports_dir), args.title)
+    rendered = render_json(dashboard) if args.format == "json" else render_html(dashboard)
+    output = Path(args.output)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(rendered + "\n", encoding="utf-8")
+    return 0
+
+
+def entrypoint() -> None:
+    raise SystemExit(main())
+
+
+if __name__ == "__main__":
+    sys.exit(main())

godot_release_dashboard_kit-0.1.0/src/godot_release_dashboard_kit/dashboard.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from html import escape
+import json
+from pathlib import Path
+from typing import Any
+
+from . import __version__
+
+
+def build_dashboard(reports_dir: Path, title: str = "Godot Release Dashboard") -> dict[str, Any]:
+    reports = [_report_card(path) for path in sorted(reports_dir.rglob("*")) if path.suffix.lower() in {".json", ".md"}]
+    summary = {
+        "reports": len(reports),
+        "errors": sum(int(report.get("errors", 0)) for report in reports),
+        "warnings": sum(int(report.get("warnings", 0)) for report in reports),
+    }
+    return {
+        "tool": "godot-release-dashboard-kit",
+        "tool_version": __version__,
+        "schema_version": "1.0",
+        "kind": "release_dashboard",
+        "title": title,
+        "summary": summary,
+        "reports": reports,
+    }
+
+
+def render_html(dashboard: dict[str, Any]) -> str:
+    cards = "\n".join(_card(report) for report in dashboard["reports"])
+    summary = dashboard["summary"]
+    return "\n".join(
+        [
+            "<!doctype html>",
+            "<html lang=\"en\"><head><meta charset=\"utf-8\">",
+            f"<title>{escape(str(dashboard['title']))}</title>",
+            "<style>body{font-family:system-ui,sans-serif;margin:2rem;color:#172033;background:#f7f8fb}.metrics{display:flex;gap:1rem;flex-wrap:wrap}.metric,.card{background:white;border:1px solid #d8dee9;border-radius:8px;padding:1rem}.grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:1rem;margin-top:1rem}.ok{color:#147d3f}.warn{color:#a15c00}.err{color:#b42318}code{background:#eef2f7;padding:.1rem .3rem;border-radius:4px}</style>",
+            "</head><body>",
+            f"<h1>{escape(str(dashboard['title']))}</h1>",
+            "<div class=\"metrics\">",
+            f"<div class=\"metric\">Reports: {summary['reports']}</div>",
+            f"<div class=\"metric err\">Errors: {summary['errors']}</div>",
+            f"<div class=\"metric warn\">Warnings: {summary['warnings']}</div>",
+            "</div>",
+            "<div class=\"grid\">",
+            cards or "<p>No JSON or Markdown reports found.</p>",
+            "</div></body></html>",
+        ]
+    )
+
+
+def render_json(dashboard: dict[str, Any]) -> str:
+    return json.dumps(dashboard, indent=2, sort_keys=True)
+
+
+def _report_card(path: Path) -> dict[str, Any]:
+    if path.suffix.lower() == ".json":
+        return _json_card(path)
+    text = path.read_text(encoding="utf-8", errors="ignore")
+    return {
+        "path": path.as_posix(),
+        "tool": path.stem,
+        "kind": "markdown",
+        "errors": text.lower().count("error"),
+        "warnings": text.lower().count("warning"),
+        "summary": text.splitlines()[0] if text.splitlines() else path.name,
+    }
+
+
+def _json_card(path: Path) -> dict[str, Any]:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        return {
+            "path": path.as_posix(),
+            "tool": path.stem,
+            "kind": "json",
+            "errors": 1,
+            "warnings": 0,
+            "summary": f"Unreadable JSON: {exc}",
+        }
+    summary = data.get("summary", {}) if isinstance(data, dict) else {}
+    return {
+        "path": path.as_posix(),
+        "tool": str(data.get("tool") or data.get("name") or path.stem) if isinstance(data, dict) else path.stem,
+        "kind": str(data.get("kind", "json")) if isinstance(data, dict) else "json",
+        "errors": int(summary.get("errors", summary.get("error_count", 0))) if isinstance(summary, dict) else 0,
+        "warnings": int(summary.get("warnings", summary.get("warning_count", 0))) if isinstance(summary, dict) else 0,
+        "summary": _summary_text(summary),
+    }
+
+
+def _summary_text(summary: object) -> str:
+    if not isinstance(summary, dict):
+        return ""
+    parts = [f"{key}: {value}" for key, value in sorted(summary.items()) if isinstance(value, (str, int, float))]
+    return ", ".join(parts[:5])
+
+
+def _card(report: dict[str, Any]) -> str:
+    level = "err" if int(report["errors"]) else "warn" if int(report["warnings"]) else "ok"
+    return (
+        f"<section class=\"card\"><h2>{escape(str(report['tool']))}</h2>"
+        f"<p><code>{escape(str(report['path']))}</code></p>"
+        f"<p class=\"{level}\">Errors: {report['errors']} | Warnings: {report['warnings']}</p>"
+        f"<p>{escape(str(report.get('summary', '')))}</p></section>"
+    )

godot_release_dashboard_kit-0.1.0/src/godot_release_dashboard_kit.egg-info/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: godot-release-dashboard-kit
+Version: 0.1.0
+Summary: Build static release dashboards from Godot Production Toolkit reports.
+Author: Godot Release Dashboard Kit contributors
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/NonniGB/godot-production-toolkit/tree/main/godot-release-dashboard-kit
+Project-URL: Issues, https://github.com/NonniGB/godot-production-toolkit/issues
+Keywords: godot,dashboard,release,qa,gamedev,ci
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Godot Release Dashboard Kit
+
+`godot-release-dashboard-kit` builds a small static dashboard from JSON and
+Markdown reports produced by Godot Production Toolkit commands.
+
+It is intentionally simple: point it at a reports folder and it writes a
+self-contained HTML file suitable for a CI artifact or release checklist.
+
+## Install
+
+```powershell
+python -m pip install godot-release-dashboard-kit
+```
+
+From a source checkout:
+
+```powershell
+python -m pip install -e .\godot-release-dashboard-kit
+```
+
+## Quick Start
+
+```powershell
+godot-release-dashboard build reports\godot-project-doctor --output reports\dashboard.html
+```
+
+Write a machine-readable dashboard summary:
+
+```powershell
+godot-release-dashboard build reports\godot-project-doctor --format json --output reports\dashboard.json
+```
+
+## Inputs
+
+The first release scans a folder recursively for `.json` and `.md` files.
+Toolkit JSON reports are summarized through their `tool`, `kind`, and `summary`
+fields when available.
+
+## Outputs
+
+- `html`: self-contained static dashboard.
+- `json`: summary for scripts or later dashboard tooling.

godot_release_dashboard_kit-0.1.0/src/godot_release_dashboard_kit.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/godot_release_dashboard_kit/__init__.py
+src/godot_release_dashboard_kit/__main__.py
+src/godot_release_dashboard_kit/cli.py
+src/godot_release_dashboard_kit/dashboard.py
+src/godot_release_dashboard_kit.egg-info/PKG-INFO
+src/godot_release_dashboard_kit.egg-info/SOURCES.txt
+src/godot_release_dashboard_kit.egg-info/dependency_links.txt
+src/godot_release_dashboard_kit.egg-info/entry_points.txt
+src/godot_release_dashboard_kit.egg-info/top_level.txt
+tests/test_release_dashboard.py

godot_release_dashboard_kit-0.1.0/src/godot_release_dashboard_kit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

godot_release_dashboard_kit-0.1.0/src/godot_release_dashboard_kit.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+godot-release-dashboard = godot_release_dashboard_kit.cli:entrypoint

godot_release_dashboard_kit-0.1.0/src/godot_release_dashboard_kit.egg-info/top_level.txt

@@ -0,0 +1 @@
+godot_release_dashboard_kit

godot_release_dashboard_kit-0.1.0/tests/test_release_dashboard.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import sys
+import tempfile
+import unittest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from godot_release_dashboard_kit.cli import main
+
+
+class ReleaseDashboardTests(unittest.TestCase):
+    def test_builds_html_dashboard(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            reports = root / "reports"
+            reports.mkdir()
+            (reports / "export.json").write_text(
+                json.dumps({"tool": "godot-export-doctor", "summary": {"errors": 1, "warnings": 2}}),
+                encoding="utf-8",
+            )
+            output = root / "dashboard.html"
+
+            exit_code = main(["build", str(reports), "--output", str(output)])
+
+            html = output.read_text(encoding="utf-8")
+            self.assertEqual(exit_code, 0)
+            self.assertIn("Godot Release Dashboard", html)
+            self.assertIn("godot-export-doctor", html)
+            self.assertIn("Errors: 1", html)
+
+    def test_builds_json_dashboard(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            reports = root / "reports"
+            reports.mkdir()
+            (reports / "notes.md").write_text("# Notes\n\nwarning: check this", encoding="utf-8")
+            output = root / "dashboard.json"
+
+            exit_code = main(["build", str(reports), "--format", "json", "--output", str(output)])
+
+            data = json.loads(output.read_text(encoding="utf-8"))
+            self.assertEqual(exit_code, 0)
+            self.assertEqual(data["tool_version"], "0.1.0")
+            self.assertEqual(data["summary"]["reports"], 1)
+
+
+if __name__ == "__main__":
+    unittest.main()