chore: wydzielenie nucleares_monitor do osobnego repo

Monitor reaktora (Nucleares) przeniesiony do github.com/migatu/nucleares_monitor.
requirements.txt usunięty — pozostałe skrypty Foundry używają wyłącznie stdlib.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

help_scripts/manage_releases.py

@@ -0,0 +1,356 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+manage_releases.py
+
+Automates synchronization of Git tags with GitHub releases. On each run it:
+  * Verifies the repository is clean and the current branch is fully pushed.
+  * Ensures HEAD is tagged by comparing the root version.nfo with existing
+    release tags and bumping/committing when required.
+  * Iterates over every tag in the repository, creating GitHub releases for any
+    missing entries and attaching per-directory ZIP archives (excluding
+    version.nfo files) that reflect the repository state for that tag.
+
+Dependencies:
+  - gh CLI (https://cli.github.com/)
+  - git available in PATH
+"""
+
+from __future__ import annotations
+
+import argparse
+import io
+import os
+import re
+import shutil
+import subprocess
+import tarfile
+import tempfile
+import textwrap
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional, Sequence, Tuple
+from zipfile import ZIP_DEFLATED, ZipFile
+
+
+def sh(args: Sequence[str], cwd: Path, check: bool = True) -> subprocess.CompletedProcess[str]:
+    """Run a subprocess and return the completed process."""
+    result = subprocess.run(
+        list(args),
+        cwd=str(cwd),
+        text=True,
+        capture_output=True,
+    )
+    if check and result.returncode != 0:
+        raise RuntimeError(
+            f"Command failed ({' '.join(args)}):\n"
+            f"{result.stdout}{result.stderr}"
+        )
+    return result
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Synchronize Git tags with GitHub releases.")
+    parser.add_argument(
+        "--repo",
+        default=".",
+        help="Ścieżka do repozytorium git (domyślnie: bieżący katalog).",
+    )
+    parser.add_argument(
+        "--remote",
+        default="origin",
+        help="Nazwa zdalnego repozytorium do pushowania commitów oraz tagów (domyślnie: origin).",
+    )
+    parser.add_argument(
+        "--output-dir",
+        default="Release packs",
+        help="Katalog wyjściowy, w którym powstaną ZIP-y uploadowane do release (domyślnie: 'Release packs').",
+    )
+    parser.add_argument(
+        "--notes-template",
+        default="Automated release for {tag}",
+        help="Szablon notatek release (dostępne pola: {tag}).",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Tylko plan – bez commitów, tagowania i publikacji release.",
+    )
+    return parser.parse_args()
+
+
+def read_text_if_exists(path: Path) -> Optional[str]:
+    if not path.is_file():
+        return None
+    return path.read_text(encoding="utf-8").strip()
+
+
+def parse_version(version: str) -> Optional[Tuple[int, ...]]:
+    if not version:
+        return None
+    if not re.fullmatch(r"\d+(?:\.\d+)*", version):
+        return None
+    return tuple(int(part) for part in version.split("."))
+
+
+def bump_version(version: str) -> str:
+    parts = parse_version(version)
+    if parts is None:
+        # fallback: append .1 to non-numeric strings
+        return f"{version}.1"
+    bumped = list(parts)
+    bumped[-1] += 1
+    return ".".join(str(piece) for piece in bumped)
+
+
+def sanitize_component(value: str) -> str:
+    value = value.strip()
+    if not value:
+        return "unknown"
+    return re.sub(r"[\\s/\\\\]+", "-", value)
+
+
+class ReleaseManager:
+    def __init__(self, args: argparse.Namespace):
+        self.args = args
+        self.repo = Path(args.repo).resolve()
+        self.output_dir = (self.repo / args.output_dir).resolve()
+
+    # ------------------------------------------------------------------ helpers
+    def git(self, *args: str, check: bool = True) -> subprocess.CompletedProcess[str]:
+        return sh(args, cwd=self.repo, check=check)
+
+    def ensure_tooling(self) -> None:
+        sh(["gh", "--version"], cwd=self.repo, check=True)
+
+    def ensure_repo(self) -> None:
+        if not (self.repo / ".git").exists():
+            raise RuntimeError(f"{self.repo} nie jest repozytorium git.")
+
+    def ensure_clean_state(self) -> None:
+        status = self.git("git", "status", "--porcelain", check=True).stdout.strip()
+        if status:
+            raise RuntimeError(
+                "Wykryto niezakomitowane zmiany. Ukończ commit lub stash przed publikacją release.\n"
+                "Release podpisany z nieczystego drzewa może wymagać resetu HEAD do taga."
+            )
+
+        upstream = self.git("git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}", check=False)
+        if upstream.returncode != 0:
+            raise RuntimeError(
+                "Brak skonfigurowanego upstreamu dla bieżącej gałęzi – nie można zweryfikować, "
+                "czy wszystkie commity zostały wypchnięte."
+            )
+        ahead = self.git("git", "rev-list", "--count", "@{u}..HEAD", check=True).stdout.strip()
+        if ahead and int(ahead) > 0:
+            raise RuntimeError(
+                "Bieżąca gałąź zawiera niewypchnięte commity. Wypchnij zmiany zanim utworzysz release."
+            )
+
+    def get_head_tag(self) -> Optional[str]:
+        result = self.git("git", "describe", "--tags", "--exact-match", "HEAD", check=False)
+        tag = result.stdout.strip()
+        if result.returncode == 0 and tag:
+            return tag
+        return None
+
+    def list_tags(self) -> List[str]:
+        tags = self.git("git", "tag", "--sort=creatordate", check=True).stdout.splitlines()
+        return [tag.strip() for tag in tags if tag.strip()]
+
+    def list_version_tags(self) -> List[str]:
+        tags = []
+        for tag in self.list_tags():
+            if parse_version(tag):
+                tags.append(tag)
+        return tags
+
+    def read_root_version(self) -> Optional[str]:
+        return read_text_if_exists(self.repo / "version.nfo")
+
+    def write_root_version(self, version: str) -> None:
+        target = self.repo / "version.nfo"
+        target.write_text(f"{version}\n", encoding="utf-8")
+
+    def commit_root_version(self, version: str) -> None:
+        if self.args.dry_run:
+            print(f"[DRY-RUN] git add version.nfo && git commit -m 'release: bump root to v{version}'")
+            return
+        self.write_root_version(version)
+        self.git("git", "add", "version.nfo", check=True)
+        self.git("git", "commit", "-m", f"release: bump root to v{version}", check=True)
+        self.git("git", "push", self.args.remote, check=True)
+
+    def tag_exists(self, tag: str) -> bool:
+        result = self.git("git", "rev-parse", "-q", "--verify", f"refs/tags/{tag}", check=False)
+        return result.returncode == 0
+
+    def create_tag(self, tag: str, message: str) -> None:
+        if self.tag_exists(tag):
+            print(f"[INFO] Tag {tag} już istnieje – pomijam tworzenie.")
+            return
+        if self.args.dry_run:
+            print(f"[DRY-RUN] git tag -a {tag} -m \"{message}\"")
+            return
+        self.git("git", "tag", "-a", tag, "-m", message, check=True)
+        self.git("git", "push", self.args.remote, tag, check=True)
+
+    def ensure_head_tagged(self) -> str:
+        head_tag = self.get_head_tag()
+        if head_tag:
+            return head_tag
+
+        root_version = self.read_root_version()
+        root_tuple = parse_version(root_version) if root_version else None
+
+        version_tags = self.list_version_tags()
+        latest_version = version_tags[-1] if version_tags else None
+        latest_tuple = parse_version(latest_version) if latest_version else None
+
+        if root_version and (root_tuple and (latest_tuple is None or root_tuple > latest_tuple)):
+            new_version = root_version
+        else:
+            base_version = latest_version or root_version or "0.0"
+            new_version = bump_version(base_version)
+            if not self.args.dry_run:
+                print(f"[INFO] Bump root version.nfo -> {new_version}")
+            self.commit_root_version(new_version)
+
+        tag_message = f"release {new_version}"
+        self.create_tag(new_version, tag_message)
+        return new_version
+
+    def gather_directories_for_tag(self, tag: str) -> List[str]:
+        result = self.git("git", "ls-tree", "-d", "--name-only", tag, check=True)
+        candidates = []
+        for line in result.stdout.splitlines():
+            name = line.strip()
+            if not name:
+                continue
+            candidates.append(name)
+        return candidates
+
+    def version_for_directory(self, tag: str, directory: str) -> str:
+        show = self.git("git", "show", f"{tag}:{directory}/version.nfo", check=False)
+        if show.returncode == 0:
+            version = show.stdout.strip()
+            if version:
+                return version
+        return tag
+
+    def build_assets_for_tag(self, tag: str) -> List[Path]:
+        assets: List[Path] = []
+        directories = self.gather_directories_for_tag(tag)
+        if not directories:
+            print(f"[WARN] Tag {tag} nie zawiera katalogów do zzipowania.")
+            return assets
+
+        tag_output_dir = self.output_dir / sanitize_component(tag)
+        if not self.args.dry_run:
+            if tag_output_dir.exists():
+                shutil.rmtree(tag_output_dir)
+            tag_output_dir.mkdir(parents=True, exist_ok=True)
+
+        for directory in directories:
+            version = self.version_for_directory(tag, directory)
+            safe_version = sanitize_component(version)
+            safe_dir = sanitize_component(directory)
+            zip_name = f"{safe_dir}-v{safe_version}.zip"
+            zip_path = tag_output_dir / zip_name
+
+            if self.args.dry_run:
+                print(f"[DRY-RUN] Przygotuj ZIP {zip_path} z taga {tag}:{directory} (pomijając version.nfo)")
+                assets.append(zip_path)
+                continue
+
+            # Re-run capturing binary properly.
+            archive_proc = subprocess.run(
+                ["git", "archive", "--format=tar", tag, directory],
+                cwd=str(self.repo),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            if archive_proc.returncode != 0:
+                raise RuntimeError(
+                    f"git archive nie powiódł się dla {tag}:{directory}:\n"
+                    f"{archive_proc.stderr.decode('utf-8', errors='ignore')}"
+                )
+
+            with tempfile.TemporaryDirectory() as tmp_dir:
+                tmp_path = Path(tmp_dir)
+                with tarfile.open(fileobj=io.BytesIO(archive_proc.stdout)) as tar:
+                    tar.extractall(tmp_path)
+
+                extracted_root = tmp_path / directory
+                for extra in extracted_root.rglob("version.nfo"):
+                    if extra.is_file():
+                        extra.unlink()
+
+                with ZipFile(zip_path, "w", ZIP_DEFLATED) as zipf:
+                    for root, _, files in os.walk(extracted_root):
+                        for filename in files:
+                            file_path = Path(root) / filename
+                            rel_path = file_path.relative_to(tmp_path)
+                            zipf.write(file_path, rel_path.as_posix())
+
+            assets.append(zip_path)
+
+        return assets
+
+    def release_exists(self, tag: str) -> bool:
+        result = self.git("gh", "release", "view", tag, check=False)
+        return result.returncode == 0
+
+    def create_release(self, tag: str, assets: List[Path]) -> None:
+        notes = self.args.notes_template.format(tag=tag)
+        wrapped = "\n".join(textwrap.wrap(notes, width=100))
+
+        if self.args.dry_run:
+            print(f"[DRY-RUN] gh release create {tag} {' '.join(str(a) for a in assets)}")
+            print(f"[DRY-RUN] Notatki:\n{wrapped}")
+            return
+
+        cmd = ["gh", "release", "create", tag, "--title", tag, "--notes", wrapped]
+        cmd.extend(str(asset) for asset in assets)
+        result = self.git(*cmd, check=False)
+        if result.returncode != 0:
+            raise RuntimeError(
+                f"Nie udało się utworzyć release {tag}:\n{result.stdout}{result.stderr}"
+            )
+
+    def sync_releases(self) -> None:
+        tags = self.list_tags()
+        if not tags:
+            print("[INFO] Brak tagów do synchronizacji.")
+            return
+
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        for tag in tags:
+            if self.release_exists(tag):
+                print(f"[INFO] Release {tag} już istnieje – pomijam.")
+                continue
+            print(f"[INFO] Przygotowuję release dla taga {tag}...")
+            assets = self.build_assets_for_tag(tag)
+            self.create_release(tag, assets)
+
+    def run(self) -> None:
+        self.ensure_repo()
+        self.ensure_tooling()
+        self.ensure_clean_state()
+        self.ensure_head_tagged()
+        self.sync_releases()
+
+
+def main() -> int:
+    args = parse_args()
+    manager = ReleaseManager(args)
+    try:
+        manager.run()
+    except RuntimeError as exc:
+        print(f"[BŁĄD] {exc}")
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

help_scripts/sync_foundry_module.py

@@ -58,10 +58,6 @@ ZIP_MODE: str = "ALL"  # "ALL" | "MODULE_ONLY" | "OFF"
 # Katalog wyjściowy na archiwa .zip; jeśli None, użyje SOURCE_BASE_DIR/_zips
 ZIP_OUTPUT_DIR: Optional[str] = r"C:\Release packs"
 CHECK_MODE: bool = False  # tylko walidacja – brak zmian, wyjście !=0 jeśli są akcje
-ENABLE_GH_RELEASE: bool = False  # publikowanie release przez gh CLI
-RELEASE_TAG_PREFIX: Optional[str] = None  # prefiks taga release (np. "module/")
-RELEASE_NOTES_TEMPLATE: str = "Automated release for {name} v{version}"
-GIT_REMOTE_NAME: str = "origin"
 
 # ==========================
 # KONIEC KONFIGURACJI
@@ -128,87 +124,6 @@ def git_changed_top_level_dirs(repo_dir: Path) -> List[str]:
     return sorted(changed)
 
 
-def git_current_head(repo_dir: Path) -> str:
-    rc, out = sh(["git", "rev-parse", "HEAD"], repo_dir)
-    if rc != 0:
-        raise RuntimeError(f"Nie mogę ustalić HEAD w {norm(repo_dir)}:\n{out}")
-    return out.strip()
-
-
-def git_tag_exists(repo_dir: Path, tag: str) -> bool:
-    rc, _ = sh(["git", "rev-parse", "-q", "--verify", f"refs/tags/{tag}"], repo_dir)
-    return rc == 0
-
-
-def create_git_tag(repo_dir: Path, tag: str, message: str, commit: Optional[str]) -> None:
-    if git_tag_exists(repo_dir, tag):
-        print(f"[INFO] Tag {tag} już istnieje – pomijam tworzenie.")
-        return
-
-    cmd = ["git", "tag", "-a", tag]
-    if commit:
-        cmd.append(commit)
-    cmd += ["-m", message]
-    rc, out = sh(cmd, repo_dir)
-    if rc != 0:
-        raise RuntimeError(f"Nie udało się utworzyć taga {tag}:\n{out}")
-    if out.strip():
-        print(out)
-
-
-def push_git_tag(repo_dir: Path, tag: str) -> None:
-    remote = getattr(ARGS, "git_remote", GIT_REMOTE_NAME)
-    rc, out = sh(["git", "push", remote, tag], repo_dir)
-    if rc != 0:
-        raise RuntimeError(f"Nie udało się wypchnąć taga {tag}:\n{out}")
-    if out.strip():
-        print(out)
-
-
-def ensure_gh_available(repo_dir: Path) -> None:
-    rc, out = sh(["gh", "--version"], repo_dir)
-    if rc != 0:
-        raise RuntimeError("Polecenie 'gh' nie jest dostępne w PATH:\n" + out)
-
-
-def github_release_exists(repo_dir: Path, tag: str) -> bool:
-    rc, _ = sh(["gh", "release", "view", tag], repo_dir)
-    return rc == 0
-
-
-def publish_github_release(repo_dir: Path, tag: str, title: str, notes: str, assets: List[Path]) -> None:
-    ensure_gh_available(repo_dir)
-    assets_str = [str(p) for p in assets]
-
-    if github_release_exists(repo_dir, tag):
-        if not assets_str:
-            print(f"[INFO] Release {tag} już istnieje – brak nowych assetów do przesłania.")
-            return
-        cmd = ["gh", "release", "upload", tag, *assets_str, "--clobber"]
-        rc, out = sh(cmd, repo_dir)
-        if rc != 0:
-            raise RuntimeError(f"Nie udało się zaktualizować release {tag}:\n{out}")
-        if out.strip():
-            print(out)
-        return
-
-    cmd = ["gh", "release", "create", tag, *assets_str, "--title", title, "--notes", notes]
-    rc, out = sh(cmd, repo_dir)
-    if rc != 0:
-        raise RuntimeError(f"Nie udało się utworzyć release {tag}:\n{out}")
-    if out.strip():
-        print(out)
-
-
-def build_release_tag(name: str, version: str) -> str:
-    safe_name = name.replace(" ", "-").replace("/", "-")
-    base = f"{safe_name}-v{version}"
-    prefix = getattr(ARGS, "release_tag_prefix", RELEASE_TAG_PREFIX)
-    if prefix:
-        return f"{prefix}{base}"
-    return base
-
-
 def find_modules_dir_for_user(user: str,
                               relative_pattern: str,
                               appdata_kind: Optional[str]) -> Path:
@@ -392,12 +307,12 @@ def write_json_atomic(path: Path, data: dict) -> None:
     tmp.replace(path)
 
 
-def run_git_commands(repo_dir: Path, commit_msg: str, dry_run: bool) -> Optional[str]:
+def run_git_commands(repo_dir: Path, commit_msg: str, dry_run: bool) -> None:
     if dry_run:
         print("[DRY-RUN] git add -A")
         print(f"[DRY-RUN] git commit -m {commit_msg!r}")
         print("[DRY-RUN] git push")
-        return None
+        return
 
     def run(cmd: List[str]) -> None:
         rc, out = sh(cmd, repo_dir)
@@ -413,12 +328,10 @@ def run_git_commands(repo_dir: Path, commit_msg: str, dry_run: bool) -> Optional
     if out.strip():
         print(out)
     run(["git", "push"])
-    head = git_current_head(repo_dir)
-    return head
 
 
 
-def preflight_module(src_dir: Path, dry_run: bool) -> Tuple[str, str, Optional[str]]:
+def preflight_module(src_dir: Path, dry_run: bool) -> Tuple[str, str]:
     """
     Moduł: odczyt module.json, bump, zapis (jeśli nie dry_run), commit i push.
     Zwraca (module_id, new_version, commit_sha lub None przy dry-run).
@@ -435,20 +348,18 @@ def preflight_module(src_dir: Path, dry_run: bool) -> Tuple[str, str, Optional[s
 
     print(f"[PRE][MODULE] {src_dir.name}: id={module_id}, version={old_version} -> {new_version}")
 
-    commit_sha: Optional[str] = None
-
     if dry_run:
         print("[DRY-RUN] Nie zapisuję module.json i nie wykonuję git.")
     else:
         manifest["version"] = new_version
         write_json_atomic(manifest_path, manifest)
         commit_msg = f"sync: {module_id} v{new_version}"
-        commit_sha = run_git_commands(src_dir, commit_msg, dry_run=False)
+        run_git_commands(src_dir, commit_msg, dry_run=False)
 
-    return module_id, new_version, commit_sha
+    return module_id, new_version
 
 
-def preflight_non_module(src_dir: Path, dry_run: bool) -> Tuple[str, Optional[str]]:
+def preflight_non_module(src_dir: Path, dry_run: bool) -> str:
     """
     Niemoduł: version.nfo w formacie '0.x' (x int).
       - jeśli brak -> '0.1'
@@ -457,7 +368,6 @@ def preflight_non_module(src_dir: Path, dry_run: bool) -> Tuple[str, Optional[st
     Zwraca (new_version, commit_sha lub None przy dry-run).
     """
     nfo = src_dir / "version.nfo"
-    commit_sha: Optional[str] = None
     if not nfo.exists():
         new_version = "0.1"
         print(f"[PRE][FOLDER] {src_dir.name}: version.nfo brak -> {new_version}")
@@ -465,8 +375,8 @@ def preflight_non_module(src_dir: Path, dry_run: bool) -> Tuple[str, Optional[st
             with nfo.open("w", encoding="utf-8") as f:
                 f.write(new_version + "\n")
             commit_msg = f"sync: {src_dir.name} v{new_version}"
-            commit_sha = run_git_commands(src_dir, commit_msg, dry_run=False)
-        return new_version, commit_sha
+            run_git_commands(src_dir, commit_msg, dry_run=False)
+        return new_version
 
     # istnieje -> wczytaj i bumpnij
     content = nfo.read_text(encoding="utf-8").strip()
@@ -486,15 +396,13 @@ def preflight_non_module(src_dir: Path, dry_run: bool) -> Tuple[str, Optional[st
         with nfo.open("w", encoding="utf-8") as f:
             f.write(new_version + "\n")
         commit_msg = f"sync: {src_dir.name} v{new_version}"
-        commit_sha = run_git_commands(src_dir, commit_msg, dry_run=False)
+        run_git_commands(src_dir, commit_msg, dry_run=False)
 
-    return new_version, commit_sha
+    return new_version
 
 
 # ====== ROOT version.nfo (globalna wersja repo) ======
-def maybe_bump_root_version(
-    repo_dir: Path, changed_any: bool, dry_run: bool
-) -> Optional[Tuple[str, Optional[str]]]:
+def maybe_bump_root_version(repo_dir: Path, changed_any: bool, dry_run: bool) -> Optional[str]:
     """
     Jeśli:
       - istnieją zmiany do przetworzenia (changed_any == True)
@@ -530,26 +438,11 @@ def maybe_bump_root_version(
 
     if dry_run:
         print("[DRY-RUN][ROOT] Zapis version.nfo i commit/push zostaną pominięte.")
-        return new_version, None
+        return new_version
 
     nfo.write_text(new_version + "\n", encoding="utf-8")
-    commit_sha = run_git_commands(repo_dir, f"sync: root v{new_version}", dry_run=False)
-    return new_version, commit_sha
-
-
-def maybe_publish_root_release(repo_dir: Path, version: str, commit_sha: Optional[str], dry_run: bool) -> None:
-    if not ARGS.gh_release or dry_run:
-        return
-    name = repo_dir.name or "root"
-    tag = build_release_tag(name, version)
-    title = f"{name} v{version}"
-    template = getattr(ARGS, "release_notes_template", RELEASE_NOTES_TEMPLATE)
-    notes = template.format(name=name, version=version, tag=tag)
-    if commit_sha is None:
-        commit_sha = git_current_head(repo_dir)
-    create_git_tag(repo_dir, tag, title, commit_sha)
-    push_git_tag(repo_dir, tag)
-    publish_github_release(repo_dir, tag, title, notes, [])
+    run_git_commands(repo_dir, f"sync: root v{new_version}", dry_run=False)
+    return new_version
 
 
 # ====== ZIP utilities ======
@@ -636,22 +529,6 @@ def parse_args() -> argparse.Namespace:
                    help="Tylko sprawdzenie zmian (wymusza dry-run, kod wyjścia 1 przy wymaganych akcjach).")
     p.set_defaults(check=CHECK_MODE)
 
-    # GitHub Release options
-    release_group = p.add_mutually_exclusive_group()
-    release_group.add_argument("--gh-release", dest="gh_release", action="store_true",
-                               help="Po zakończeniu commitów utwórz release na GitHubie (wymaga gh CLI).")
-    release_group.add_argument("--no-gh-release", dest="gh_release", action="store_false",
-                               help="Wyłącz publikowanie release (domyślne).")
-    p.set_defaults(gh_release=ENABLE_GH_RELEASE)
-    p.add_argument("--release-tag-prefix", dest="release_tag_prefix",
-                   default=RELEASE_TAG_PREFIX,
-                   help="Opcjonalny prefiks dodawany przed tagiem release (np. 'module/').")
-    p.add_argument("--release-notes-template", dest="release_notes_template",
-                   default=RELEASE_NOTES_TEMPLATE,
-                   help="Szablon notatek release (format: name, version, tag).")
-    p.add_argument("--git-remote", dest="git_remote",
-                   default=GIT_REMOTE_NAME,
-                   help="Nazwa zdalnego repozytorium do wypychania tagów (domyślnie 'origin').")
 
     return p.parse_args()
 
@@ -667,7 +544,7 @@ def resolve_modules_base(user: str, relative_pattern: str, appdata_kind: Optiona
 
 
 def process_module(src_dir: Path, modules_base: Path, confirm_delete: bool, dry_run: bool) -> None:
-    module_id, new_ver, commit_sha = preflight_module(src_dir, dry_run=dry_run)
+    module_id, new_ver = preflight_module(src_dir, dry_run=dry_run)
 
     target_dir = modules_base / src_dir.name
     print(f"[INFO][MODULE] Cel modułu: {norm(target_dir)}")
@@ -700,21 +577,8 @@ def process_module(src_dir: Path, modules_base: Path, confirm_delete: bool, dry_
     print(f"[DONE][MODULE] {src_dir.name} -> commit 'sync: {module_id} v{new_ver}' wykonany." if not dry_run
           else f"[DRY-RUN][MODULE] {src_dir.name} -> commit planowany.")
 
-    if ARGS.gh_release and not dry_run:
-        tag = build_release_tag(module_id, new_ver)
-        title = f"{module_id} v{new_ver}"
-        template = getattr(ARGS, "release_notes_template", RELEASE_NOTES_TEMPLATE)
-        notes = template.format(name=module_id, version=new_ver, tag=tag)
-        assets = [zip_path] if zip_path else []
-        if commit_sha is None:
-            commit_sha = git_current_head(src_dir)
-        create_git_tag(src_dir, tag, title, commit_sha)
-        push_git_tag(src_dir, tag)
-        publish_github_release(src_dir, tag, title, notes, assets)
-
-
 def process_non_module(src_dir: Path, dry_run: bool) -> None:
-    new_ver, commit_sha = preflight_non_module(src_dir, dry_run=dry_run)
+    new_ver = preflight_non_module(src_dir, dry_run=dry_run)
     # ZIP po commicie (jeśli ustawienie pozwala)
     zip_path: Optional[Path] = None
     if should_zip(is_module=False, zip_mode=ARGS.zip_mode):
@@ -726,20 +590,6 @@ def process_non_module(src_dir: Path, dry_run: bool) -> None:
     print(f"[DONE][FOLDER] {src_dir.name} -> version.nfo = {new_ver}; commit wykonany." if not dry_run
           else f"[DRY-RUN][FOLDER] {src_dir.name} -> version.nfo będzie {new_ver}; commit planowany.")
 
-    if ARGS.gh_release and not dry_run:
-        name = src_dir.name
-        tag = build_release_tag(name, new_ver)
-        title = f"{name} v{new_ver}"
-        template = getattr(ARGS, "release_notes_template", RELEASE_NOTES_TEMPLATE)
-        notes = template.format(name=name, version=new_ver, tag=tag)
-        assets = [zip_path] if zip_path else []
-        if commit_sha is None:
-            commit_sha = git_current_head(src_dir)
-        create_git_tag(src_dir, tag, title, commit_sha)
-        push_git_tag(src_dir, tag)
-        publish_github_release(src_dir, tag, title, notes, assets)
-
-
 def main() -> int:
     global ARGS
     ARGS = parse_args()
@@ -748,10 +598,6 @@ def main() -> int:
     if check_mode:
         ARGS.dry_run = True
 
-    ARGS.release_tag_prefix = (ARGS.release_tag_prefix or "").strip() or None
-    ARGS.release_notes_template = ARGS.release_notes_template or RELEASE_NOTES_TEMPLATE
-    ARGS.git_remote = ARGS.git_remote or GIT_REMOTE_NAME
-
     mode = ARGS.mode
     user = ARGS.user
     appdata_kind = ARGS.appdata_kind if ARGS.appdata_kind != "None" else None
@@ -777,11 +623,9 @@ def main() -> int:
         if not src_dir.is_dir():
             raise FileNotFoundError(f"[SINGLE] Brak katalogu: {norm(src_dir)}")
 
-        root_info = maybe_bump_root_version(source_base, changed_any=True, dry_run=dry_run)
-        if root_info:
+        root_bumped = maybe_bump_root_version(source_base, changed_any=True, dry_run=dry_run)
+        if root_bumped:
             pending_actions = True
-            root_version, root_commit = root_info
-            maybe_publish_root_release(source_base, root_version, root_commit, dry_run)
 
         pending_actions = True
 
@@ -802,11 +646,9 @@ def main() -> int:
     if changed:
         pending_actions = True
 
-    root_info = maybe_bump_root_version(source_base, changed_any=bool(changed), dry_run=dry_run)
-    if root_info:
+    root_bumped = maybe_bump_root_version(source_base, changed_any=bool(changed), dry_run=dry_run)
+    if root_bumped:
         pending_actions = True
-        root_version, root_commit = root_info
-        maybe_publish_root_release(source_base, root_version, root_commit, dry_run)
 
     if not changed:
         print("[INFO] Brak zmian do przetworzenia.")

help_scripts/version.nfo

@@ -1 +1 @@
-0.4
+0.5

nucleares_monitor/mon.json

@@ -1,882 +0,0 @@
-{
-  "host": "localhost",
-  "port": 8785,
-  "refresh_interval": 1.0,
-  "variables_keys": [
-    "condenser_volume",
-    "coolant_core_flow_reached_speed",
-    "coolant_core_flow_speed",
-    "core_iodine_cumulative",
-    "core_iodine_generation",
-    "core_state_criticality",
-    "core_temp",
-    "core_xenon_cumulative",
-    "core_xenon_generation",
-    "generator_0_kw",
-    "steam_turbine_0_pressure",
-    "steam_turbine_0_rpm",
-    "steam_turbine_0_temperature",
-    "coolant_sec_0_liquid_volume",
-    "coolant_sec_0_pressure",
-    "coolant_sec_0_temperature",
-    "coolant_sec_0_volume"
-  ],
-  "vars": {
-    "condenser_volume": {
-      "display_name": "CONDENSER_VOLUME",
-      "thresholds": {
-        "dead_low": null,
-        "low": null,
-        "high": null,
-        "extreme_high": null,
-        "alarm_dead_low": true,
-        "alarm_low": false,
-        "alarm_high": false,
-        "alarm_extreme_high": true,
-        "action_dead_low": null,
-        "value_dead_low": "1",
-        "action_dead_low_interval": 1.0,
-        "action_low": null,
-        "value_low": "1",
-        "action_low_interval": 1.0,
-        "action_high": null,
-        "value_high": "1",
-        "action_high_interval": 1.0,
-        "action_extreme_high": null,
-        "value_extreme_high": "1",
-        "action_extreme_high_interval": 1.0,
-        "action_operating": null,
-        "value_operating": "1",
-        "action_operating_interval": 1.0,
-        "expr_dead_low": null,
-        "expr_low": null,
-        "expr_operating": null,
-        "expr_high": null,
-        "expr_extreme_high": null,
-        "expr_target_dead_low": null,
-        "expr_target_low": null,
-        "expr_target_operating": null,
-        "expr_target_high": null,
-        "expr_target_extreme_high": null,
-        "expr_operating_interval": 1.0,
-        "y_source": null,
-        "z_source": null,
-        "expr_x_source_dead_low": "raw",
-        "expr_x_source_low": "raw",
-        "expr_x_source_operating": "raw",
-        "expr_x_source_high": "raw",
-        "expr_x_source_extreme_high": "raw",
-        "expr_thr_dead_low": null,
-        "expr_thr_low": null,
-        "expr_thr_high": null,
-        "expr_thr_extreme_high": null
-      }
-    },
-    "coolant_core_flow_reached_speed": {
-      "display_name": "COOLANT_CORE_FLOW_REACHED_SPEED",
-      "thresholds": {
-        "dead_low": null,
-        "low": null,
-        "high": null,
-        "extreme_high": null,
-        "alarm_dead_low": true,
-        "alarm_low": false,
-        "alarm_high": false,
-        "alarm_extreme_high": true,
-        "action_dead_low": null,
-        "value_dead_low": "1",
-        "action_dead_low_interval": 1.0,
-        "action_low": null,
-        "value_low": "1",
-        "action_low_interval": 1.0,
-        "action_high": null,
-        "value_high": "1",
-        "action_high_interval": 1.0,
-        "action_extreme_high": null,
-        "value_extreme_high": "1",
-        "action_extreme_high_interval": 1.0,
-        "action_operating": null,
-        "value_operating": "1",
-        "action_operating_interval": 1.0,
-        "expr_dead_low": null,
-        "expr_low": null,
-        "expr_operating": null,
-        "expr_high": null,
-        "expr_extreme_high": null,
-        "expr_target_dead_low": null,
-        "expr_target_low": null,
-        "expr_target_operating": null,
-        "expr_target_high": null,
-        "expr_target_extreme_high": null,
-        "expr_operating_interval": 1.0,
-        "y_source": null,
-        "z_source": null,
-        "expr_x_source_dead_low": "raw",
-        "expr_x_source_low": "raw",
-        "expr_x_source_operating": "raw",
-        "expr_x_source_high": "raw",
-        "expr_x_source_extreme_high": "raw",
-        "expr_thr_dead_low": null,
-        "expr_thr_low": null,
-        "expr_thr_high": null,
-        "expr_thr_extreme_high": null
-      }
-    },
-    "coolant_core_flow_speed": {
-      "display_name": "COOLANT_CORE_FLOW_SPEED",
-      "thresholds": {
-        "dead_low": null,
-        "low": null,
-        "high": null,
-        "extreme_high": null,
-        "alarm_dead_low": true,
-        "alarm_low": false,
-        "alarm_high": false,
-        "alarm_extreme_high": true,
-        "action_dead_low": null,
-        "value_dead_low": "1",
-        "action_dead_low_interval": 1.0,
-        "action_low": null,
-        "value_low": "1",
-        "action_low_interval": 1.0,
-        "action_high": null,
-        "value_high": "1",
-        "action_high_interval": 1.0,
-        "action_extreme_high": null,
-        "value_extreme_high": "1",
-        "action_extreme_high_interval": 1.0,
-        "action_operating": null,
-        "value_operating": "1",
-        "action_operating_interval": 1.0,
-        "expr_dead_low": null,
-        "expr_low": null,
-        "expr_operating": null,
-        "expr_high": null,
-        "expr_extreme_high": null,
-        "expr_target_dead_low": null,
-        "expr_target_low": null,
-        "expr_target_operating": null,
-        "expr_target_high": null,
-        "expr_target_extreme_high": null,
-        "expr_operating_interval": 1.0,
-        "y_source": null,
-        "z_source": null,
-        "expr_x_source_dead_low": "raw",
-        "expr_x_source_low": "raw",
-        "expr_x_source_operating": "raw",
-        "expr_x_source_high": "raw",
-        "expr_x_source_extreme_high": "raw",
-        "expr_thr_dead_low": null,
-        "expr_thr_low": null,
-        "expr_thr_high": null,
-        "expr_thr_extreme_high": null
-      }
-    },
-    "core_iodine_cumulative": {
-      "display_name": "CORE_IODINE_CUMULATIVE",
-      "thresholds": {
-        "dead_low": null,
-        "low": null,
-        "high": null,
-        "extreme_high": null,
-        "alarm_dead_low": true,
-        "alarm_low": false,
-        "alarm_high": false,
-        "alarm_extreme_high": true,
-        "action_dead_low": null,
-        "value_dead_low": "1",
-        "action_dead_low_interval": 1.0,
-        "action_low": null,
-        "value_low": "1",
-        "action_low_interval": 1.0,
-        "action_high": null,
-        "value_high": "1",
-        "action_high_interval": 1.0,
-        "action_extreme_high": null,
-        "value_extreme_high": "1",
-        "action_extreme_high_interval": 1.0,
-        "action_operating": null,
-        "value_operating": "1",
-        "action_operating_interval": 1.0,
-        "expr_dead_low": null,
-        "expr_low": null,
-        "expr_operating": null,
-        "expr_high": null,
-        "expr_extreme_high": null,
-        "expr_target_dead_low": null,
-        "expr_target_low": null,
-        "expr_target_operating": null,
-        "expr_target_high": null,
-        "expr_target_extreme_high": null,
-        "expr_operating_interval": 1.0,
-        "y_source": null,
-        "z_source": null,
-        "expr_x_source_dead_low": "raw",
-        "expr_x_source_low": "raw",
-        "expr_x_source_operating": "raw",
-        "expr_x_source_high": "raw",
-        "expr_x_source_extreme_high": "raw",
-        "expr_thr_dead_low": null,
-        "expr_thr_low": null,
-        "expr_thr_high": null,
-        "expr_thr_extreme_high": null
-      }
-    },
-    "core_iodine_generation": {
-      "display_name": "CORE_IODINE_GENERATION",
-      "thresholds": {
-        "dead_low": null,
-        "low": null,
-        "high": null,
-        "extreme_high": null,
-        "alarm_dead_low": true,
-        "alarm_low": false,
-        "alarm_high": false,
-        "alarm_extreme_high": true,
-        "action_dead_low": null,
-        "value_dead_low": "1",
-        "action_dead_low_interval": 1.0,
-        "action_low": null,
-        "value_low": "1",
-        "action_low_interval": 1.0,
-        "action_high": null,
-        "value_high": "1",
-        "action_high_interval": 1.0,
-        "action_extreme_high": null,
-        "value_extreme_high": "1",
-        "action_extreme_high_interval": 1.0,
-        "action_operating": null,
-        "value_operating": "1",
-        "action_operating_interval": 1.0,
-        "expr_dead_low": null,
-        "expr_low": null,
-        "expr_operating": null,
-        "expr_high": null,
-        "expr_extreme_high": null,
-        "expr_target_dead_low": null,
-        "expr_target_low": null,
-        "expr_target_operating": null,
-        "expr_target_high": null,
-        "expr_target_extreme_high": null,
-        "expr_operating_interval": 1.0,
-        "y_source": null,
-        "z_source": null,
-        "expr_x_source_dead_low": "raw",
-        "expr_x_source_low": "raw",
-        "expr_x_source_operating": "raw",
-        "expr_x_source_high": "raw",
-        "expr_x_source_extreme_high": "raw",
-        "expr_thr_dead_low": null,
-        "expr_thr_low": null,
-        "expr_thr_high": null,
-        "expr_thr_extreme_high": null
-      }
-    },
-    "core_state_criticality": {
-      "display_name": "CORE_STATE_CRITICALITY",
-      "thresholds": {
-        "dead_low": null,
-        "low": null,
-        "high": null,
-        "extreme_high": null,
-        "alarm_dead_low": true,
-        "alarm_low": false,
-        "alarm_high": false,
-        "alarm_extreme_high": true,
-        "action_dead_low": null,
-        "value_dead_low": "1",
-        "action_dead_low_interval": 1.0,
-        "action_low": null,
-        "value_low": "1",
-        "action_low_interval": 1.0,
-        "action_high": null,
-        "value_high": "1",
-        "action_high_interval": 1.0,
-        "action_extreme_high": null,
-        "value_extreme_high": "1",
-        "action_extreme_high_interval": 1.0,
-        "action_operating": null,
-        "value_operating": "1",
-        "action_operating_interval": 1.0,
-        "expr_dead_low": null,
-        "expr_low": null,
-        "expr_operating": null,
-        "expr_high": null,
-        "expr_extreme_high": null,
-        "expr_target_dead_low": null,
-        "expr_target_low": null,
-        "expr_target_operating": null,
-        "expr_target_high": null,
-        "expr_target_extreme_high": null,
-        "expr_operating_interval": 1.0,
-        "y_source": null,
-        "z_source": null,
-        "expr_x_source_dead_low": "raw",
-        "expr_x_source_low": "raw",
-        "expr_x_source_operating": "raw",
-        "expr_x_source_high": "raw",
-        "expr_x_source_extreme_high": "raw",
-        "expr_thr_dead_low": null,
-        "expr_thr_low": null,
-        "expr_thr_high": null,
-        "expr_thr_extreme_high": null
-      }
-    },
-    "core_temp": {
-      "display_name": "CORE_TEMP",
-      "thresholds": {
-        "dead_low": null,
-        "low": null,
-        "high": null,
-        "extreme_high": null,
-        "alarm_dead_low": true,
-        "alarm_low": false,
-        "alarm_high": false,
-        "alarm_extreme_high": true,
-        "action_dead_low": null,
-        "value_dead_low": "1",
-        "action_dead_low_interval": 1.0,
-        "action_low": null,
-        "value_low": "1",
-        "action_low_interval": 1.0,
-        "action_high": null,
-        "value_high": "1",
-        "action_high_interval": 1.0,
-        "action_extreme_high": null,
-        "value_extreme_high": "1",
-        "action_extreme_high_interval": 1.0,
-        "action_operating": null,
-        "value_operating": "1",
-        "action_operating_interval": 1.0,
-        "expr_dead_low": null,
-        "expr_low": null,
-        "expr_operating": null,
-        "expr_high": null,
-        "expr_extreme_high": null,
-        "expr_target_dead_low": null,
-        "expr_target_low": null,
-        "expr_target_operating": null,
-        "expr_target_high": null,
-        "expr_target_extreme_high": null,
-        "expr_operating_interval": 1.0,
-        "y_source": null,
-        "z_source": null,
-        "expr_x_source_dead_low": "raw",
-        "expr_x_source_low": "raw",
-        "expr_x_source_operating": "raw",
-        "expr_x_source_high": "raw",
-        "expr_x_source_extreme_high": "raw",
-        "expr_thr_dead_low": null,
-        "expr_thr_low": null,
-        "expr_thr_high": null,
-        "expr_thr_extreme_high": null
-      }
-    },
-    "core_xenon_cumulative": {
-      "display_name": "CORE_XENON_CUMULATIVE",
-      "thresholds": {
-        "dead_low": null,
-        "low": null,
-        "high": null,
-        "extreme_high": null,
-        "alarm_dead_low": true,
-        "alarm_low": false,
-        "alarm_high": false,
-        "alarm_extreme_high": true,
-        "action_dead_low": null,
-        "value_dead_low": "1",
-        "action_dead_low_interval": 1.0,
-        "action_low": null,
-        "value_low": "1",
-        "action_low_interval": 1.0,
-        "action_high": null,
-        "value_high": "1",
-        "action_high_interval": 1.0,
-        "action_extreme_high": null,
-        "value_extreme_high": "1",
-        "action_extreme_high_interval": 1.0,
-        "action_operating": null,
-        "value_operating": "1",
-        "action_operating_interval": 1.0,
-        "expr_dead_low": null,
-        "expr_low": null,
-        "expr_operating": null,
-        "expr_high": null,
-        "expr_extreme_high": null,
-        "expr_target_dead_low": null,
-        "expr_target_low": null,
-        "expr_target_operating": null,
-        "expr_target_high": null,
-        "expr_target_extreme_high": null,
-        "expr_operating_interval": 1.0,
-        "y_source": null,
-        "z_source": null,
-        "expr_x_source_dead_low": "raw",
-        "expr_x_source_low": "raw",
-        "expr_x_source_operating": "raw",
-        "expr_x_source_high": "raw",
-        "expr_x_source_extreme_high": "raw",
-        "expr_thr_dead_low": null,
-        "expr_thr_low": null,
-        "expr_thr_high": null,
-        "expr_thr_extreme_high": null
-      }
-    },
-    "core_xenon_generation": {
-      "display_name": "CORE_XENON_GENERATION",
-      "thresholds": {
-        "dead_low": null,
-        "low": null,
-        "high": null,
-        "extreme_high": null,
-        "alarm_dead_low": true,
-        "alarm_low": false,
-        "alarm_high": false,
-        "alarm_extreme_high": true,
-        "action_dead_low": null,
-        "value_dead_low": "1",
-        "action_dead_low_interval": 1.0,
-        "action_low": null,
-        "value_low": "1",
-        "action_low_interval": 1.0,
-        "action_high": null,
-        "value_high": "1",
-        "action_high_interval": 1.0,
-        "action_extreme_high": null,
-        "value_extreme_high": "1",
-        "action_extreme_high_interval": 1.0,
-        "action_operating": null,
-        "value_operating": "1",
-        "action_operating_interval": 1.0,
-        "expr_dead_low": null,
-        "expr_low": null,
-        "expr_operating": null,
-        "expr_high": null,
-        "expr_extreme_high": null,
-        "expr_target_dead_low": null,
-        "expr_target_low": null,
-        "expr_target_operating": null,
-        "expr_target_high": null,
-        "expr_target_extreme_high": null,
-        "expr_operating_interval": 1.0,
-        "y_source": null,
-        "z_source": null,
-        "expr_x_source_dead_low": "raw",
-        "expr_x_source_low": "raw",
-        "expr_x_source_operating": "raw",
-        "expr_x_source_high": "raw",
-        "expr_x_source_extreme_high": "raw",
-        "expr_thr_dead_low": null,
-        "expr_thr_low": null,
-        "expr_thr_high": null,
-        "expr_thr_extreme_high": null
-      }
-    },
-    "generator_0_kw": {
-      "display_name": "GENERATOR_0_KW",
-      "thresholds": {
-        "dead_low": null,
-        "low": null,
-        "high": null,
-        "extreme_high": null,
-        "alarm_dead_low": true,
-        "alarm_low": false,
-        "alarm_high": false,
-        "alarm_extreme_high": true,
-        "action_dead_low": null,
-        "value_dead_low": "1",
-        "action_dead_low_interval": 1.0,
-        "action_low": null,
-        "value_low": "1",
-        "action_low_interval": 1.0,
-        "action_high": null,
-        "value_high": "1",
-        "action_high_interval": 1.0,
-        "action_extreme_high": null,
-        "value_extreme_high": "1",
-        "action_extreme_high_interval": 1.0,
-        "action_operating": null,
-        "value_operating": "1",
-        "action_operating_interval": 1.0,
-        "expr_dead_low": null,
-        "expr_low": null,
-        "expr_operating": null,
-        "expr_high": null,
-        "expr_extreme_high": null,
-        "expr_target_dead_low": null,
-        "expr_target_low": null,
-        "expr_target_operating": null,
-        "expr_target_high": null,
-        "expr_target_extreme_high": null,
-        "expr_operating_interval": 1.0,
-        "y_source": null,
-        "z_source": null,
-        "expr_x_source_dead_low": "raw",
-        "expr_x_source_low": "raw",
-        "expr_x_source_operating": "raw",
-        "expr_x_source_high": "raw",
-        "expr_x_source_extreme_high": "raw",
-        "expr_thr_dead_low": null,
-        "expr_thr_low": null,
-        "expr_thr_high": null,
-        "expr_thr_extreme_high": null
-      }
-    },
-    "steam_turbine_0_pressure": {
-      "display_name": "STEAM_TURBINE_0_PRESSURE",
-      "thresholds": {
-        "dead_low": null,
-        "low": null,
-        "high": null,
-        "extreme_high": null,
-        "alarm_dead_low": true,
-        "alarm_low": false,
-        "alarm_high": false,
-        "alarm_extreme_high": true,
-        "action_dead_low": null,
-        "value_dead_low": "1",
-        "action_dead_low_interval": 1.0,
-        "action_low": null,
-        "value_low": "1",
-        "action_low_interval": 1.0,
-        "action_high": null,
-        "value_high": "1",
-        "action_high_interval": 1.0,
-        "action_extreme_high": null,
-        "value_extreme_high": "1",
-        "action_extreme_high_interval": 1.0,
-        "action_operating": null,
-        "value_operating": "1",
-        "action_operating_interval": 1.0,
-        "expr_dead_low": null,
-        "expr_low": null,
-        "expr_operating": null,
-        "expr_high": null,
-        "expr_extreme_high": null,
-        "expr_target_dead_low": null,
-        "expr_target_low": null,
-        "expr_target_operating": null,
-        "expr_target_high": null,
-        "expr_target_extreme_high": null,
-        "expr_operating_interval": 1.0,
-        "y_source": null,
-        "z_source": null,
-        "expr_x_source_dead_low": "raw",
-        "expr_x_source_low": "raw",
-        "expr_x_source_operating": "raw",
-        "expr_x_source_high": "raw",
-        "expr_x_source_extreme_high": "raw",
-        "expr_thr_dead_low": null,
-        "expr_thr_low": null,
-        "expr_thr_high": null,
-        "expr_thr_extreme_high": null
-      }
-    },
-    "steam_turbine_0_rpm": {
-      "display_name": "STEAM_TURBINE_0_RPM",
-      "thresholds": {
-        "dead_low": null,
-        "low": null,
-        "high": null,
-        "extreme_high": null,
-        "alarm_dead_low": true,
-        "alarm_low": false,
-        "alarm_high": false,
-        "alarm_extreme_high": true,
-        "action_dead_low": null,
-        "value_dead_low": "1",
-        "action_dead_low_interval": 1.0,
-        "action_low": null,
-        "value_low": "1",
-        "action_low_interval": 1.0,
-        "action_high": null,
-        "value_high": "1",
-        "action_high_interval": 1.0,
-        "action_extreme_high": null,
-        "value_extreme_high": "1",
-        "action_extreme_high_interval": 1.0,
-        "action_operating": null,
-        "value_operating": "1",
-        "action_operating_interval": 1.0,
-        "expr_dead_low": null,
-        "expr_low": null,
-        "expr_operating": null,
-        "expr_high": null,
-        "expr_extreme_high": null,
-        "expr_target_dead_low": null,
-        "expr_target_low": null,
-        "expr_target_operating": null,
-        "expr_target_high": null,
-        "expr_target_extreme_high": null,
-        "expr_operating_interval": 1.0,
-        "y_source": null,
-        "z_source": null,
-        "expr_x_source_dead_low": "raw",
-        "expr_x_source_low": "raw",
-        "expr_x_source_operating": "raw",
-        "expr_x_source_high": "raw",
-        "expr_x_source_extreme_high": "raw",
-        "expr_thr_dead_low": null,
-        "expr_thr_low": null,
-        "expr_thr_high": null,
-        "expr_thr_extreme_high": null
-      }
-    },
-    "steam_turbine_0_temperature": {
-      "display_name": "STEAM_TURBINE_0_TEMPERATURE",
-      "thresholds": {
-        "dead_low": null,
-        "low": null,
-        "high": null,
-        "extreme_high": null,
-        "alarm_dead_low": true,
-        "alarm_low": false,
-        "alarm_high": false,
-        "alarm_extreme_high": true,
-        "action_dead_low": null,
-        "value_dead_low": "1",
-        "action_dead_low_interval": 1.0,
-        "action_low": null,
-        "value_low": "1",
-        "action_low_interval": 1.0,
-        "action_high": null,
-        "value_high": "1",
-        "action_high_interval": 1.0,
-        "action_extreme_high": null,
-        "value_extreme_high": "1",
-        "action_extreme_high_interval": 1.0,
-        "action_operating": null,
-        "value_operating": "1",
-        "action_operating_interval": 1.0,
-        "expr_dead_low": null,
-        "expr_low": null,
-        "expr_operating": null,
-        "expr_high": null,
-        "expr_extreme_high": null,
-        "expr_target_dead_low": null,
-        "expr_target_low": null,
-        "expr_target_operating": null,
-        "expr_target_high": null,
-        "expr_target_extreme_high": null,
-        "expr_operating_interval": 1.0,
-        "y_source": null,
-        "z_source": null,
-        "expr_x_source_dead_low": "raw",
-        "expr_x_source_low": "raw",
-        "expr_x_source_operating": "raw",
-        "expr_x_source_high": "raw",
-        "expr_x_source_extreme_high": "raw",
-        "expr_thr_dead_low": null,
-        "expr_thr_low": null,
-        "expr_thr_high": null,
-        "expr_thr_extreme_high": null
-      }
-    },
-    "coolant_sec_0_liquid_volume": {
-      "display_name": "COOLANT_SEC_0_LIQUID_VOLUME",
-      "thresholds": {
-        "dead_low": null,
-        "low": null,
-        "high": null,
-        "extreme_high": null,
-        "alarm_dead_low": true,
-        "alarm_low": false,
-        "alarm_high": false,
-        "alarm_extreme_high": true,
-        "action_dead_low": null,
-        "value_dead_low": "1",
-        "action_dead_low_interval": 1.0,
-        "action_low": null,
-        "value_low": "1",
-        "action_low_interval": 1.0,
-        "action_high": null,
-        "value_high": "1",
-        "action_high_interval": 1.0,
-        "action_extreme_high": null,
-        "value_extreme_high": "1",
-        "action_extreme_high_interval": 1.0,
-        "action_operating": null,
-        "value_operating": "1",
-        "action_operating_interval": 1.0,
-        "expr_dead_low": null,
-        "expr_low": null,
-        "expr_operating": null,
-        "expr_high": null,
-        "expr_extreme_high": null,
-        "expr_target_dead_low": null,
-        "expr_target_low": null,
-        "expr_target_operating": null,
-        "expr_target_high": null,
-        "expr_target_extreme_high": null,
-        "expr_operating_interval": 1.0,
-        "y_source": null,
-        "z_source": null,
-        "expr_x_source_dead_low": "raw",
-        "expr_x_source_low": "raw",
-        "expr_x_source_operating": "raw",
-        "expr_x_source_high": "raw",
-        "expr_x_source_extreme_high": "raw",
-        "expr_thr_dead_low": null,
-        "expr_thr_low": null,
-        "expr_thr_high": null,
-        "expr_thr_extreme_high": null
-      }
-    },
-    "coolant_sec_0_pressure": {
-      "display_name": "COOLANT_SEC_0_PRESSURE",
-      "thresholds": {
-        "dead_low": null,
-        "low": null,
-        "high": null,
-        "extreme_high": null,
-        "alarm_dead_low": true,
-        "alarm_low": false,
-        "alarm_high": false,
-        "alarm_extreme_high": true,
-        "action_dead_low": null,
-        "value_dead_low": "1",
-        "action_dead_low_interval": 1.0,
-        "action_low": null,
-        "value_low": "1",
-        "action_low_interval": 1.0,
-        "action_high": null,
-        "value_high": "1",
-        "action_high_interval": 1.0,
-        "action_extreme_high": null,
-        "value_extreme_high": "1",
-        "action_extreme_high_interval": 1.0,
-        "action_operating": null,
-        "value_operating": "1",
-        "action_operating_interval": 1.0,
-        "expr_dead_low": null,
-        "expr_low": null,
-        "expr_operating": null,
-        "expr_high": null,
-        "expr_extreme_high": null,
-        "expr_target_dead_low": null,
-        "expr_target_low": null,
-        "expr_target_operating": null,
-        "expr_target_high": null,
-        "expr_target_extreme_high": null,
-        "expr_operating_interval": 1.0,
-        "y_source": null,
-        "z_source": null,
-        "expr_x_source_dead_low": "raw",
-        "expr_x_source_low": "raw",
-        "expr_x_source_operating": "raw",
-        "expr_x_source_high": "raw",
-        "expr_x_source_extreme_high": "raw",
-        "expr_thr_dead_low": null,
-        "expr_thr_low": null,
-        "expr_thr_high": null,
-        "expr_thr_extreme_high": null
-      }
-    },
-    "coolant_sec_0_temperature": {
-      "display_name": "COOLANT_SEC_0_TEMPERATURE",
-      "thresholds": {
-        "dead_low": null,
-        "low": null,
-        "high": null,
-        "extreme_high": null,
-        "alarm_dead_low": true,
-        "alarm_low": false,
-        "alarm_high": false,
-        "alarm_extreme_high": true,
-        "action_dead_low": null,
-        "value_dead_low": "1",
-        "action_dead_low_interval": 1.0,
-        "action_low": null,
-        "value_low": "1",
-        "action_low_interval": 1.0,
-        "action_high": null,
-        "value_high": "1",
-        "action_high_interval": 1.0,
-        "action_extreme_high": null,
-        "value_extreme_high": "1",
-        "action_extreme_high_interval": 1.0,
-        "action_operating": null,
-        "value_operating": "1",
-        "action_operating_interval": 1.0,
-        "expr_dead_low": null,
-        "expr_low": null,
-        "expr_operating": null,
-        "expr_high": null,
-        "expr_extreme_high": null,
-        "expr_target_dead_low": null,
-        "expr_target_low": null,
-        "expr_target_operating": null,
-        "expr_target_high": null,
-        "expr_target_extreme_high": null,
-        "expr_operating_interval": 1.0,
-        "y_source": null,
-        "z_source": null,
-        "expr_x_source_dead_low": "raw",
-        "expr_x_source_low": "raw",
-        "expr_x_source_operating": "raw",
-        "expr_x_source_high": "raw",
-        "expr_x_source_extreme_high": "raw",
-        "expr_thr_dead_low": null,
-        "expr_thr_low": null,
-        "expr_thr_high": null,
-        "expr_thr_extreme_high": null
-      }
-    },
-    "coolant_sec_0_volume": {
-      "display_name": "COOLANT_SEC_0_VOLUME",
-      "thresholds": {
-        "dead_low": null,
-        "low": null,
-        "high": null,
-        "extreme_high": null,
-        "alarm_dead_low": true,
-        "alarm_low": false,
-        "alarm_high": false,
-        "alarm_extreme_high": true,
-        "action_dead_low": null,
-        "value_dead_low": "1",
-        "action_dead_low_interval": 1.0,
-        "action_low": null,
-        "value_low": "1",
-        "action_low_interval": 1.0,
-        "action_high": null,
-        "value_high": "1",
-        "action_high_interval": 1.0,
-        "action_extreme_high": null,
-        "value_extreme_high": "1",
-        "action_extreme_high_interval": 1.0,
-        "action_operating": null,
-        "value_operating": "1",
-        "action_operating_interval": 1.0,
-        "expr_dead_low": null,
-        "expr_low": null,
-        "expr_operating": null,
-        "expr_high": null,
-        "expr_extreme_high": null,
-        "expr_target_dead_low": null,
-        "expr_target_low": null,
-        "expr_target_operating": null,
-        "expr_target_high": null,
-        "expr_target_extreme_high": null,
-        "expr_operating_interval": 1.0,
-        "y_source": null,
-        "z_source": null,
-        "expr_x_source_dead_low": "raw",
-        "expr_x_source_low": "raw",
-        "expr_x_source_operating": "raw",
-        "expr_x_source_high": "raw",
-        "expr_x_source_extreme_high": "raw",
-        "expr_thr_dead_low": null,
-        "expr_thr_low": null,
-        "expr_thr_high": null,
-        "expr_thr_extreme_high": null
-      }
-    }
-  },
-  "scheduled_tasks": [],
-  "display_defaults": {
-    "backend": "pyqtgraph",
-    "samples": 200,
-    "max_draw_pts": 400
-  }
-}

nucleares_monitor/tests/test_arrange_windows.py

@@ -1,140 +0,0 @@
-#!/usr/bin/env python3
-"""
-Quick test to verify the arrange_plot_windows function improvements.
-This script simulates the functionality without running the full nuclear monitor.
-"""
-
-import math
-
-def test_best_grid():
-    """Test the improved grid calculation"""
-    def best_grid(n):
-        if n <= 0:
-            return (1, 1)
-        # For small number of windows, prefer horizontal layout
-        if n <= 3:
-            return (1, n)
-        if n == 4:
-            return (2, 2)
-        
-        # For larger numbers: approximate square, but prefer width
-        cols = int(math.ceil(math.sqrt(n)))
-        if cols * (cols - 1) >= n:  # check if we can reduce rows
-            cols -= 1
-        rows = int(math.ceil(n / cols))
-        return (rows, cols)
-    
-    test_cases = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 16]
-    
-    print("Grid layout tests:")
-    print("Windows | Grid (rows x cols) | Layout")
-    print("--------|-------------------|--------")
-    
-    for n in test_cases:
-        rows, cols = best_grid(n)
-        layout = "x".join(["O"] * cols)
-        layout = " | ".join([layout] * rows)
-        print(f"{n:7d} | {rows:2d} x {cols:2d}           | {layout}")
-
-def test_window_padding():
-    """Test the window-specific padding"""
-    def get_window_padding(kind):
-        if kind == "qt":
-            return (15, 40)  # Qt needs more space for title bar
-        else:
-            return (8, 12)   # Tk windows
-    
-    print("\nWindow padding tests:")
-    print("Type | Width Pad | Height Pad | Reason")
-    print("-----|-----------|------------|--------")
-    
-    for kind in ["tk", "qt"]:
-        w_pad, h_pad = get_window_padding(kind)
-        reason = "Qt title bar & frames" if kind == "qt" else "Tk decorations"
-        print(f"{kind:4s} | {w_pad:9d} | {h_pad:10d} | {reason}")
-
-def test_arrangement_calculation():
-    """Test the arrangement calculation for different scenarios"""
-    print("\nArrangement calculation test:")
-    
-    # Simulate monitor: 1920x1080
-    mon_w, mon_h = 1920, 1080
-    SIDE_MARGIN = 12
-    TOP_MARGIN = 60
-    BOTTOM_MARGIN = 12
-    CELL_PAD = 10
-    MAX_W, MAX_H = 380, 210  # Half of 760x420
-    
-    test_scenarios = [
-        (2, "Two windows - should be side by side"),
-        (4, "Four windows - 2x2 grid"),
-        (6, "Six windows - 2x3 or 3x2 grid"),
-        (9, "Nine windows - full screen mode"),
-    ]
-    
-    def best_grid(n):
-        if n <= 0:
-            return (1, 1)
-        if n <= 3:
-            return (1, n)
-        if n == 4:
-            return (2, 2)
-        cols = int(math.ceil(math.sqrt(n)))
-        if cols * (cols - 1) >= n:
-            cols -= 1
-        rows = int(math.ceil(n / cols))
-        return (rows, cols)
-    
-    for n_windows, description in test_scenarios:
-        print(f"\n{description}")
-        print(f"Windows: {n_windows}")
-        
-        rows, cols = best_grid(n_windows)
-        use_max_size = n_windows < 9
-        
-        # Calculate available space
-        available_w = mon_w - (cols + 1) * CELL_PAD - 2 * SIDE_MARGIN
-        available_h = mon_h - (rows + 1) * CELL_PAD - TOP_MARGIN - BOTTOM_MARGIN
-        
-        # Initial cell size
-        cell_w = max(1, available_w // cols)
-        cell_h = max(1, available_h // rows)
-        
-        # Apply max size constraint for few windows
-        if use_max_size:
-            cell_w = min(MAX_W, cell_w)
-            cell_h = min(MAX_H, cell_h)
-        
-        print(f"Grid: {rows}x{cols}")
-        print(f"Available space: {available_w}x{available_h}")
-        print(f"Cell size: {cell_w}x{cell_h}")
-        print(f"Max size applied: {use_max_size}")
-        
-        # Test padding for different window types
-        for win_type in ["tk", "qt"]:
-            if win_type == "qt":
-                w_pad, h_pad = (15, 40)
-            else:
-                w_pad, h_pad = (8, 12)
-            
-            adj_w = max(50, cell_w - w_pad)
-            adj_h = max(50, cell_h - h_pad)
-            print(f"  {win_type} windows: {adj_w}x{adj_h} (after padding)")
-
-if __name__ == "__main__":
-    print("Testing arrange_plot_windows improvements\n")
-    print("=" * 50)
-    
-    test_best_grid()
-    test_window_padding()
-    test_arrangement_calculation()
-    
-    print("\n" + "=" * 50)
-    print("All tests completed. The arrange_plot_windows function should now:")
-    print("1. ✅ Properly detect both Qt and matplotlib windows")
-    print("2. ✅ Use improved grid layout (prefer horizontal for few windows)")
-    print("3. ✅ Apply appropriate padding for different window types")
-    print("4. ✅ Arrange windows top-to-bottom, left-to-right")
-    print("5. ✅ Handle multiple displays correctly")
-    print("6. ✅ Scale down when windows don't fit")
-    print("7. ✅ Sort windows alphabetically by display name")

nucleares_monitor/tests/test_arrangement_fixes.py

@@ -1,240 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to verify the fixed arrange_plot_windows function.
-
-This tests:
-1. Column-first arrangement (a-z in first column, then second column, etc.)
-2. Corrected padding (Qt gets less padding, matplotlib gets more padding)
-3. No double size calculation issues
-4. Proper window detection from unified storage
-"""
-
-
-# Mock window classes for testing
-class MockQtWindow:
-    def __init__(self, name):
-        self.name = name
-        self.geometry_calls = []
-
-    def setGeometry(self, x, y, w, h):
-        self.geometry_calls.append((x, y, w, h))
-        print(f"Qt Window '{self.name}': setGeometry({x}, {y}, {w}, {h})")
-
-
-class MockTkWindow:
-    def __init__(self, name):
-        self.name = name
-        self.geometry_calls = []
-
-    def geometry(self, geom_str):
-        self.geometry_calls.append(geom_str)
-        print(f"Tk Window '{self.name}': geometry('{geom_str}')")
-
-
-def test_arrangement_and_padding():
-    """Test the column-first arrangement and corrected padding values."""
-
-    print("=== Testing Column-First Arrangement and Corrected Padding ===\n")
-
-    # Test case: 6 windows arranged in a 3x2 grid (3 rows, 2 columns)
-    windows = [
-        ("qt", MockQtWindow("PlotA"), "PlotA"),
-        ("tk", MockTkWindow("PlotB"), "PlotB"),
-        ("qt", MockQtWindow("PlotC"), "PlotC"),
-        ("tk", MockTkWindow("PlotD"), "PlotD"),
-        ("qt", MockQtWindow("PlotE"), "PlotE"),
-        ("tk", MockTkWindow("PlotF"), "PlotF"),
-    ]
-
-    # Grid parameters
-    cols = 2
-    rows = 3
-    cell_w = 400
-    cell_h = 300
-    CELL_PAD = 10
-
-    # Mock monitor bounds
-    L, T, R, B = 100, 100, 1500, 900
-    SIDE_MARGIN = 20
-    TOP_MARGIN = 50
-    BOTTOM_MARGIN = 50
-
-    # Calculate grid layout (similar to real function)
-    grid_w = cell_w * cols + (cols + 1) * CELL_PAD
-    grid_h = cell_h * rows + (rows + 1) * CELL_PAD
-    mon_w = R - L
-    mon_h = B - T
-    origin_x = L + SIDE_MARGIN + max(0, (mon_w - grid_w - 2 * SIDE_MARGIN) // 2)
-    origin_y = (
-        T + TOP_MARGIN + max(0, (mon_h - grid_h - TOP_MARGIN - BOTTOM_MARGIN) // 2)
-    )
-
-    print(f"Grid: {cols}x{rows}, Cell: {cell_w}x{cell_h}")
-    print(f"Monitor: ({L},{T}) to ({R},{B})")
-    print(f"Grid origin: ({origin_x},{origin_y})")
-    print("Expected arrangement (column-first):")
-    print("  Column 1: PlotA(0,0), PlotB(0,1), PlotC(0,2)")
-    print("  Column 2: PlotD(1,0), PlotE(1,1), PlotF(1,2)")
-    print()
-
-    # Test the column-first arrangement with corrected padding
-    arrangement_results = []
-    i = 0
-    for c in range(cols):  # Column-first: iterate columns first
-        for r in range(rows):  # Then rows within each column
-            if i >= len(windows):
-                break
-            kind, win, name = windows[i]
-
-            # Calculate position
-            x = origin_x + CELL_PAD + c * (cell_w + CELL_PAD)
-            y = origin_y + CELL_PAD + r * (cell_h + CELL_PAD)
-
-            # Apply corrected padding (Qt less, Tk/matplotlib more)
-            if kind == "qt":
-                w_pad, h_pad = (8, 15)  # Qt: minimal frames, precise sizing
-            else:  # "tk" (matplotlib/canvas)
-                w_pad, h_pad = (20, 50)  # Tk/matplotlib: toolbar + larger decorations
-
-            adj_w = max(50, cell_w - w_pad)
-            adj_h = max(50, cell_h - h_pad)
-
-            # Clamp to monitor bounds
-            final_x = max(L + SIDE_MARGIN, min(x, R - SIDE_MARGIN - adj_w))
-            final_y = max(T + TOP_MARGIN, min(y, B - BOTTOM_MARGIN - adj_h))
-
-            arrangement_results.append(
-                {
-                    "name": name,
-                    "kind": kind,
-                    "column": c,
-                    "row": r,
-                    "padding": (w_pad, h_pad),
-                    "size": (adj_w, adj_h),
-                    "position": (final_x, final_y),
-                }
-            )
-
-            # Apply geometry
-            if kind == "qt":
-                win.setGeometry(final_x, final_y, adj_w, adj_h)
-            else:
-                win.geometry(f"{adj_w}x{adj_h}+{final_x}+{final_y}")
-
-            i += 1
-
-    print("\n=== Arrangement Results ===")
-    for result in arrangement_results:
-        name = result["name"]
-        kind = result["kind"]
-        col = result["column"]
-        row = result["row"]
-        w_pad, h_pad = result["padding"]
-        adj_w, adj_h = result["size"]
-        final_x, final_y = result["position"]
-
-        print(f"{name} ({kind}): Column {col}, Row {row}")
-        print(
-            f"  Padding: {w_pad}x{h_pad} ({'minimal' if kind == 'qt' else 'toolbar+margins'})"
-        )
-        print(f"  Final size: {adj_w}x{adj_h}")
-        print(f"  Position: ({final_x},{final_y})")
-        print()
-
-    # Verify column-first arrangement
-    print("=== Verification ===")
-    expected_order = [
-        ("PlotA", 0, 0),
-        ("PlotB", 0, 1),
-        ("PlotC", 0, 2),  # Column 1
-        ("PlotD", 1, 0),
-        ("PlotE", 1, 1),
-        ("PlotF", 1, 2),  # Column 2
-    ]
-
-    success = True
-    for i, (expected_name, expected_col, expected_row) in enumerate(expected_order):
-        actual = arrangement_results[i]
-        if (
-            actual["name"] != expected_name
-            or actual["column"] != expected_col
-            or actual["row"] != expected_row
-        ):
-            print(
-                f"❌ Position {i}: Expected {expected_name} at ({expected_col},{expected_row}), "
-                f"got {actual['name']} at ({actual['column']},{actual['row']})"
-            )
-            success = False
-
-    if success:
-        print("✅ Column-first arrangement verified correctly!")
-
-    # Verify padding corrections
-    qt_windows = [r for r in arrangement_results if r["kind"] == "qt"]
-    tk_windows = [r for r in arrangement_results if r["kind"] == "tk"]
-
-    if qt_windows and tk_windows:
-        qt_pad = qt_windows[0]["padding"]
-        tk_pad = tk_windows[0]["padding"]
-
-        if qt_pad[0] < tk_pad[0] and qt_pad[1] < tk_pad[1]:
-            print(
-                "✅ Padding correction verified: Qt windows have less padding than Tk/matplotlib"
-            )
-            print(f"   Qt padding: {qt_pad[0]}x{qt_pad[1]}")
-            print(f"   Tk padding: {tk_pad[0]}x{tk_pad[1]}")
-        else:
-            print(f"❌ Padding incorrect: Qt {qt_pad} should be less than Tk {tk_pad}")
-            success = False
-
-    return success
-
-
-def test_grid_calculation():
-    """Test the grid calculation logic that prefers horizontal layouts."""
-
-    def best_grid(n):
-        """Find best grid dimensions preferring horizontal layouts for small n."""
-        if n <= 0:
-            return (0, 0)
-        if n == 1:
-            return (1, 1)
-        if n <= 3:
-            return (n, 1)  # Horizontal preference for small counts
-
-        best_ratio = float("inf")
-        best_cols, best_rows = 1, n
-
-        for cols in range(1, n + 1):
-            rows = (n + cols - 1) // cols
-            if cols * rows >= n:
-                ratio = max(cols / rows, rows / cols)
-                if ratio < best_ratio:
-                    best_ratio = ratio
-                    best_cols, best_rows = cols, rows
-
-        return (best_cols, best_rows)
-
-    print("\n=== Testing Grid Calculation ===")
-    test_cases = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 15, 16]
-
-    for n in test_cases:
-        cols, rows = best_grid(n)
-        ratio = max(cols / rows, rows / cols) if rows > 0 else float("inf")
-        print(f"Windows: {n:2d} → Grid: {cols}x{rows} (ratio: {ratio:.2f})")
-
-    return True
-
-
-if __name__ == "__main__":
-    print("Testing arrange_plot_windows fixes...\n")
-
-    result1 = test_arrangement_and_padding()
-    result2 = test_grid_calculation()
-
-    if result1 and result2:
-        print(
-            "\n🎉 All tests passed! The arrangement and padding fixes are working correctly."
-        )
-    else:
-        print("\n❌ Some tests failed. Check the implementation.")

nucleares_monitor/tests/test_high_priority_fixes.py

@@ -1,220 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test HIGH priority fixes from code review:
-1. Double cleanup prevention 
-2. Input validation for host/port
-3. Qt window cleanup registration
-"""
-
-import sys
-import os
-import unittest
-from unittest.mock import Mock, patch
-
-# Add current directory to path for import
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-class TestHighPriorityFixes(unittest.TestCase):
-    """Test the HIGH priority code review fixes."""
-    
-    def setUp(self):
-        """Set up test fixtures."""
-        # Mock pyqtgraph to avoid Qt dependencies in tests
-        self.mock_pyqtgraph = Mock()
-        self.mock_pyqtgraph.GraphicsLayoutWidget = Mock()
-        self.mock_pyqtgraph.mkPen = Mock()
-        self.mock_pyqtgraph.InfiniteLine = Mock()
-        self.mock_pyqtgraph.TextItem = Mock()
-        
-        with patch.dict('sys.modules', {'pyqtgraph': self.mock_pyqtgraph}):
-            from nucleares_monitor.control_board_monitor import App
-            self.App = App
-    
-    def test_double_cleanup_prevention(self):
-        """Test that on_close prevents double cleanup calls."""
-        with patch('tkinter.Tk'):
-            app = self.App()
-            
-            # Mock cleanup methods to track calls
-            app._cleanup_qt_windows = Mock()
-            app._cleanup_poller = Mock()
-            app._cleanup_scheduler = Mock()
-            app.destroy = Mock()
-            
-            # First call should work normally
-            app.on_close()
-            
-            # Verify cleanup methods were called
-            app._cleanup_qt_windows.assert_called_once()
-            app._cleanup_poller.assert_called_once()
-            app._cleanup_scheduler.assert_called_once()
-            app.destroy.assert_called_once()
-            
-            # Reset mocks
-            app._cleanup_qt_windows.reset_mock()
-            app._cleanup_poller.reset_mock()
-            app._cleanup_scheduler.reset_mock()
-            app.destroy.reset_mock()
-            
-            # Second call should be ignored (idempotent)
-            app.on_close()
-            
-            # Verify no methods were called again
-            app._cleanup_qt_windows.assert_not_called()
-            app._cleanup_poller.assert_not_called()
-            app._cleanup_scheduler.assert_not_called()
-            app.destroy.assert_not_called()
-    
-    def test_host_validation(self):
-        """Test safe host validation with fallbacks."""
-        with patch('tkinter.Tk'):
-            app = self.App()
-            
-            # Test valid host
-            app.host_var.set("example.com")
-            result = app._get_validated_host()
-            self.assertEqual(result, "example.com")
-            
-            # Test empty host
-            app.host_var.set("")
-            result = app._get_validated_host("fallback.com")
-            self.assertEqual(result, "fallback.com")
-            
-            # Test host with whitespace
-            app.host_var.set("  test.com  ")
-            result = app._get_validated_host()
-            self.assertEqual(result, "test.com")
-    
-    def test_port_validation(self):
-        """Test safe port validation with fallbacks."""
-        with patch('tkinter.Tk'):
-            app = self.App()
-            
-            # Test valid port
-            app.port_var.set("8080")
-            result = app._get_validated_port()
-            self.assertEqual(result, 8080)
-            
-            # Test invalid port (non-numeric)
-            app.port_var.set("abc")
-            result = app._get_validated_port(9000)
-            self.assertEqual(result, 9000)
-            
-            # Test port out of range
-            app.port_var.set("70000")
-            result = app._get_validated_port(8080)
-            self.assertEqual(result, 8080)
-            
-            # Test empty port
-            app.port_var.set("")
-            result = app._get_validated_port(3000)
-            self.assertEqual(result, 3000)
-            
-            # Test port caching
-            app.port_var.set("8080")
-            app._get_validated_port()  # This should cache 8080
-            app.port_var.set("invalid")
-            result = app._get_validated_port(9000)
-            self.assertEqual(result, 8080)  # Should return cached value
-    
-    def test_base_url_validation(self):
-        """Test safe base URL generation."""
-        with patch('tkinter.Tk'):
-            app = self.App()
-            
-            # Test normal case
-            app.host_var.set("localhost")
-            app.port_var.set("8080")
-            result = app._get_base_url_validated()
-            self.assertTrue(result.startswith("http://localhost:8080"))
-            
-            # Test with invalid port (should use fallback)
-            app.host_var.set("test.com")
-            app.port_var.set("invalid")
-            result = app._get_base_url_validated()
-            # Should not crash and return a valid URL
-            self.assertTrue(result.startswith("http://"))
-    
-    def test_qt_window_registration(self):
-        """Test that Qt windows are properly registered for cleanup."""
-        with patch('tkinter.Tk'), \
-             patch('nucleares_monitor.control_board_monitor._pyqtgraph_available', True), \
-             patch('nucleares_monitor.control_board_monitor.pg') as mock_pg, \
-             patch.object(self.App, '_qt_ensure_app'), \
-             patch.object(self.App, '_ensure_qt_pump'), \
-             patch.object(self.App, '_ensure_plot_timer'):
-            
-            # Mock PyQtGraph components
-            mock_widget = Mock()
-            mock_pg.GraphicsLayoutWidget.return_value = mock_widget
-            mock_widget.addPlot.return_value = Mock()
-            mock_widget.resize = Mock()
-            mock_widget.setWindowTitle = Mock()
-            mock_pg.mkPen.return_value = Mock()
-            mock_pg.InfiniteLine.return_value = Mock()
-            mock_pg.TextItem.return_value = Mock()
-            
-            app = self.App()
-            app._qt_app = Mock()
-            
-            # Mock variable info
-            app.vars = {"test_var": Mock(display_name="Test Variable")}
-            
-            # Create a Qt window
-            app._open_pyqtgraph_window("test_var")
-            
-            # Verify window is registered in both tracking dictionaries
-            self.assertIn("test_var", app._plot_windows)
-            self.assertIn("test_var", app._qt_windows)
-            
-            # Verify _qt_windows contains proper tuple
-            win, timer = app._qt_windows["test_var"]
-            self.assertIsNotNone(win)
-            self.assertIsNone(timer)  # PyQtGraph windows don't have timers
-    
-    def test_qt_cleanup_with_no_timer(self):
-        """Test that Qt cleanup handles windows without timers."""
-        with patch('tkinter.Tk'):
-            app = self.App()
-            
-            # Create mock Qt window without timer
-            mock_win = Mock()
-            app._qt_windows = {"test": (mock_win, None)}
-            
-            # Run cleanup
-            app._cleanup_qt_windows()
-            
-            # Verify window close was called
-            mock_win.close.assert_called_once()
-            
-            # Verify tracking dict was cleared
-            self.assertEqual(len(app._qt_windows), 0)
-
-
-def run_tests():
-    """Run the test suite."""
-    print("Testing HIGH priority fixes...")
-    print("=" * 50)
-    
-    # Run tests
-    suite = unittest.TestLoader().loadTestsFromTestCase(TestHighPriorityFixes)
-    runner = unittest.TextTestRunner(verbosity=2)
-    result = runner.run(suite)
-    
-    # Summary
-    print("\n" + "=" * 50)
-    if result.wasSuccessful():
-        print("✅ All HIGH priority fixes working correctly!")
-        print(f"✅ Ran {result.testsRun} tests successfully")
-    else:
-        print("❌ Some tests failed:")
-        print(f"❌ {len(result.failures)} failures")
-        print(f"❌ {len(result.errors)} errors")
-        for test, traceback in result.failures + result.errors:
-            print(f"   - {test}: {traceback.splitlines()[-1]}")
-    
-    return result.wasSuccessful()
-
-
-if __name__ == "__main__":
-    run_tests()

nucleares_monitor/tests/test_scheduler_optimization.py

@@ -1,127 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to validate the LOW priority scheduler optimization for reducing redundant
-get_value_cb calls in ActionScheduler.run_task_once().
-
-The optimization caches get_stats_for() results within a single task execution to avoid:
-1. Redundant calls when the same source is used for multiple axes (x_src == y_src)
-2. Unnecessary calls for None sources  
-3. Multiple lock acquisitions and deque copying for the same data
-
-Performance improvement: Reduces scheduler overhead by 33-66% for common scenarios.
-"""
-
-import sys
-import time
-
-# Add the monitor directory to path
-sys.path.insert(0, 'nucleares_monitor')
-
-def test_scheduler_optimization():
-    """Test that the scheduler optimization reduces get_value_cb calls."""
-    from control_board_monitor import ActionScheduler
-    
-    print("Testing ActionScheduler call optimization...")
-    
-    class MockTask:
-        def __init__(self, x_src='var1', y_src='var1', z_src='var2', expr='x + y + z'):
-            self.x_src = x_src
-            self.y_src = y_src  
-            self.z_src = z_src
-            self.expr = expr
-            self.value = '0'
-            self.name = 'test'
-            self.x_mode = 'raw'
-            self.y_mode = 'raw'
-            self.z_mode = 'raw'
-
-    call_count = 0
-    call_log = []
-    
-    def mock_get_value_cb(src):
-        nonlocal call_count, call_log
-        call_count += 1
-        call_log.append(src)
-        # Simulate some work (lock acquisition, deque copying, etc.)
-        time.sleep(0.001)  # 1ms per call
-        return {'x': 10.0, 'x_avg': 8.0, 'dx': 1.0, 'dx_avg': 0.5}
-
-    def mock_get_base_url():
-        return 'http://localhost:8080'
-
-    scheduler = ActionScheduler(mock_get_base_url, mock_get_value_cb)
-    
-    test_cases = [
-        ("Same x and y source", MockTask('var1', 'var1', 'var2'), 2),
-        ("All same source", MockTask('var1', 'var1', 'var1'), 1), 
-        ("One None source", MockTask('var1', None, 'var2'), 2),
-        ("All different sources", MockTask('var1', 'var2', 'var3'), 3),
-        ("Two None sources", MockTask('var1', None, None), 1),
-    ]
-    
-    results = []
-    
-    for description, task, expected_calls in test_cases:
-        call_count = 0
-        call_log = []
-        
-        start_time = time.time()
-        try:
-            scheduler.run_task_once(task)
-        except Exception:
-            pass  # Expected due to HTTP/expression errors in test
-        end_time = time.time()
-        
-        execution_time = (end_time - start_time) * 1000  # Convert to ms
-        
-        results.append({
-            'description': description,
-            'expected_calls': expected_calls,
-            'actual_calls': call_count,
-            'call_log': call_log,
-            'execution_time_ms': execution_time,
-            'optimized': call_count == expected_calls
-        })
-        
-        print(f"\n{description}:")
-        print(f"  Sources: x={task.x_src}, y={task.y_src}, z={task.z_src}")
-        print(f"  Expected calls: {expected_calls}")
-        print(f"  Actual calls: {call_count}")
-        print(f"  Called for: {call_log}")
-        print(f"  Execution time: {execution_time:.1f}ms")
-        print("  ✅ Optimized" if call_count == expected_calls else "  ❌ Not optimized")
-    
-    # Summary
-    print(f"\n{'='*60}")
-    print("OPTIMIZATION RESULTS:")
-    print(f"{'='*60}")
-    
-    optimized_count = sum(1 for r in results if r['optimized'])
-    total_count = len(results)
-    
-    print(f"Tests passed: {optimized_count}/{total_count}")
-    
-    if optimized_count == total_count:
-        print("✅ ALL TESTS PASSED - Scheduler optimization working correctly!")
-        
-        # Calculate potential savings
-        unoptimized_calls = sum(3 for _ in results)  # Old version always called 3 times
-        optimized_calls = sum(r['actual_calls'] for r in results)
-        savings_percent = ((unoptimized_calls - optimized_calls) / unoptimized_calls) * 100
-        
-        print("\nPerformance improvement:")
-        print(f"  Old version: {unoptimized_calls} total calls")
-        print(f"  Optimized version: {optimized_calls} total calls")
-        print(f"  Savings: {savings_percent:.1f}% reduction in get_value_cb calls")
-        
-    else:
-        print("❌ Some tests failed - optimization needs review")
-        for r in results:
-            if not r['optimized']:
-                print(f"  Failed: {r['description']}")
-    
-    return optimized_count == total_count
-
-if __name__ == '__main__':
-    success = test_scheduler_optimization()
-    sys.exit(0 if success else 1)

nucleares_monitor/tests/test_validation_fixes.py

@@ -1,201 +0,0 @@
-#!/usr/bin/env python3
-"""
-Simple test for HIGH priority fixes - focused validation tests only.
-"""
-
-import os
-import unittest
-from unittest.mock import Mock
-
-# Test the validation functions in isolation
-class TestValidationFixes(unittest.TestCase):
-    """Test validation fixes in isolation."""
-    
-    def test_double_cleanup_prevention_logic(self):
-        """Test the idempotent logic without full App initialization."""
-        print("\n✅ Testing double cleanup prevention logic...")
-        
-        # Simulate the idempotent behavior
-        cleanup_called = []
-        
-        def mock_on_close(already_closing_flag=None):
-            if already_closing_flag is None:
-                already_closing_flag = [False]
-            if already_closing_flag[0]:
-                return  # Prevent double cleanup
-            already_closing_flag[0] = True
-            cleanup_called.append(True)
-        
-        # First call should work
-        mock_on_close()
-        self.assertEqual(len(cleanup_called), 1)
-        
-        # Second call should be ignored
-        mock_on_close()
-        self.assertEqual(len(cleanup_called), 1)  # Still just 1
-        
-        print("   ✅ Double cleanup prevention works correctly")
-    
-    def test_port_validation_logic(self):
-        """Test port validation logic without Tkinter dependencies."""
-        print("\n✅ Testing port validation logic...")
-
-        def validate_port(port_input, fallback=8080, cache=None):
-            if cache is None:
-                cache = {}
-            """Simplified version of port validation logic."""
-            try:
-                # Handle both string and int inputs
-                if isinstance(port_input, int):
-                    port = port_input
-                else:
-                    port_str = str(port_input).strip()
-                    if not port_str:
-                        return fallback
-                    port = int(port_str)
-                
-                if not (1 <= port <= 65535):
-                    return cache.get('port', fallback)
-                
-                cache['port'] = port
-                return port
-            except ValueError:
-                return cache.get('port', fallback)
-            except Exception:
-                return cache.get('port', fallback)
-        
-        # Test valid port
-        result = validate_port("8080")
-        self.assertEqual(result, 8080)
-        print("   ✅ Valid port string handled correctly")
-        
-        # Test integer input
-        result = validate_port(9000)
-        self.assertEqual(result, 9000)
-        print("   ✅ Integer input handled correctly")
-        
-        # Test invalid port
-        cache = {'port': 8080}  # Pre-cached value
-        result = validate_port("abc", fallback=3000, cache=cache)
-        self.assertEqual(result, 8080)  # Should return cached value
-        print("   ✅ Invalid port returns cached value")
-        
-        # Test empty port
-        result = validate_port("", fallback=5000)
-        self.assertEqual(result, 5000)
-        print("   ✅ Empty port returns fallback")
-        
-        # Test out of range
-        result = validate_port("70000", fallback=8080)
-        self.assertEqual(result, 8080)
-        print("   ✅ Out of range port returns fallback")
-    
-    def test_host_validation_logic(self):
-        """Test host validation logic."""
-        print("\n✅ Testing host validation logic...")
-        
-        def validate_host(host_input, fallback="localhost", cache=None):
-            """Simplified version of host validation logic."""
-            if cache is None:
-                cache = {}
-            try:
-                host = str(host_input).strip()
-                if not host:
-                    return fallback
-                cache['host'] = host
-                return host
-            except Exception:
-                return cache.get('host', fallback)
-        
-        # Test valid host
-        result = validate_host("example.com")
-        self.assertEqual(result, "example.com")
-        print("   ✅ Valid host handled correctly")
-        
-        # Test empty host
-        result = validate_host("", fallback="test.com")
-        self.assertEqual(result, "test.com")
-        print("   ✅ Empty host returns fallback")
-        
-        # Test host with whitespace
-        result = validate_host("  test.com  ")
-        self.assertEqual(result, "test.com")
-        print("   ✅ Host whitespace trimmed correctly")
-    
-    def test_qt_window_cleanup_logic(self):
-        """Test Qt window cleanup logic.""" 
-        print("\n✅ Testing Qt window cleanup logic...")
-        
-        def cleanup_qt_windows(qt_windows):
-            """Simplified Qt cleanup logic."""
-            for _, tup in list(qt_windows.items()):
-                try:
-                    if isinstance(tup, tuple) and len(tup) >= 2:
-                        win, timer = tup[:2]
-                        if timer:
-                            timer.stop()  # Would call stop() if timer exists
-                        if win:
-                            win.close()  # Would call close() if window exists
-                except Exception:
-                    pass  # Error isolation
-            qt_windows.clear()
-        
-        # Test with window and timer
-        mock_win = Mock()
-        mock_timer = Mock()
-        qt_windows = {"test1": (mock_win, mock_timer)}
-        
-        cleanup_qt_windows(qt_windows)
-        
-        mock_timer.stop.assert_called_once()
-        mock_win.close.assert_called_once()
-        self.assertEqual(len(qt_windows), 0)
-        print("   ✅ Qt window with timer cleaned up correctly")
-        
-        # Test with window but no timer (PyQtGraph case)
-        mock_win2 = Mock()
-        qt_windows = {"test2": (mock_win2, None)}
-        
-        cleanup_qt_windows(qt_windows)
-        
-        mock_win2.close.assert_called_once()
-        self.assertEqual(len(qt_windows), 0)
-        print("   ✅ Qt window without timer cleaned up correctly")
-
-
-def run_validation_tests():
-    """Run the isolated validation tests."""
-    print("Testing HIGH priority fixes - Validation Logic")
-    print("=" * 60)
-    
-    # Run tests
-    suite = unittest.TestLoader().loadTestsFromTestCase(TestValidationFixes)
-    runner = unittest.TextTestRunner(verbosity=0, stream=open(os.devnull, 'w'))
-    result = runner.run(suite)
-    
-    # Summary
-    print("\n" + "=" * 60)
-    if result.wasSuccessful():
-        print("✅ All HIGH priority validation fixes working correctly!")
-        print(f"✅ Ran {result.testsRun} validation tests successfully")
-        print("\n🎯 KEY FIXES VERIFIED:")
-        print("   1. ✅ Double cleanup prevention (idempotent on_close)")
-        print("   2. ✅ Safe port validation with fallbacks and caching")
-        print("   3. ✅ Safe host validation with fallbacks")
-        print("   4. ✅ Qt window cleanup with optional timers")
-        print("\n📝 IMPLEMENTATION STATUS:")
-        print("   • Removed atexit registration to prevent double cleanup")
-        print("   • Added _already_closing flag for idempotent behavior")
-        print("   • Centralized input validation with caching")
-        print("   • Qt windows registered in both _plot_windows and _qt_windows")
-        print("   • Cleanup methods handle missing timers gracefully")
-    else:
-        print("❌ Some validation tests failed:")
-        print(f"❌ {len(result.failures)} failures")
-        print(f"❌ {len(result.errors)} errors")
-    
-    return result.wasSuccessful()
-
-
-if __name__ == "__main__":
-    run_validation_tests()

nucleares_monitor/tests/test_verification.py

@@ -1,236 +0,0 @@
-#!/usr/bin/env python3
-"""
-Direct test of HIGH priority fixes - verification script.
-"""
-
-def test_double_cleanup_logic():
-    """Test double cleanup prevention logic."""
-    print("🔍 Testing Double Cleanup Prevention...")
-    
-    cleanup_calls = []
-    already_closing = [False]
-    
-    def on_close():
-        # Implementation matches the actual code
-        if already_closing[0]:
-            return  # Idempotent - prevent double cleanup
-        already_closing[0] = True
-        cleanup_calls.append("cleanup")
-    
-    # First call should work
-    on_close()
-    assert len(cleanup_calls) == 1, f"Expected 1 cleanup call, got {len(cleanup_calls)}"
-    
-    # Second call should be ignored
-    on_close()
-    assert len(cleanup_calls) == 1, f"Expected 1 cleanup call after double call, got {len(cleanup_calls)}"
-    
-    print("   ✅ Double cleanup prevention working correctly")
-    return True
-
-def test_port_validation_logic():
-    """Test port validation with various inputs."""
-    print("🔍 Testing Port Validation...")
-    
-    cache = {}
-    
-    def validate_port(port_input, fallback=8080):
-        try:
-            # Handle both string and int inputs (for testing)
-            if isinstance(port_input, int):
-                port = port_input
-            else:
-                port_str = str(port_input).strip()
-                if not port_str:
-                    return fallback
-                port = int(port_str)
-            
-            if not (1 <= port <= 65535):
-                return cache.get('port', fallback)
-            
-            # Cache valid port
-            cache['port'] = port
-            return port
-        except ValueError:
-            return cache.get('port', fallback)
-        except Exception:
-            return cache.get('port', fallback)
-    
-    # Test valid inputs first
-    result = validate_port("8080")
-    assert result == 8080, f"Valid string port: Expected 8080, got {result}"
-    print(f"   ✅ Valid string port: 8080 -> {result}")
-    
-    result = validate_port(9000)
-    assert result == 9000, f"Valid integer port: Expected 9000, got {result}"
-    print(f"   ✅ Valid integer port: 9000 -> {result}")
-    
-    # Test empty string
-    result = validate_port("", fallback=3000)
-    assert result == 3000, f"Empty string: Expected 3000, got {result}"
-    print(f"   ✅ Empty string with fallback: '' -> {result}")
-    
-    # Set up cache with known value for invalid tests
-    validate_port("8080")  # This caches 8080
-    
-    # Test invalid string (should return cached value)
-    result = validate_port("abc")
-    expected = cache.get('port', 8080)  # Should get cached value
-    assert result == expected, f"Invalid string: Expected {expected}, got {result}"
-    print(f"   ✅ Invalid string (cached): 'abc' -> {result}")
-    
-    # Test out of range (should return cached value)
-    result = validate_port("70000")
-    expected = cache.get('port', 8080)  # Should get cached value
-    assert result == expected, f"Out of range: Expected {expected}, got {result}"
-    print(f"   ✅ Out of range port (cached): '70000' -> {result}")
-    
-    # Test string with whitespace
-    result = validate_port("  8080  ")
-    assert result == 8080, f"Whitespace string: Expected 8080, got {result}"
-    print(f"   ✅ String with whitespace: '  8080  ' -> {result}")
-    
-    return True
-
-def test_qt_cleanup_logic():
-    """Test Qt window cleanup logic."""
-    print("🔍 Testing Qt Window Cleanup...")
-    
-    class MockWindow:
-        def __init__(self):
-            self.closed = False
-        def close(self):
-            self.closed = True
-    
-    class MockTimer:
-        def __init__(self):
-            self.stopped = False
-        def stop(self):
-            self.stopped = True
-    
-    def cleanup_qt_windows(qt_windows):
-        """Simplified Qt cleanup matching actual implementation."""
-        for _, tup in list(qt_windows.items()):
-            try:
-                if isinstance(tup, tuple) and len(tup) >= 2:
-                    win, timer = tup[:2]
-                    if timer:
-                        timer.stop()
-                    if win:
-                        win.close()
-            except Exception:
-                pass  # Error isolation
-        qt_windows.clear()
-    
-    # Test with timer
-    win1 = MockWindow()
-    timer1 = MockTimer()
-    qt_windows = {"test1": (win1, timer1)}
-    
-    cleanup_qt_windows(qt_windows)
-    
-    assert win1.closed, "Window should be closed"
-    assert timer1.stopped, "Timer should be stopped"
-    assert len(qt_windows) == 0, "Dict should be cleared"
-    print("   ✅ Qt window with timer cleaned up correctly")
-    
-    # Test without timer (PyQtGraph case)
-    win2 = MockWindow()
-    qt_windows = {"test2": (win2, None)}
-    
-    cleanup_qt_windows(qt_windows)
-    
-    assert win2.closed, "Window should be closed"
-    assert len(qt_windows) == 0, "Dict should be cleared"
-    print("   ✅ Qt window without timer cleaned up correctly")
-    
-    return True
-
-def test_host_validation_logic():
-    """Test host validation logic."""
-    print("🔍 Testing Host Validation...")
-    
-    cache = {}
-    
-    def validate_host(host_input, fallback="localhost"):
-        try:
-            host = str(host_input).strip()
-            if not host:
-                return fallback
-            cache['host'] = host
-            return host
-        except Exception:
-            return cache.get('host', fallback)
-    
-    # Test cases
-    tests = [
-        ("example.com", "example.com", "Valid host"),
-        ("", "fallback.com", "Empty host"),
-        ("  test.com  ", "test.com", "Host with whitespace"),
-        ("localhost", "localhost", "Localhost"),
-    ]
-    
-    for input_val, expected, description in tests:
-        if input_val == "":
-            result = validate_host(input_val, fallback="fallback.com")
-        else:
-            result = validate_host(input_val)
-        assert result == expected, f"{description}: Expected {expected}, got {result}"
-        print(f"   ✅ {description}: '{input_val}' -> '{result}'")
-    
-    return True
-
-def main():
-    """Run all HIGH priority fix tests."""
-    print("🧪 HIGH PRIORITY FIXES VERIFICATION")
-    print("=" * 50)
-    
-    all_passed = True
-    
-    try:
-        test_double_cleanup_logic()
-    except Exception as e:
-        print(f"   ❌ Double cleanup test failed: {e}")
-        all_passed = False
-    
-    try:
-        test_port_validation_logic()
-    except Exception as e:
-        print(f"   ❌ Port validation test failed: {e}")
-        all_passed = False
-    
-    try:
-        test_host_validation_logic()
-    except Exception as e:
-        print(f"   ❌ Host validation test failed: {e}")
-        all_passed = False
-    
-    try:
-        test_qt_cleanup_logic()
-    except Exception as e:
-        print(f"   ❌ Qt cleanup test failed: {e}")
-        all_passed = False
-    
-    print("\n" + "=" * 50)
-    if all_passed:
-        print("🎉 ALL HIGH PRIORITY FIXES VERIFIED SUCCESSFULLY!")
-        print("\n📋 SUMMARY OF FIXES IMPLEMENTED:")
-        print("   1. ✅ Fixed double cleanup registration")
-        print("      • Removed atexit.register to avoid conflict with WM_DELETE_WINDOW")
-        print("      • Added _already_closing flag for idempotent on_close")
-        print("   2. ✅ Centralized input validation for host/port")
-        print("      • Added _get_validated_host() with fallback handling")
-        print("      • Added _get_validated_port() with range checking and caching")
-        print("      • Replaced all unsafe int(self.port_var.get()) calls")
-        print("   3. ✅ Completed Qt window cleanup registration")
-        print("      • PyQtGraph windows now registered in both _plot_windows and _qt_windows")
-        print("      • Cleanup handles optional timers (None for PyQtGraph)")
-        print("      • Added close event handlers for user-initiated window closes")
-        print("\n🚀 Ready for MEDIUM priority fixes!")
-    else:
-        print("❌ Some tests failed - check implementation!")
-    
-    return all_passed
-
-if __name__ == "__main__":
-    main()

nucleares_monitor/version.nfo

@@ -1 +0,0 @@
-1.17

requirements.txt

@@ -1,23 +1,7 @@
-cffi==2.0.0
-contourpy==1.3.3
-cycler==0.12.1
-fonttools==4.60.1
-kiwisolver==1.4.9
-matplotlib==3.10.7
+# Zależności vtt_work — wyłącznie dla help_scripts/sound.py (generator dźwięków).
+# Pozostałe skrypty Foundry używają czystego stdlib.
 numpy==2.3.3
-packaging==25.0
-pillow==12.0.0
-pycparser==2.23
-pyparsing==3.2.5
-PyQt5==5.15.11
-PyQt5-Qt5==5.15.2
-PyQt5_sip==12.17.1
-pyqtgraph==0.13.7
-PySide6==6.10.0
-PySide6_Addons==6.10.0
-PySide6_Essentials==6.10.0
-python-dateutil==2.9.0.post0
 scipy==1.16.2
-shiboken6==6.10.0
-six==1.17.0
 soundfile==0.13.1
+cffi==2.0.0
+pycparser==2.23

version.nfo

@@ -1 +1 @@
-0.3
+0.4