Lag das Programm unter C:\Program Files (Installer-Wahl "fuer alle Benutzer"), scheiterte das Kopieren beim Update still und die alte Fassung startete neu. Neu: - update_helfer.py ersetzt die Batchdatei. Wartet per Prozess-ID auf das Programmende, prueft den Ordner per Schreibprobe und kopiert bei Bedarf in einem zweiten Prozess mit Adminrechten. Fehler werden gemeldet und protokolliert, mit Link zum Installer. - Das Programm kuendigt die Windows-Abfrage vor dem Download an. - Der Helfer aus dem neuen Paket hat Vorrang. - Installer ohne die Wahl "fuer alle Benutzer"; eine alte Installation fuer alle Benutzer wird vorher entfernt. - version.json fuehrt die Installer-Adresse. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
1543 lines
59 KiB
Python
1543 lines
59 KiB
Python
"""
|
|
Squad Manager
|
|
Werkzeug fuer Squad. Kernfunktion: haelt die Sprechtaste automatisch
|
|
gedrueckt, solange gesprochen wird.
|
|
|
|
Greift nicht in Squad ein: kein Hook, keine DLL, kein Speicherzugriff.
|
|
Liest nur den Mikrofonpegel und ruft Windows SendInput / GetAsyncKeyState auf.
|
|
"""
|
|
|
|
import ctypes
|
|
import ctypes.wintypes as wintypes
|
|
import json
|
|
import os
|
|
import queue
|
|
import sys
|
|
import threading
|
|
import time
|
|
from pathlib import Path
|
|
|
|
|
|
def _ensure_tcl_paths():
|
|
"""
|
|
Muss vor dem tkinter-Import laufen.
|
|
|
|
Eine virtuelle Umgebung erbt unter Windows die Tcl/Tk-Pfade der
|
|
Basisinstallation nicht. tkinter findet dann init.tcl nicht und
|
|
bricht mit einem TclError ab. Hier werden die Pfade nachgezogen,
|
|
damit das Programm auch per Doppelklick oder Verknuepfung startet.
|
|
"""
|
|
if getattr(sys, "frozen", False):
|
|
return # gepackte EXE bringt Tcl/Tk selbst mit
|
|
tcl_root = Path(getattr(sys, "base_prefix", sys.prefix)) / "tcl"
|
|
if not tcl_root.is_dir():
|
|
return
|
|
for var, prefix, marker in (("TCL_LIBRARY", "tcl8", "init.tcl"),
|
|
("TK_LIBRARY", "tk8", "tk.tcl")):
|
|
if os.environ.get(var):
|
|
continue
|
|
for folder in sorted(tcl_root.glob(prefix + "*")):
|
|
if (folder / marker).is_file():
|
|
os.environ[var] = str(folder)
|
|
break
|
|
|
|
|
|
_ensure_tcl_paths()
|
|
|
|
import tkinter as tk # noqa: E402
|
|
from tkinter import ttk, messagebox # noqa: E402
|
|
|
|
import numpy as np # noqa: E402
|
|
import sounddevice as sd # noqa: E402
|
|
|
|
from theme import ( # noqa: E402
|
|
BG, PANEL, PANEL_HI, LINE, FG, FG_DIM, OLIVE, OLIVE_HI, AMBER,
|
|
AMBER_HELL, AMBER_DUNKEL, RED, GREEN_TX,
|
|
FONT_UI, FONT_BOLD, FONT_TITLE, FONT_MONO, FONT_STATUS,
|
|
apply_tactical_theme, LevelMeter,
|
|
)
|
|
import akte # noqa: E402
|
|
import update_helfer # noqa: E402
|
|
|
|
APP_NAME = "Squad Manager"
|
|
VERSION = "4.0"
|
|
CONFIG_PATH = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "config.json"
|
|
LOG_PATH = CONFIG_PATH.parent / "error.log"
|
|
# Bis Version 3.2 hiess das Programm "Squad Voice Activation"
|
|
ALT_CONFIG_PATH = Path(os.getenv("APPDATA", ".")) / "SquadVoiceActivation" / "config.json"
|
|
|
|
|
|
def alte_einstellungen_uebernehmen():
|
|
"""
|
|
Uebernimmt die Einstellungen aus der Zeit vor der Umbenennung.
|
|
|
|
Kopiert statt verschiebt: Eine noch vorhandene alte Installation soll
|
|
ihre Einstellungen behalten.
|
|
"""
|
|
if CONFIG_PATH.exists() or not ALT_CONFIG_PATH.exists():
|
|
return False
|
|
try:
|
|
import shutil
|
|
CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
|
|
shutil.copy2(ALT_CONFIG_PATH, CONFIG_PATH)
|
|
return True
|
|
except Exception:
|
|
return False
|
|
|
|
|
|
UPDATE_URL = "https://sva.tyrveil.com/version.json"
|
|
|
|
|
|
def version_tupel(text):
|
|
"""'3.10' wird zu (3, 10), damit 3.10 groesser ist als 3.9."""
|
|
teile = []
|
|
for stueck in str(text).strip().split("."):
|
|
ziffern = "".join(z for z in stueck if z.isdigit())
|
|
teile.append(int(ziffern) if ziffern else 0)
|
|
return tuple(teile)
|
|
|
|
|
|
def pruefe_update(timeout=6):
|
|
"""
|
|
Fragt die Versionsdatei auf dem Server ab.
|
|
|
|
Gibt die Angaben zurueck, wenn dort eine neuere Fassung steht, sonst
|
|
None. Netzwerkfehler sind kein Grund fuer eine Meldung - ohne
|
|
Internetverbindung laeuft das Programm ganz normal weiter.
|
|
"""
|
|
import json as _json
|
|
import urllib.request
|
|
|
|
if not UPDATE_URL.lower().startswith("https://"):
|
|
return None
|
|
try:
|
|
anfrage = urllib.request.Request(
|
|
UPDATE_URL, headers={"User-Agent": f"{APP_NAME}/{VERSION}"})
|
|
with urllib.request.urlopen(anfrage, timeout=timeout) as antwort:
|
|
angaben = _json.loads(antwort.read(65536).decode("utf-8"))
|
|
except Exception:
|
|
return None
|
|
|
|
ziel = str(angaben.get("version", "")).strip()
|
|
datei = str(angaben.get("datei", "")).strip()
|
|
if not ziel or not datei.lower().startswith("https://"):
|
|
return None
|
|
if version_tupel(ziel) <= version_tupel(VERSION):
|
|
return None
|
|
installer = str(angaben.get("installer", "")).strip()
|
|
return {
|
|
"version": ziel,
|
|
"datei": datei,
|
|
"sha256": str(angaben.get("sha256", "")).strip().lower(),
|
|
"hinweis": str(angaben.get("hinweis", "")).strip()[:200],
|
|
"installer": installer if installer.lower().startswith("https://") else "",
|
|
}
|
|
|
|
|
|
def lade_update(angaben, ziel_pfad, fortschritt=None):
|
|
"""Laedt das Paket und prueft die Pruefsumme."""
|
|
import hashlib
|
|
import urllib.request
|
|
|
|
anfrage = urllib.request.Request(
|
|
angaben["datei"], headers={"User-Agent": f"{APP_NAME}/{VERSION}"})
|
|
hasher = hashlib.sha256()
|
|
geladen = 0
|
|
with urllib.request.urlopen(anfrage, timeout=30) as antwort:
|
|
gesamt = int(antwort.headers.get("Content-Length") or 0)
|
|
with open(ziel_pfad, "wb") as datei:
|
|
while True:
|
|
brocken = antwort.read(65536)
|
|
if not brocken:
|
|
break
|
|
datei.write(brocken)
|
|
hasher.update(brocken)
|
|
geladen += len(brocken)
|
|
if fortschritt and gesamt:
|
|
fortschritt(geladen, gesamt)
|
|
|
|
erwartet = angaben.get("sha256", "")
|
|
if erwartet and hasher.hexdigest() != erwartet:
|
|
raise ValueError(
|
|
"Die heruntergeladene Datei stimmt nicht mit der angegebenen "
|
|
"Pruefsumme ueberein und wurde verworfen.")
|
|
return ziel_pfad
|
|
|
|
|
|
def spiele_update_ein(zip_pfad, programm_ordner, installer_url=""):
|
|
"""
|
|
Entpackt das Paket und startet den Update-Helfer.
|
|
|
|
Das laufende Programm ersetzt seine Dateien nicht selbst. Das erledigt
|
|
update_helfer.py als eigener Prozess, sobald das Programm beendet ist,
|
|
und startet es danach neu. Bevorzugt wird der Helfer aus dem *neuen*
|
|
Paket: Eine Verbesserung am Helfer wirkt so schon bei dem Update, das
|
|
sie ausliefert. Seine Aufrufparameter sind deshalb eine Schnittstelle
|
|
und muessen zwischen den Versionen gleich bleiben.
|
|
"""
|
|
import shutil
|
|
import subprocess
|
|
import tempfile
|
|
import zipfile
|
|
|
|
arbeit = Path(tempfile.mkdtemp(prefix="sm_update_"))
|
|
with zipfile.ZipFile(zip_pfad) as archiv:
|
|
archiv.extractall(arbeit)
|
|
|
|
quelle = arbeit / "Programm"
|
|
if not quelle.is_dir():
|
|
treffer = list(arbeit.rglob("squad_manager.py"))
|
|
if not treffer:
|
|
raise ValueError("Im Paket wurde kein Programmordner gefunden.")
|
|
quelle = treffer[0].parent
|
|
|
|
kandidaten = (quelle / "update_helfer.py",
|
|
Path(__file__).resolve().parent / "update_helfer.py")
|
|
helfer = next((p for p in kandidaten if p.is_file()), None)
|
|
if helfer is None:
|
|
raise ValueError("Der Update-Helfer fehlt.")
|
|
# Ausserhalb von quelle, damit er beim Kopieren nicht mitten im Lauf liegt
|
|
ausfuehren = arbeit / "update_helfer.py"
|
|
shutil.copy2(helfer, ausfuehren)
|
|
|
|
subprocess.Popen([sys.executable, str(ausfuehren), str(quelle),
|
|
str(programm_ordner), str(os.getpid()), installer_url],
|
|
creationflags=0x08000000) # kein Konsolenfenster
|
|
return True
|
|
|
|
|
|
def log_exception(exc_type, exc, tb):
|
|
"""Schreibt einen Fehler ins Log. Ohne Konsolenfenster geht er sonst verloren."""
|
|
import traceback
|
|
text = "".join(traceback.format_exception(exc_type, exc, tb))
|
|
try:
|
|
LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
|
|
with open(LOG_PATH, "a", encoding="utf-8") as fh:
|
|
fh.write(f"\n--- {time.strftime('%Y-%m-%d %H:%M:%S')} ---\n{text}")
|
|
except Exception:
|
|
pass
|
|
return text
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Win32
|
|
# ---------------------------------------------------------------------------
|
|
user32 = ctypes.WinDLL("user32", use_last_error=True)
|
|
kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
|
|
|
|
PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
|
|
# Der laufende Prozess heisst SquadGame-Win64-Shipping.exe, der Launcher
|
|
# SquadGame.exe. Verglichen wird per Praefix, damit beide passen - und
|
|
# damit dieses Programm selbst nicht versehentlich als Squad zaehlt.
|
|
SQUAD_PROCESS_DEFAULT = "SquadGame"
|
|
|
|
INPUT_MOUSE = 0
|
|
INPUT_KEYBOARD = 1
|
|
KEYEVENTF_KEYUP = 0x0002
|
|
|
|
MOUSEEVENTF_MIDDLEDOWN = 0x0020
|
|
MOUSEEVENTF_MIDDLEUP = 0x0040
|
|
MOUSEEVENTF_XDOWN = 0x0080
|
|
MOUSEEVENTF_XUP = 0x0100
|
|
|
|
CURSOR_SHOWING = 0x0001
|
|
|
|
# ULONG_PTR ist zeigergross: 64 Bit auf 64-Bit-Windows
|
|
ULONG_PTR = wintypes.WPARAM
|
|
|
|
|
|
class KEYBDINPUT(ctypes.Structure):
|
|
_fields_ = [
|
|
("wVk", wintypes.WORD),
|
|
("wScan", wintypes.WORD),
|
|
("dwFlags", wintypes.DWORD),
|
|
("time", wintypes.DWORD),
|
|
("dwExtraInfo", ULONG_PTR),
|
|
]
|
|
|
|
|
|
class MOUSEINPUT(ctypes.Structure):
|
|
_fields_ = [
|
|
("dx", wintypes.LONG),
|
|
("dy", wintypes.LONG),
|
|
("mouseData", wintypes.DWORD),
|
|
("dwFlags", wintypes.DWORD),
|
|
("time", wintypes.DWORD),
|
|
("dwExtraInfo", ULONG_PTR),
|
|
]
|
|
|
|
|
|
class HARDWAREINPUT(ctypes.Structure):
|
|
_fields_ = [
|
|
("uMsg", wintypes.DWORD),
|
|
("wParamL", wintypes.WORD),
|
|
("wParamH", wintypes.WORD),
|
|
]
|
|
|
|
|
|
class _INPUTUNION(ctypes.Union):
|
|
_fields_ = [("ki", KEYBDINPUT), ("mi", MOUSEINPUT), ("hi", HARDWAREINPUT)]
|
|
|
|
|
|
class INPUT(ctypes.Structure):
|
|
_anonymous_ = ("u",)
|
|
_fields_ = [("type", wintypes.DWORD), ("u", _INPUTUNION)]
|
|
|
|
|
|
class POINT(ctypes.Structure):
|
|
_fields_ = [("x", wintypes.LONG), ("y", wintypes.LONG)]
|
|
|
|
|
|
class CURSORINFO(ctypes.Structure):
|
|
_fields_ = [
|
|
("cbSize", wintypes.DWORD),
|
|
("flags", wintypes.DWORD),
|
|
("hCursor", wintypes.HANDLE),
|
|
("ptScreenPos", POINT),
|
|
]
|
|
|
|
|
|
user32.SendInput.argtypes = (wintypes.UINT, ctypes.POINTER(INPUT), ctypes.c_int)
|
|
user32.SendInput.restype = wintypes.UINT
|
|
user32.GetAsyncKeyState.argtypes = (ctypes.c_int,)
|
|
user32.GetAsyncKeyState.restype = ctypes.c_short
|
|
user32.GetCursorInfo.argtypes = (ctypes.POINTER(CURSORINFO),)
|
|
user32.GetCursorInfo.restype = wintypes.BOOL
|
|
user32.GetWindowThreadProcessId.argtypes = (wintypes.HWND, ctypes.POINTER(wintypes.DWORD))
|
|
user32.GetWindowThreadProcessId.restype = wintypes.DWORD
|
|
|
|
kernel32.OpenProcess.argtypes = (wintypes.DWORD, wintypes.BOOL, wintypes.DWORD)
|
|
kernel32.OpenProcess.restype = wintypes.HANDLE
|
|
kernel32.QueryFullProcessImageNameW.argtypes = (
|
|
wintypes.HANDLE, wintypes.DWORD, wintypes.LPWSTR, ctypes.POINTER(wintypes.DWORD))
|
|
kernel32.QueryFullProcessImageNameW.restype = wintypes.BOOL
|
|
kernel32.CloseHandle.argtypes = (wintypes.HANDLE,)
|
|
kernel32.CloseHandle.restype = wintypes.BOOL
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tastentabelle: Anzeigename -> (art, code)
|
|
# art "key" -> code ist ein Virtual-Key-Code
|
|
# art "mouse" -> code ist die XBUTTON-Nummer (3 = mittlere Maustaste)
|
|
# ---------------------------------------------------------------------------
|
|
VK_MBUTTON, VK_XBUTTON1, VK_XBUTTON2 = 0x04, 0x05, 0x06
|
|
|
|
KEYS = {}
|
|
for _c in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
|
|
KEYS[_c] = ("key", ord(_c))
|
|
for _n in range(10):
|
|
KEYS[str(_n)] = ("key", 0x30 + _n)
|
|
for _i in range(1, 13):
|
|
KEYS[f"F{_i}"] = ("key", 0x6F + _i)
|
|
KEYS.update({
|
|
"Maus mitte": ("mouse", 3),
|
|
"Maus 4": ("mouse", 1),
|
|
"Maus 5": ("mouse", 2),
|
|
"Pause": ("key", 0x13),
|
|
"Rollen": ("key", 0x91),
|
|
"Einfg": ("key", 0x2D),
|
|
"Entf": ("key", 0x2E),
|
|
"Pos1": ("key", 0x24),
|
|
"Ende": ("key", 0x23),
|
|
"Bild auf": ("key", 0x21),
|
|
"Bild ab": ("key", 0x22),
|
|
})
|
|
|
|
KEY_NAMES = list(KEYS.keys())
|
|
NONE_LABEL = "(keine)"
|
|
NO_MOD_LABEL = "(kein)"
|
|
|
|
# Zusatztasten fuer Kombinationen wie Strg+V (Squad "Direct Voice" o. ae.)
|
|
MODIFIERS = {
|
|
NO_MOD_LABEL: None,
|
|
"Strg": 0x11, # VK_CONTROL
|
|
"Alt": 0x12, # VK_MENU
|
|
"Shift": 0x10, # VK_SHIFT
|
|
}
|
|
MOD_NAMES = list(MODIFIERS.keys())
|
|
|
|
|
|
def _async_vk(name):
|
|
"""Virtual-Key-Code, mit dem GetAsyncKeyState diese Taste abgefragt wird."""
|
|
kind, code = KEYS[name]
|
|
if kind == "key":
|
|
return code
|
|
return {1: VK_XBUTTON1, 2: VK_XBUTTON2, 3: VK_MBUTTON}[code]
|
|
|
|
|
|
def is_physically_down(name):
|
|
"""True, wenn die Taste gerade gedrueckt ist (egal ob echt oder simuliert)."""
|
|
if name not in KEYS:
|
|
return False
|
|
return bool(user32.GetAsyncKeyState(_async_vk(name)) & 0x8000)
|
|
|
|
|
|
def is_binding_down(mod, name):
|
|
"""True, wenn Taste und ggf. zugehoerige Zusatztaste gleichzeitig gehalten werden."""
|
|
if name not in KEYS:
|
|
return False
|
|
mod_vk = MODIFIERS.get(mod)
|
|
if mod_vk is not None and not (user32.GetAsyncKeyState(mod_vk) & 0x8000):
|
|
return False
|
|
return is_physically_down(name)
|
|
|
|
|
|
def _send(kind, **fields):
|
|
if kind == "key":
|
|
inp = INPUT(type=INPUT_KEYBOARD, ki=KEYBDINPUT(**fields))
|
|
else:
|
|
inp = INPUT(type=INPUT_MOUSE, mi=MOUSEINPUT(**fields))
|
|
sent = user32.SendInput(1, ctypes.byref(inp), ctypes.sizeof(INPUT))
|
|
if sent != 1:
|
|
err = ctypes.get_last_error()
|
|
raise OSError(err, f"SendInput fehlgeschlagen (sent={sent}, error={err})")
|
|
|
|
|
|
def send_input_key(name, down):
|
|
"""Drueckt bzw. loesst die benannte Taste."""
|
|
kind, code = KEYS[name]
|
|
if kind == "key":
|
|
_send("key", wVk=code, wScan=0,
|
|
dwFlags=0 if down else KEYEVENTF_KEYUP, time=0, dwExtraInfo=0)
|
|
elif code == 3:
|
|
_send("mouse", dx=0, dy=0, mouseData=0,
|
|
dwFlags=MOUSEEVENTF_MIDDLEDOWN if down else MOUSEEVENTF_MIDDLEUP,
|
|
time=0, dwExtraInfo=0)
|
|
else:
|
|
_send("mouse", dx=0, dy=0, mouseData=code,
|
|
dwFlags=MOUSEEVENTF_XDOWN if down else MOUSEEVENTF_XUP,
|
|
time=0, dwExtraInfo=0)
|
|
|
|
|
|
def send_modifier(mod, down):
|
|
vk = MODIFIERS.get(mod)
|
|
if vk is None:
|
|
return
|
|
_send("key", wVk=vk, wScan=0,
|
|
dwFlags=0 if down else KEYEVENTF_KEYUP, time=0, dwExtraInfo=0)
|
|
|
|
|
|
def send_binding(mod, name, down):
|
|
"""Drueckt bzw. loesst eine Kombination. Zusatztaste zuerst rein, zuletzt raus."""
|
|
if down:
|
|
send_modifier(mod, True)
|
|
send_input_key(name, True)
|
|
else:
|
|
send_input_key(name, False)
|
|
send_modifier(mod, False)
|
|
|
|
|
|
def get_foreground_process_name():
|
|
"""Dateiname des Prozesses, dem das aktive Fenster gehoert (z. B. SquadGame.exe)."""
|
|
hwnd = user32.GetForegroundWindow()
|
|
if not hwnd:
|
|
return ""
|
|
pid = wintypes.DWORD()
|
|
user32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid))
|
|
if not pid.value:
|
|
return ""
|
|
handle = kernel32.OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, False, pid.value)
|
|
if not handle:
|
|
return ""
|
|
try:
|
|
size = wintypes.DWORD(1024)
|
|
buf = ctypes.create_unicode_buffer(size.value)
|
|
if kernel32.QueryFullProcessImageNameW(handle, 0, buf, ctypes.byref(size)):
|
|
return os.path.basename(buf.value)
|
|
return ""
|
|
finally:
|
|
kernel32.CloseHandle(handle)
|
|
|
|
|
|
def set_dark_titlebar(root):
|
|
"""
|
|
Faerbt die Fenstertitelleiste dunkel.
|
|
|
|
Windows zeichnet die Titelleiste sonst hell, was ueber der dunklen
|
|
Oberflaeche wie ein weisser Balken wirkt. Das Attribut heisst auf
|
|
aktuellen Windows-Versionen 20, auf aelteren 19.
|
|
"""
|
|
try:
|
|
root.update_idletasks()
|
|
hwnd = user32.GetParent(root.winfo_id()) or root.winfo_id()
|
|
dwm = ctypes.WinDLL("dwmapi")
|
|
an = ctypes.c_int(1)
|
|
for attribut in (20, 19):
|
|
if dwm.DwmSetWindowAttribute(
|
|
wintypes.HWND(hwnd), ctypes.c_uint(attribut),
|
|
ctypes.byref(an), ctypes.sizeof(an)) == 0:
|
|
# Neu zeichnen erzwingen, sonst bleibt die alte Farbe stehen
|
|
root.withdraw()
|
|
root.deiconify()
|
|
return True
|
|
except Exception:
|
|
pass
|
|
return False
|
|
|
|
|
|
def set_window_icon(root):
|
|
"""
|
|
Setzt das Programmsymbol fuer Fenster und Taskleiste.
|
|
|
|
Verwendet icon.ico neben dem Programm. Fehlt sie, bleibt das
|
|
Standardsymbol - ein fehlendes Symbol ist kein Grund abzubrechen.
|
|
"""
|
|
ordner = Path(__file__).resolve().parent
|
|
ico = ordner / "icon.ico"
|
|
if ico.exists():
|
|
try:
|
|
root.iconbitmap(default=str(ico))
|
|
return True
|
|
except Exception:
|
|
pass
|
|
png = ordner / "icon.png"
|
|
if png.exists():
|
|
try:
|
|
bild = tk.PhotoImage(file=str(png))
|
|
root.iconphoto(True, bild)
|
|
root._icon_ref = bild # Verweis halten, sonst weggeraeumt
|
|
return True
|
|
except Exception:
|
|
pass
|
|
return False
|
|
|
|
|
|
def clean_device_name(name):
|
|
"""
|
|
Macht Windows-Geraetenamen lesbar.
|
|
|
|
Manche Treiber liefern einen unaufgeloesten Ressourcenverweis wie
|
|
"@System32\\drivers\\bthhfenum.sys,#4;%1 Hands-Free HF Audio%0 ;(iPhone)".
|
|
Daraus wird "Hands-Free HF Audio (iPhone)".
|
|
"""
|
|
name = name.replace("\r", " ").replace("\n", " ")
|
|
if name.lstrip().startswith("@") or ".sys," in name or ".dll," in name:
|
|
pieces = []
|
|
for piece in name.split(";")[1:]:
|
|
piece = piece.strip()
|
|
if piece.startswith("%1"):
|
|
piece = piece[2:].strip()
|
|
if piece.endswith("%0"):
|
|
piece = piece[:-2].strip()
|
|
piece = piece.strip(" ()")
|
|
if piece:
|
|
pieces.append(piece)
|
|
if pieces:
|
|
name = f"{pieces[0]} ({', '.join(pieces[1:])})" if len(pieces) > 1 else pieces[0]
|
|
return " ".join(name.split())
|
|
|
|
|
|
API_RANG = {"WASAPI": 0, "DirectSound": 1, "MME": 2, "WDM-KS": 3}
|
|
|
|
# Platzhalter fuer "Windows-Standardgeraet" - kein echtes Mikrofon
|
|
ALIAS_GERAETE = ("microsoft soundmapper", "primärer soundaufnahmetreiber",
|
|
"primarer soundaufnahmetreiber", "primary sound capture")
|
|
|
|
|
|
def _vergleichsname(name):
|
|
return "".join(z for z in name.lower() if z.isalnum())
|
|
|
|
|
|
def gleiches_geraet(a, b):
|
|
"""
|
|
Zwei Eintraege gehoeren zum selben Mikrofon.
|
|
|
|
Die MME-Schnittstelle kuerzt Geraetenamen auf 31 Zeichen, deshalb wird
|
|
geprueft, ob der kuerzere Name Anfang des laengeren ist.
|
|
"""
|
|
x, y = _vergleichsname(a), _vergleichsname(b)
|
|
if x == y:
|
|
return True
|
|
kurz, lang = (x, y) if len(x) <= len(y) else (y, x)
|
|
return len(kurz) >= 8 and lang.startswith(kurz)
|
|
|
|
|
|
def zusammenfassen(geraete):
|
|
"""Pro Mikrofon nur den Eintrag mit der besten Schnittstelle behalten."""
|
|
gruppen = []
|
|
for geraet in sorted(geraete, key=lambda g: len(_vergleichsname(g["name"]))):
|
|
for gruppe in gruppen:
|
|
if gleiches_geraet(gruppe[0]["name"], geraet["name"]):
|
|
gruppe.append(geraet)
|
|
break
|
|
else:
|
|
gruppen.append([geraet])
|
|
return [min(g, key=lambda d: API_RANG.get(d["api"], 9)) for g in gruppen]
|
|
|
|
|
|
def enumerate_inputs(rescan=False, alle=False):
|
|
"""
|
|
Alle Eingabegeraete mit Host-API und nativer Abtastrate.
|
|
|
|
Die Geraeteindizes von PortAudio sind nicht stabil - sie verschieben
|
|
sich, sobald ein Treiber dazukommt oder verschwindet. Deshalb wird
|
|
ueberall mit dem Label gearbeitet und der Index erst unmittelbar vor
|
|
dem Oeffnen aufgeloest.
|
|
"""
|
|
if rescan:
|
|
try:
|
|
sd._terminate()
|
|
sd._initialize()
|
|
except Exception:
|
|
pass
|
|
apis = sd.query_hostapis()
|
|
result = []
|
|
for index, dev in enumerate(sd.query_devices()):
|
|
if dev["max_input_channels"] < 1:
|
|
continue
|
|
api = apis[dev["hostapi"]]["name"].replace("Windows ", "")
|
|
name = clean_device_name(dev["name"])
|
|
result.append({
|
|
"index": index,
|
|
"name": name,
|
|
"api": api,
|
|
"samplerate": int(dev["default_samplerate"]),
|
|
"label": f"[{api}] {name}",
|
|
})
|
|
|
|
if alle:
|
|
return result
|
|
|
|
gefiltert = [d for d in result
|
|
if not any(a in d["name"].lower() for a in ALIAS_GERAETE)]
|
|
|
|
# WDM-KS ist der Kernel-Zugang. Dort taucht zusaetzlich zu jedem echten
|
|
# Mikrofon ein Eintrag unter abweichendem Treibernamen auf, dazu Geraete,
|
|
# die in Windows gar nicht aktiv sind. Sobald WASAPI etwas liefert, ist
|
|
# das die massgebliche Liste - sie entspricht den Windows-Soundeinstellungen.
|
|
ohne_kernel = [d for d in gefiltert if d["api"] != "WDM-KS"]
|
|
if any(d["api"] == "WASAPI" for d in ohne_kernel):
|
|
gefiltert = ohne_kernel
|
|
|
|
return zusammenfassen(gefiltert or result)
|
|
|
|
|
|
def pick_samplerate(index, preferred):
|
|
"""Erste Abtastrate, die das Geraet tatsaechlich akzeptiert."""
|
|
seen = []
|
|
for rate in (preferred, 48000, 44100, 16000):
|
|
if rate in seen:
|
|
continue
|
|
seen.append(rate)
|
|
try:
|
|
sd.check_input_settings(device=index, channels=1,
|
|
samplerate=rate, dtype="float32")
|
|
return rate
|
|
except Exception:
|
|
continue
|
|
return None
|
|
|
|
|
|
def audio_service_running():
|
|
"""
|
|
Laeuft der Windows-Audiodienst? Stuerzt er ab, scheitert jede Aufnahme.
|
|
Nur lesender Zugriff auf den Dienststatus.
|
|
"""
|
|
SC_MANAGER_CONNECT, SERVICE_QUERY_STATUS, SERVICE_RUNNING = 0x0001, 0x0004, 0x0004
|
|
advapi = ctypes.WinDLL("advapi32", use_last_error=True)
|
|
|
|
class SERVICE_STATUS(ctypes.Structure):
|
|
_fields_ = [("dwServiceType", wintypes.DWORD),
|
|
("dwCurrentState", wintypes.DWORD),
|
|
("dwControlsAccepted", wintypes.DWORD),
|
|
("dwWin32ExitCode", wintypes.DWORD),
|
|
("dwServiceSpecificExitCode", wintypes.DWORD),
|
|
("dwCheckPoint", wintypes.DWORD),
|
|
("dwWaitHint", wintypes.DWORD)]
|
|
|
|
manager = advapi.OpenSCManagerW(None, None, SC_MANAGER_CONNECT)
|
|
if not manager:
|
|
return True # Status nicht ermittelbar - nicht faelschlich warnen
|
|
try:
|
|
service = advapi.OpenServiceW(manager, "Audiosrv", SERVICE_QUERY_STATUS)
|
|
if not service:
|
|
return True
|
|
try:
|
|
status = SERVICE_STATUS()
|
|
if not advapi.QueryServiceStatus(service, ctypes.byref(status)):
|
|
return True
|
|
return status.dwCurrentState == SERVICE_RUNNING
|
|
finally:
|
|
advapi.CloseServiceHandle(service)
|
|
finally:
|
|
advapi.CloseServiceHandle(manager)
|
|
|
|
|
|
def beep(enabled):
|
|
"""Kurze Rueckmeldung zum Hotkey - im Vollbild ist das Fenster nicht sichtbar."""
|
|
def run():
|
|
try:
|
|
import winsound
|
|
winsound.Beep(880 if enabled else 440, 90)
|
|
except Exception:
|
|
pass
|
|
threading.Thread(target=run, daemon=True).start()
|
|
|
|
|
|
def cursor_is_visible():
|
|
"""
|
|
True, wenn Windows gerade einen Mauszeiger zeichnet.
|
|
|
|
Squad blendet den Zeiger im Spiel aus und im Deploy-/Menuebildschirm ein.
|
|
Damit laesst sich der Respawn-Screen erkennen, ohne das Spiel anzufassen.
|
|
"""
|
|
info = CURSORINFO()
|
|
info.cbSize = ctypes.sizeof(CURSORINFO)
|
|
if not user32.GetCursorInfo(ctypes.byref(info)):
|
|
return True
|
|
return bool(info.flags & CURSOR_SHOWING)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Anwendung
|
|
# ---------------------------------------------------------------------------
|
|
class VoiceActivationApp:
|
|
POLL_SECONDS = 0.02
|
|
|
|
def __init__(self, root):
|
|
self.root = root
|
|
self.root.title(f"{APP_NAME} {VERSION}")
|
|
self.root.geometry("900x830")
|
|
self.root.minsize(780, 520)
|
|
set_window_icon(self.root)
|
|
set_dark_titlebar(self.root)
|
|
|
|
self.audio_queue = queue.Queue(maxsize=10)
|
|
self.running = False
|
|
self.stream = None
|
|
self.ptt_down = False
|
|
self.active_binding = None
|
|
self.last_voice_time = 0.0
|
|
self.current_level = 0.0
|
|
self.hold_reason = ""
|
|
self.hotkey_was_down = False
|
|
|
|
self.device_var = tk.StringVar()
|
|
self.threshold_var = tk.DoubleVar(value=0.025)
|
|
self.release_ms_var = tk.IntVar(value=450)
|
|
self.ptt_key_var = tk.StringVar(value="V")
|
|
self.ptt_mod_var = tk.StringVar(value=NO_MOD_LABEL)
|
|
self.radio1_var = tk.StringVar(value="B")
|
|
self.radio1_mod_var = tk.StringVar(value=NO_MOD_LABEL)
|
|
self.radio2_var = tk.StringVar(value="G")
|
|
self.radio2_mod_var = tk.StringVar(value=NO_MOD_LABEL)
|
|
self.radio3_var = tk.StringVar(value=NONE_LABEL)
|
|
self.radio3_mod_var = tk.StringVar(value=NO_MOD_LABEL)
|
|
self.hotkey_var = tk.StringVar(value="Pause")
|
|
self.squad_process_var = tk.StringVar(value=SQUAD_PROCESS_DEFAULT)
|
|
self.squad_only_var = tk.BooleanVar(value=True)
|
|
self.pause_on_cursor_var = tk.BooleanVar(value=False)
|
|
self.beep_var = tk.BooleanVar(value=True)
|
|
self.alle_geraete_var = tk.BooleanVar(value=False)
|
|
self.enabled_var = tk.BooleanVar(value=True)
|
|
self.status_var = tk.StringVar(value="Gestoppt")
|
|
self.detail_var = tk.StringVar(value="")
|
|
self.device_info_var = tk.StringVar(value="")
|
|
self.diag_var = tk.StringVar(value="")
|
|
self.inputs = []
|
|
self.worker = None
|
|
self.update_angaben = None
|
|
|
|
self.build_ui()
|
|
self.refresh_devices()
|
|
self.load_config()
|
|
self.arm_autosave()
|
|
self.root.protocol("WM_DELETE_WINDOW", self.on_close)
|
|
self.root.report_callback_exception = self.on_tk_error
|
|
self.root.after(80, self.ui_tick)
|
|
self.root.after(1500, self.suche_update)
|
|
|
|
def on_tk_error(self, exc_type, exc, tb):
|
|
"""Fehler aus Tk-Callbacks sichtbar machen statt still verschlucken."""
|
|
log_exception(exc_type, exc, tb)
|
|
try:
|
|
messagebox.showerror(
|
|
APP_NAME,
|
|
f"Unerwarteter Fehler:\n\n{exc_type.__name__}: {exc}\n\n"
|
|
f"Einzelheiten stehen in:\n{LOG_PATH}")
|
|
except Exception:
|
|
pass
|
|
|
|
# -- UI -----------------------------------------------------------------
|
|
def build_ui(self):
|
|
header = ttk.Frame(self.root)
|
|
header.pack(fill="x", padx=18, pady=(16, 4))
|
|
ttk.Label(header, text="SQUAD MANAGER",
|
|
style="Title.TLabel").pack(anchor="w")
|
|
ttk.Label(header, style="Sub.TLabel",
|
|
text="Sprachaktivierung und Personalakte fuer Squad.").pack(anchor="w")
|
|
ttk.Separator(self.root, orient="horizontal").pack(
|
|
fill="x", padx=18, pady=(10, 0))
|
|
|
|
# Die Leiste mit Starten/Stoppen wird VOR dem Notebook gepackt und am
|
|
# unteren Rand verankert. Sonst frisst das Notebook (expand=True) den
|
|
# Platz und die Knoepfe fallen aus dem Fenster.
|
|
self._build_statusbar()
|
|
self._build_update_banner()
|
|
|
|
# Hauptreiter je Modul. Die Statusleiste bleibt darunter fuer alle
|
|
# Module sichtbar - die Sprachaktivierung laeuft weiter, waehrend man
|
|
# zum Beispiel an einer Akte schreibt.
|
|
haupt = ttk.Notebook(self.root, style="Haupt.TNotebook")
|
|
self.haupt_nb = haupt
|
|
haupt.pack(fill="both", expand=True, padx=16, pady=(4, 8))
|
|
seite_funk = ttk.Frame(haupt)
|
|
seite_akte = ttk.Frame(haupt)
|
|
haupt.add(seite_funk, text="FUNK")
|
|
haupt.add(seite_akte, text="AKTE")
|
|
|
|
nb = ttk.Notebook(seite_funk)
|
|
self.nb = nb
|
|
nb.pack(fill="both", expand=True, pady=(6, 0))
|
|
tab_main = ttk.Frame(nb)
|
|
tab_keys = ttk.Frame(nb)
|
|
nb.add(tab_main, text=" Mikrofon ")
|
|
nb.add(tab_keys, text=" Tasten und Verhalten ")
|
|
|
|
self._build_main_tab(tab_main)
|
|
self._build_keys_tab(tab_keys)
|
|
|
|
self.akte = akte.AkteSeite(seite_akte)
|
|
self.akte.pack(fill="both", expand=True)
|
|
|
|
def _build_main_tab(self, parent):
|
|
f = ttk.Frame(parent)
|
|
f.pack(fill="both", expand=True, padx=12, pady=12)
|
|
f.columnconfigure(1, weight=1)
|
|
|
|
ttk.Label(f, text="Mikrofon").grid(row=0, column=0, sticky="w", pady=8)
|
|
self.device_combo = ttk.Combobox(f, textvariable=self.device_var,
|
|
state="readonly", width=44)
|
|
self.device_combo.grid(row=0, column=1, sticky="ew", padx=8, pady=8)
|
|
ttk.Button(f, text="Neu laden",
|
|
command=lambda: self.refresh_devices(rescan=True)).grid(
|
|
row=0, column=2, pady=8)
|
|
|
|
ttk.Checkbutton(
|
|
f, variable=self.alle_geraete_var,
|
|
text="Jede Windows-Schnittstelle einzeln auflisten",
|
|
command=lambda: self.refresh_devices(rescan=False),
|
|
).grid(row=1, column=1, sticky="w", padx=8, pady=(0, 6))
|
|
|
|
ttk.Label(f, text="Schwelle").grid(row=2, column=0, sticky="w", pady=8)
|
|
ttk.Scale(f, from_=0.002, to=0.100, variable=self.threshold_var,
|
|
orient="horizontal").grid(row=2, column=1, sticky="ew", padx=8, pady=8)
|
|
self.threshold_label = ttk.Label(f, text="0.025", width=8)
|
|
self.threshold_label.grid(row=2, column=2, sticky="w", pady=8)
|
|
|
|
ttk.Label(f, text="Pegel").grid(row=3, column=0, sticky="w", pady=8)
|
|
self.level_bar = LevelMeter(f)
|
|
self.level_bar.grid(row=3, column=1, sticky="ew", padx=8, pady=8)
|
|
self.level_label = ttk.Label(f, text="0.000", width=8, style="Mono.TLabel")
|
|
self.level_label.grid(row=3, column=2, sticky="w", pady=8)
|
|
|
|
ttk.Label(f, text="Nachlaufzeit").grid(row=4, column=0, sticky="w", pady=8)
|
|
row3 = ttk.Frame(f)
|
|
row3.grid(row=4, column=1, sticky="w", padx=8, pady=8)
|
|
ttk.Spinbox(row3, from_=100, to=2000, increment=50,
|
|
textvariable=self.release_ms_var, width=8).pack(side="left")
|
|
ttk.Label(row3, text="ms nach dem letzten Wort").pack(side="left", padx=8)
|
|
|
|
diag = ttk.LabelFrame(f, text="Warum sendet es (nicht)?")
|
|
diag.grid(row=5, column=0, columnspan=3, sticky="ew", pady=(16, 8))
|
|
ttk.Label(diag, textvariable=self.diag_var, justify="left",
|
|
font=("Consolas", 9)).pack(anchor="w", padx=10, pady=8)
|
|
ttk.Label(diag, textvariable=self.device_info_var,
|
|
foreground="#666").pack(anchor="w", padx=10, pady=(0, 8))
|
|
|
|
box = ttk.LabelFrame(f, text="Eingabetest")
|
|
box.grid(row=6, column=0, columnspan=3, sticky="ew", pady=(8, 8))
|
|
ttk.Button(box, text="PTT-Taste testen (1 Sekunde halten)",
|
|
command=self.test_ptt).pack(side="left", padx=10, pady=10)
|
|
self.test_result = ttk.Label(box, text="Vor dem Start von Squad ausprobieren.")
|
|
self.test_result.pack(side="left", padx=10, pady=10)
|
|
|
|
ttk.Label(f, justify="left", text=(
|
|
"Notepad oeffnen, hineinklicken, zurueck zu diesem Fenster wechseln\n"
|
|
"und den Test starten. Erscheint die Taste in Notepad, funktioniert\n"
|
|
"die Eingabesimulation. Laeuft Squad als Administrator, muss auch\n"
|
|
"dieses Programm als Administrator laufen.")
|
|
).grid(row=7, column=0, columnspan=3, sticky="w", pady=(4, 0))
|
|
|
|
def _build_keys_tab(self, parent):
|
|
f = ttk.Frame(parent)
|
|
f.pack(fill="both", expand=True, padx=12, pady=12)
|
|
f.columnconfigure(2, weight=1)
|
|
|
|
ttk.Label(f, text="Sprechtaste (wird automatisch gehalten)").grid(
|
|
row=0, column=0, sticky="w", pady=8)
|
|
ptt_row = ttk.Frame(f)
|
|
ptt_row.grid(row=0, column=1, columnspan=2, sticky="w", padx=8, pady=8)
|
|
ttk.Combobox(ptt_row, textvariable=self.ptt_mod_var, values=MOD_NAMES,
|
|
state="readonly", width=8).pack(side="left")
|
|
ttk.Label(ptt_row, text="+").pack(side="left", padx=6)
|
|
ttk.Combobox(ptt_row, textvariable=self.ptt_key_var, values=KEY_NAMES,
|
|
state="readonly", width=12).pack(side="left")
|
|
ttk.Label(ptt_row, text=" z. B. Local V oder Fireteam-Kanal",
|
|
foreground="#666").pack(side="left", padx=6)
|
|
|
|
box = ttk.LabelFrame(
|
|
f, text="Andere Sprechtasten - Automatik pausiert, solange eine gehalten wird")
|
|
box.grid(row=1, column=0, columnspan=3, sticky="ew", pady=(16, 8))
|
|
for i, (label, mod_var, key_var, hint) in enumerate([
|
|
("Squad Radio", self.radio1_mod_var, self.radio1_var, "meist B"),
|
|
("Command Radio", self.radio2_mod_var, self.radio2_var, "meist G"),
|
|
("Weitere Taste", self.radio3_mod_var, self.radio3_var, "optional"),
|
|
]):
|
|
ttk.Label(box, text=label).grid(row=i, column=0, sticky="w", padx=10, pady=6)
|
|
ttk.Combobox(box, textvariable=mod_var, values=MOD_NAMES,
|
|
state="readonly", width=8).grid(row=i, column=1, padx=(10, 2), pady=6)
|
|
ttk.Label(box, text="+").grid(row=i, column=2)
|
|
ttk.Combobox(box, textvariable=key_var, values=[NONE_LABEL] + KEY_NAMES,
|
|
state="readonly", width=12).grid(row=i, column=3, padx=(2, 10), pady=6)
|
|
ttk.Label(box, text=hint, foreground="#666").grid(row=i, column=4,
|
|
sticky="w", padx=6)
|
|
|
|
ttk.Label(f, justify="left", text=(
|
|
"Drueckst du selbst eine dieser Tasten, laesst das Programm die\n"
|
|
"Local-Taste sofort los und haelt sich raus, bis du sie wieder\n"
|
|
"loslaesst. Dein Funkspruch wird dadurch nicht mehr ueberschrieben.")
|
|
).grid(row=2, column=0, columnspan=3, sticky="w", pady=(0, 12))
|
|
|
|
box2 = ttk.LabelFrame(f, text="Verhalten")
|
|
box2.grid(row=3, column=0, columnspan=3, sticky="ew", pady=8)
|
|
|
|
ttk.Checkbutton(
|
|
box2, variable=self.squad_only_var,
|
|
text="Alles nur aktiv, solange dieses Programm im Vordergrund ist:",
|
|
).pack(anchor="w", padx=10, pady=(8, 2))
|
|
|
|
proc_row = ttk.Frame(box2)
|
|
proc_row.pack(anchor="w", padx=32, pady=(0, 4))
|
|
ttk.Entry(proc_row, textvariable=self.squad_process_var, width=22).pack(side="left")
|
|
self.proc_hint = ttk.Label(proc_row, foreground="#666", text="")
|
|
self.proc_hint.pack(side="left", padx=10)
|
|
|
|
ttk.Checkbutton(
|
|
box2, variable=self.pause_on_cursor_var,
|
|
text="Pausieren, solange ein Mauszeiger sichtbar ist (Deploy-Screen, Menue, Karte)",
|
|
).pack(anchor="w", padx=10, pady=4)
|
|
|
|
self.cursor_hint = ttk.Label(box2, foreground="#666", text="")
|
|
self.cursor_hint.pack(anchor="w", padx=32, pady=(0, 8))
|
|
|
|
row = ttk.Frame(box2)
|
|
row.pack(anchor="w", padx=10, pady=(4, 2))
|
|
ttk.Label(row, text="Stummschalt-Hotkey (nur im Spiel)").pack(side="left")
|
|
ttk.Combobox(row, textvariable=self.hotkey_var, values=[NONE_LABEL] + KEY_NAMES,
|
|
state="readonly", width=14).pack(side="left", padx=10)
|
|
|
|
ttk.Checkbutton(
|
|
box2, variable=self.beep_var,
|
|
text="Signalton beim Umschalten (hoch = aktiv, tief = stumm)",
|
|
).pack(anchor="w", padx=32, pady=(0, 10))
|
|
|
|
ttk.Label(f, text="Alle Aenderungen werden sofort gespeichert.",
|
|
style="Dim.TLabel").grid(row=4, column=0, columnspan=2,
|
|
sticky="w", pady=(16, 0))
|
|
self.save_hint = ttk.Label(f, style="Dim.TLabel", text="")
|
|
self.save_hint.grid(row=5, column=0, columnspan=3, sticky="w", pady=(2, 0))
|
|
|
|
def _build_update_banner(self):
|
|
"""Hinweisleiste auf eine neue Fassung. Bleibt verborgen, bis es eine gibt."""
|
|
self.update_banner = tk.Frame(self.root, bg=AMBER_DUNKEL,
|
|
highlightthickness=1,
|
|
highlightbackground=AMBER)
|
|
innen = tk.Frame(self.update_banner, bg=AMBER_DUNKEL)
|
|
innen.pack(fill="x", padx=14, pady=9)
|
|
|
|
self.update_text_var = tk.StringVar(value="")
|
|
tk.Label(innen, textvariable=self.update_text_var, bg=AMBER_DUNKEL,
|
|
fg=AMBER, font=FONT_BOLD, anchor="w",
|
|
justify="left").pack(side="left", fill="x", expand=True)
|
|
|
|
tk.Button(innen, text="Später", command=self.update_verbergen,
|
|
bg=AMBER_DUNKEL, fg=FG_DIM, activebackground=PANEL_HI,
|
|
activeforeground=FG, relief="flat", bd=0, padx=12, pady=4,
|
|
font=FONT_UI, cursor="hand2").pack(side="right", padx=(8, 0))
|
|
|
|
self.update_btn = tk.Button(
|
|
innen, text="Jetzt aktualisieren", command=self.update_starten,
|
|
bg=AMBER, fg="#1a1508", activebackground=AMBER_HELL,
|
|
activeforeground="#1a1508", relief="flat", bd=0, padx=16, pady=4,
|
|
font=FONT_BOLD, cursor="hand2")
|
|
self.update_btn.pack(side="right")
|
|
|
|
def _build_statusbar(self):
|
|
self.status_trenner = ttk.Separator(self.root, orient="horizontal")
|
|
self.status_trenner.pack(side="bottom", fill="x", padx=0, pady=(0, 0))
|
|
bar = ttk.Frame(self.root)
|
|
bar.pack(side="bottom", fill="x", padx=16, pady=12)
|
|
|
|
self.start_btn = ttk.Button(bar, text="STARTEN", style="Accent.TButton",
|
|
command=self.start)
|
|
self.start_btn.pack(side="left")
|
|
self.stop_btn = ttk.Button(bar, text="STOPPEN", command=self.stop,
|
|
state="disabled")
|
|
self.stop_btn.pack(side="left", padx=8)
|
|
|
|
right = ttk.Frame(bar)
|
|
right.pack(side="right")
|
|
ttk.Label(right, textvariable=self.detail_var,
|
|
style="Dim.TLabel").pack(side="left", padx=10)
|
|
self.status_label = ttk.Label(right, textvariable=self.status_var,
|
|
font=FONT_STATUS, foreground=FG_DIM)
|
|
self.status_label.pack(side="left")
|
|
|
|
# -- Konfiguration ------------------------------------------------------
|
|
def config_dict(self):
|
|
return {
|
|
"device": self.device_var.get(),
|
|
"threshold": round(float(self.threshold_var.get()), 4),
|
|
"release_ms": int(self.release_ms_var.get()),
|
|
"ptt_key": self.ptt_key_var.get(),
|
|
"ptt_mod": self.ptt_mod_var.get(),
|
|
"radio_keys": [self.radio1_var.get(), self.radio2_var.get(),
|
|
self.radio3_var.get()],
|
|
"radio_mods": [self.radio1_mod_var.get(), self.radio2_mod_var.get(),
|
|
self.radio3_mod_var.get()],
|
|
"hotkey": self.hotkey_var.get(),
|
|
"squad_process": self.squad_process_var.get(),
|
|
"squad_only": bool(self.squad_only_var.get()),
|
|
"pause_on_cursor": bool(self.pause_on_cursor_var.get()),
|
|
"beep": bool(self.beep_var.get()),
|
|
"modul": self.haupt_nb.index("current"),
|
|
}
|
|
|
|
def suche_update(self):
|
|
"""Fragt im Hintergrund nach einer neueren Fassung."""
|
|
def arbeit():
|
|
angaben = pruefe_update()
|
|
if angaben:
|
|
self.root.after(0, lambda: self.update_anbieten(angaben))
|
|
threading.Thread(target=arbeit, daemon=True).start()
|
|
|
|
def update_anbieten(self, angaben):
|
|
self.update_angaben = angaben
|
|
text = f"Version {angaben['version']} ist verfügbar."
|
|
if angaben.get("hinweis"):
|
|
text += f" {angaben['hinweis']}"
|
|
self.update_text_var.set(text)
|
|
self.update_banner.pack(side="bottom", fill="x", padx=0, pady=0,
|
|
before=self.status_trenner)
|
|
|
|
def update_verbergen(self):
|
|
self.update_banner.pack_forget()
|
|
|
|
def update_starten(self):
|
|
if not getattr(self, "update_angaben", None):
|
|
return
|
|
ordner = Path(__file__).resolve().parent
|
|
# Liegt das Programm unter C:\Program Files, darf es dort ohne
|
|
# Adminrechte nichts ersetzen. Bis 3.4 scheiterte das Update dann
|
|
# still und startete die alte Fassung neu.
|
|
if not update_helfer.beschreibbar(ordner) and not messagebox.askokcancel(
|
|
APP_NAME,
|
|
"Squad Manager liegt in einem geschuetzten Ordner:\n"
|
|
f"{ordner}\n\n"
|
|
"Zum Einspielen fragt Windows gleich nach Administratorrechten. "
|
|
"Das Programm selbst laeuft danach wieder mit normalen Rechten.\n\n"
|
|
"Dauerhaft beheben laesst sich das mit dem aktuellen Installer: "
|
|
"Er installiert in deinen Benutzerordner.",
|
|
icon="warning"):
|
|
return
|
|
self.update_btn.config(state="disabled", text="Lädt ...")
|
|
|
|
def arbeit():
|
|
import tempfile
|
|
try:
|
|
ziel = Path(tempfile.gettempdir()) / "SquadManager_Update.zip"
|
|
|
|
def melden(geladen, gesamt):
|
|
anteil = int(geladen * 100 / gesamt)
|
|
self.root.after(0, lambda: self.update_btn.config(
|
|
text=f"Lädt ... {anteil} %"))
|
|
|
|
lade_update(self.update_angaben, ziel, melden)
|
|
self.root.after(0, lambda: self.update_abschliessen(ziel, ordner))
|
|
except Exception as fehler:
|
|
log_exception(type(fehler), fehler, fehler.__traceback__)
|
|
self.root.after(0, lambda f=fehler: self.update_fehler(f))
|
|
|
|
threading.Thread(target=arbeit, daemon=True).start()
|
|
|
|
def update_fehler(self, fehler):
|
|
self.update_btn.config(state="normal", text="Jetzt aktualisieren")
|
|
messagebox.showerror(
|
|
APP_NAME,
|
|
f"Das Update konnte nicht geladen werden:\n\n{fehler}\n\n"
|
|
"Das Programm läuft unverändert weiter.")
|
|
|
|
def update_abschliessen(self, zip_pfad, ordner):
|
|
self.update_btn.config(text="Wird eingespielt ...")
|
|
try:
|
|
spiele_update_ein(zip_pfad, ordner,
|
|
self.update_angaben.get("installer", ""))
|
|
except Exception as fehler:
|
|
log_exception(type(fehler), fehler, fehler.__traceback__)
|
|
self.update_fehler(fehler)
|
|
return
|
|
try:
|
|
self.akte.speichern_sofort()
|
|
except Exception as e:
|
|
log_exception(type(e), e, e.__traceback__)
|
|
self.stop()
|
|
self.root.after(400, self.root.destroy)
|
|
|
|
def arm_autosave(self):
|
|
"""
|
|
Jede Aenderung wird gespeichert, nicht erst beim Schliessen.
|
|
|
|
Wird das Programm abgeschossen oder faellt der Rechner aus, waeren
|
|
sonst alle Einstellungen der Sitzung verloren. Geschrieben wird
|
|
verzoegert, damit das Ziehen am Schieberegler nicht hunderte
|
|
Schreibvorgaenge ausloest.
|
|
"""
|
|
for var in (self.device_var, self.threshold_var, self.release_ms_var,
|
|
self.ptt_key_var, self.ptt_mod_var,
|
|
self.radio1_var, self.radio1_mod_var,
|
|
self.radio2_var, self.radio2_mod_var,
|
|
self.radio3_var, self.radio3_mod_var,
|
|
self.hotkey_var, self.squad_process_var,
|
|
self.squad_only_var, self.pause_on_cursor_var,
|
|
self.beep_var):
|
|
var.trace_add("write", self._on_setting_changed)
|
|
self._autosave_job = None
|
|
self.haupt_nb.bind("<<NotebookTabChanged>>", self._on_setting_changed,
|
|
add="+")
|
|
|
|
def _on_setting_changed(self, *_):
|
|
if getattr(self, "_autosave_job", None) is not None:
|
|
try:
|
|
self.root.after_cancel(self._autosave_job)
|
|
except Exception:
|
|
pass
|
|
self._autosave_job = self.root.after(600, self._autosave_now)
|
|
|
|
def _autosave_now(self):
|
|
self._autosave_job = None
|
|
self.save_config(quiet=True)
|
|
|
|
def save_config(self, quiet=False):
|
|
try:
|
|
CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
|
|
CONFIG_PATH.write_text(json.dumps(self.config_dict(), indent=2),
|
|
encoding="utf-8")
|
|
self.save_hint.config(
|
|
text=f"Automatisch gespeichert {time.strftime('%H:%M:%S')}")
|
|
except Exception as e:
|
|
log_exception(type(e), e, e.__traceback__)
|
|
if not quiet:
|
|
messagebox.showerror(
|
|
APP_NAME, f"Einstellungen konnten nicht gespeichert werden:\n{e}")
|
|
else:
|
|
self.save_hint.config(text="Speichern fehlgeschlagen - siehe error.log")
|
|
|
|
def load_config(self):
|
|
alte_einstellungen_uebernehmen()
|
|
if not CONFIG_PATH.exists():
|
|
return
|
|
try:
|
|
cfg = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
|
|
except Exception:
|
|
return
|
|
|
|
# Toleranter Vergleich: Geraetenamen enthalten oft ueberzaehlige
|
|
# Leerzeichen, und die Namensbereinigung kann sie veraendert haben.
|
|
saved = " ".join((cfg.get("device") or "").split())
|
|
if saved:
|
|
match = next((label for label in self.device_combo["values"]
|
|
if " ".join(label.split()) == saved), None)
|
|
if match:
|
|
self.device_var.set(match)
|
|
|
|
try:
|
|
self.threshold_var.set(float(cfg.get("threshold", 0.025)))
|
|
self.release_ms_var.set(int(cfg.get("release_ms", 450)))
|
|
except Exception:
|
|
pass
|
|
self.squad_only_var.set(bool(cfg.get("squad_only", True)))
|
|
self.pause_on_cursor_var.set(bool(cfg.get("pause_on_cursor", False)))
|
|
self.beep_var.set(bool(cfg.get("beep", True)))
|
|
|
|
if cfg.get("ptt_key") in KEYS:
|
|
self.ptt_key_var.set(cfg["ptt_key"])
|
|
if cfg.get("ptt_mod") in MODIFIERS:
|
|
self.ptt_mod_var.set(cfg["ptt_mod"])
|
|
if cfg.get("hotkey") in KEYS or cfg.get("hotkey") == NONE_LABEL:
|
|
self.hotkey_var.set(cfg["hotkey"])
|
|
if cfg.get("squad_process"):
|
|
self.squad_process_var.set(cfg["squad_process"])
|
|
|
|
for var, value in zip((self.radio1_var, self.radio2_var, self.radio3_var),
|
|
cfg.get("radio_keys") or []):
|
|
if value in KEYS or value == NONE_LABEL:
|
|
var.set(value)
|
|
for var, value in zip((self.radio1_mod_var, self.radio2_mod_var,
|
|
self.radio3_mod_var), cfg.get("radio_mods") or []):
|
|
if value in MODIFIERS:
|
|
var.set(value)
|
|
|
|
modul = cfg.get("modul")
|
|
if isinstance(modul, int) and 0 <= modul < len(self.haupt_nb.tabs()):
|
|
self.haupt_nb.select(modul)
|
|
|
|
self.save_hint.config(text="Einstellungen geladen.")
|
|
|
|
# -- Audio --------------------------------------------------------------
|
|
def refresh_devices(self, rescan=False):
|
|
try:
|
|
self.inputs = enumerate_inputs(rescan=rescan,
|
|
alle=bool(self.alle_geraete_var.get()))
|
|
except Exception as e:
|
|
messagebox.showerror(APP_NAME, f"Mikrofone konnten nicht gelesen werden:\n{e}")
|
|
return
|
|
|
|
labels = [d["label"] for d in self.inputs]
|
|
self.device_combo["values"] = labels
|
|
|
|
if self.device_var.get() not in labels:
|
|
# WASAPI zuerst - moderner und stabiler als MME/DirectSound
|
|
preferred = next((d["label"] for d in self.inputs if d["api"] == "WASAPI"),
|
|
labels[0] if labels else "")
|
|
self.device_var.set(preferred)
|
|
|
|
def selected_device(self):
|
|
"""Loest das gewaehlte Label frisch auf, weil Indizes wandern koennen."""
|
|
label = self.device_var.get()
|
|
if not label:
|
|
return None
|
|
for device in enumerate_inputs():
|
|
if device["label"] == label:
|
|
return device
|
|
return None
|
|
|
|
def audio_callback(self, indata, frames, time_info, status):
|
|
rms = float(np.sqrt(np.mean(np.square(indata.astype(np.float32)))))
|
|
self.current_level = rms
|
|
try:
|
|
self.audio_queue.put_nowait(rms)
|
|
except queue.Full:
|
|
try:
|
|
self.audio_queue.get_nowait()
|
|
self.audio_queue.put_nowait(rms)
|
|
except Exception:
|
|
pass
|
|
|
|
# -- PTT ----------------------------------------------------------------
|
|
def test_ptt(self):
|
|
if self.ptt_down:
|
|
return
|
|
key = self.ptt_key_var.get()
|
|
mod = self.ptt_mod_var.get()
|
|
if key not in KEYS:
|
|
messagebox.showwarning(APP_NAME, "Bitte eine gueltige Taste waehlen.")
|
|
return
|
|
|
|
label = key if MODIFIERS.get(mod) is None else f"{mod}+{key}"
|
|
self.test_result.config(text=f"Teste {label} ...")
|
|
|
|
def do_test():
|
|
try:
|
|
send_binding(mod, key, True)
|
|
time.sleep(1.0)
|
|
send_binding(mod, key, False)
|
|
self.root.after(0, lambda: self.test_result.config(
|
|
text=f"{label} wurde erfolgreich gesendet."))
|
|
except Exception as e:
|
|
self.root.after(0, lambda: messagebox.showerror(
|
|
APP_NAME, f"Test fehlgeschlagen:\n{e}"))
|
|
self.root.after(0, lambda: self.test_result.config(
|
|
text="Test fehlgeschlagen."))
|
|
|
|
threading.Thread(target=do_test, daemon=True).start()
|
|
|
|
def press_ptt(self):
|
|
if self.ptt_down:
|
|
return
|
|
key = self.ptt_key_var.get()
|
|
if key not in KEYS:
|
|
return
|
|
# Kombination merken, damit ein spaeteres Umstellen im UI die
|
|
# gehaltene Taste nicht haengen laesst.
|
|
self.active_binding = (self.ptt_mod_var.get(), key)
|
|
send_binding(*self.active_binding, True)
|
|
self.ptt_down = True
|
|
|
|
def release_ptt(self):
|
|
if not self.ptt_down:
|
|
return
|
|
try:
|
|
if self.active_binding:
|
|
send_binding(*self.active_binding, False)
|
|
finally:
|
|
self.active_binding = None
|
|
self.ptt_down = False
|
|
|
|
# -- Sperrgruende -------------------------------------------------------
|
|
def radio_bindings(self):
|
|
pairs = ((self.radio1_mod_var, self.radio1_var),
|
|
(self.radio2_mod_var, self.radio2_var),
|
|
(self.radio3_mod_var, self.radio3_var))
|
|
return [(m.get(), k.get()) for m, k in pairs if k.get() in KEYS]
|
|
|
|
def squad_focused(self):
|
|
"""Ist das Spiel gerade das aktive Fenster?"""
|
|
if not self.squad_only_var.get():
|
|
return True
|
|
wanted = self.squad_process_var.get().strip().lower()
|
|
if not wanted:
|
|
return True
|
|
return get_foreground_process_name().lower().startswith(wanted)
|
|
|
|
def blocking_reason(self):
|
|
"""Grund, warum gerade nicht gesendet werden darf. Leerer String = frei."""
|
|
if not self.squad_focused():
|
|
return "Squad nicht im Vordergrund"
|
|
|
|
if not self.enabled_var.get():
|
|
return "Pausiert (Hotkey)"
|
|
|
|
for mod, key in self.radio_bindings():
|
|
if is_binding_down(mod, key):
|
|
label = key if MODIFIERS.get(mod) is None else f"{mod}+{key}"
|
|
return f"Funk aktiv ({label})"
|
|
|
|
# Haelt der Spieler die Local-Taste selbst, mischen wir uns nicht ein.
|
|
if not self.ptt_down and is_binding_down(self.ptt_mod_var.get(),
|
|
self.ptt_key_var.get()):
|
|
return "Manuell gedrueckt"
|
|
|
|
if self.pause_on_cursor_var.get() and cursor_is_visible():
|
|
return "Menue / Deploy-Screen"
|
|
|
|
return ""
|
|
|
|
def poll_hotkey(self):
|
|
"""
|
|
Flankenerkennung fuer den Stummschalt-Hotkey.
|
|
|
|
Wird nur ausgewertet, solange das Spiel im Vordergrund ist. Sonst
|
|
wuerde dieselbe Taste auch beim Schreiben im Browser oder in Discord
|
|
die Automatik umschalten.
|
|
"""
|
|
key = self.hotkey_var.get()
|
|
if key not in KEYS or not self.squad_focused():
|
|
self.hotkey_was_down = False
|
|
return
|
|
down = is_physically_down(key)
|
|
if down and not self.hotkey_was_down:
|
|
now_enabled = not self.enabled_var.get()
|
|
self.enabled_var.set(now_enabled)
|
|
if not now_enabled:
|
|
self.release_ptt()
|
|
if self.beep_var.get():
|
|
beep(now_enabled)
|
|
self.hotkey_was_down = down
|
|
|
|
# -- Steuerung ----------------------------------------------------------
|
|
def start(self):
|
|
if self.running:
|
|
return
|
|
|
|
if not audio_service_running():
|
|
messagebox.showerror(
|
|
APP_NAME,
|
|
"Der Windows-Audiodienst laeuft nicht.\n\n"
|
|
"Ohne ihn kann kein Programm aufnehmen. In einer\n"
|
|
"Eingabeaufforderung als Administrator starten:\n\n"
|
|
" net start Audiosrv")
|
|
return
|
|
|
|
device = self.selected_device()
|
|
if device is None:
|
|
messagebox.showwarning(
|
|
APP_NAME,
|
|
"Das gewaehlte Mikrofon ist nicht mehr vorhanden.\n"
|
|
"Bitte auf 'Neu laden' klicken und erneut waehlen.")
|
|
return
|
|
|
|
rate = pick_samplerate(device["index"], device["samplerate"])
|
|
if rate is None:
|
|
messagebox.showerror(
|
|
APP_NAME,
|
|
f"{device['name']} akzeptiert keine der ueblichen Abtastraten.\n"
|
|
"Bitte ein anderes Geraet waehlen - moeglichst eines mit [WASAPI].")
|
|
return
|
|
|
|
try:
|
|
self.audio_queue = queue.Queue(maxsize=10)
|
|
self.running = True
|
|
self.enabled_var.set(True)
|
|
self.last_voice_time = 0.0
|
|
|
|
self.stream = sd.InputStream(
|
|
device=device["index"], channels=1, samplerate=rate,
|
|
blocksize=max(64, rate // 50), # rund 20 ms
|
|
dtype="float32", callback=self.audio_callback,
|
|
)
|
|
self.stream.start()
|
|
self.worker = threading.Thread(target=self.worker_loop, daemon=True)
|
|
self.worker.start()
|
|
|
|
self.start_btn.config(state="disabled")
|
|
self.stop_btn.config(state="normal")
|
|
self.device_combo.config(state="disabled")
|
|
self.device_info_var.set(f"{device['api']} @ {rate} Hz")
|
|
except Exception as e:
|
|
self.running = False
|
|
self.stream = None
|
|
log_exception(type(e), e, e.__traceback__)
|
|
messagebox.showerror(
|
|
APP_NAME,
|
|
f"Mikrofon konnte nicht geoeffnet werden:\n\n{e}\n\n"
|
|
"Haeufige Ursachen:\n"
|
|
"- Windows-Audiodienst abgestuerzt (net start Audiosrv)\n"
|
|
"- Geraet von einem anderen Programm exklusiv belegt\n"
|
|
"- Virtueller Treiber (z. B. SteelSeries Sonar) haengt\n\n"
|
|
"Ein Geraet mit [WASAPI] ist meist am stabilsten.")
|
|
|
|
def stop(self):
|
|
self.running = False
|
|
|
|
# Erst den Worker auslaufen lassen, sonst greift er noch auf den
|
|
# Stream zu, waehrend dieser geschlossen wird - das kann PortAudio
|
|
# hart abstuerzen lassen.
|
|
worker, self.worker = self.worker, None
|
|
if worker is not None and worker.is_alive():
|
|
worker.join(timeout=1.0)
|
|
|
|
try:
|
|
self.release_ptt()
|
|
except Exception as e:
|
|
log_exception(type(e), e, e.__traceback__)
|
|
self.ptt_down = False
|
|
self.active_binding = None
|
|
|
|
stream, self.stream = self.stream, None
|
|
if stream is not None:
|
|
try:
|
|
stream.abort(ignore_errors=True)
|
|
except Exception:
|
|
pass
|
|
try:
|
|
stream.close(ignore_errors=True)
|
|
except Exception as e:
|
|
log_exception(type(e), e, e.__traceback__)
|
|
self.current_level = 0.0
|
|
self.hold_reason = ""
|
|
self.start_btn.config(state="normal")
|
|
self.stop_btn.config(state="disabled")
|
|
self.device_combo.config(state="readonly")
|
|
|
|
def worker_loop(self):
|
|
while self.running:
|
|
try:
|
|
rms = self.audio_queue.get(timeout=self.POLL_SECONDS)
|
|
except queue.Empty:
|
|
rms = 0.0
|
|
|
|
now = time.monotonic()
|
|
try:
|
|
threshold = float(self.threshold_var.get())
|
|
release_delay = max(0.05, int(self.release_ms_var.get()) / 1000.0)
|
|
except Exception:
|
|
threshold, release_delay = 0.025, 0.45
|
|
|
|
try:
|
|
self.poll_hotkey()
|
|
reason = self.blocking_reason()
|
|
self.hold_reason = reason
|
|
|
|
if reason:
|
|
self.release_ptt()
|
|
elif rms >= threshold:
|
|
self.last_voice_time = now
|
|
self.press_ptt()
|
|
elif self.ptt_down and now - self.last_voice_time >= release_delay:
|
|
self.release_ptt()
|
|
except Exception as e:
|
|
self.running = False
|
|
self.root.after(0, lambda err=e: messagebox.showerror(
|
|
APP_NAME,
|
|
f"Tastatureingabe fehlgeschlagen:\n{err}\n\n"
|
|
"Zuerst den PTT-Test ausserhalb von Squad probieren.\n"
|
|
"Laeuft Squad als Administrator, muss auch dieses "
|
|
"Programm als Administrator laufen."))
|
|
break
|
|
|
|
try:
|
|
self.release_ptt()
|
|
except Exception:
|
|
pass
|
|
|
|
# -- Anzeige ------------------------------------------------------------
|
|
def ui_tick(self):
|
|
try:
|
|
val = float(self.current_level)
|
|
self.level_bar.update_values(val, float(self.threshold_var.get()),
|
|
self.ptt_down)
|
|
self.level_label.config(text=f"{val:.3f}")
|
|
self.threshold_label.config(text=f"{self.threshold_var.get():.3f}")
|
|
|
|
self.cursor_hint.config(
|
|
text="Mauszeiger gerade sichtbar" if cursor_is_visible()
|
|
else "Mauszeiger gerade ausgeblendet")
|
|
self.proc_hint.config(
|
|
text=f"gerade im Vordergrund: {get_foreground_process_name() or '?'}")
|
|
|
|
threshold = float(self.threshold_var.get())
|
|
if not self.running:
|
|
self.status_var.set("● BEREITSCHAFT")
|
|
self.status_label.config(foreground=FG_DIM)
|
|
self.detail_var.set("")
|
|
self.diag_var.set("Nicht gestartet - unten auf STARTEN klicken.")
|
|
else:
|
|
laut = "ueber Schwelle" if val >= threshold else "ZU LEISE"
|
|
zeilen = [f"Pegel {val:.4f} / Schwelle {threshold:.4f} -> {laut}"]
|
|
if self.ptt_down:
|
|
self.status_var.set("● SENDET")
|
|
self.status_label.config(foreground=GREEN_TX)
|
|
self.detail_var.set("")
|
|
zeilen.append("Taste wird gehalten.")
|
|
elif self.hold_reason:
|
|
self.status_var.set("● GESPERRT")
|
|
self.status_label.config(foreground=RED)
|
|
self.detail_var.set(self.hold_reason)
|
|
zeilen.append(f"Blockiert: {self.hold_reason}")
|
|
if self.hold_reason == "Squad nicht im Vordergrund":
|
|
zeilen.append(" -> Squad anklicken, oder den Haken im")
|
|
zeilen.append(" Reiter 'Tasten und Verhalten' entfernen.")
|
|
else:
|
|
self.status_var.set("● HORCHT")
|
|
self.status_label.config(foreground=AMBER)
|
|
self.detail_var.set("")
|
|
zeilen.append("Nichts blockiert - es fehlt nur lautes Sprechen.")
|
|
self.diag_var.set("\n".join(zeilen))
|
|
except Exception:
|
|
pass
|
|
self.root.after(80, self.ui_tick)
|
|
|
|
def on_close(self):
|
|
try:
|
|
self.akte.speichern_sofort()
|
|
except Exception as e:
|
|
log_exception(type(e), e, e.__traceback__)
|
|
try:
|
|
self.save_config()
|
|
except Exception:
|
|
pass
|
|
self.stop()
|
|
self.root.destroy()
|
|
|
|
|
|
def main():
|
|
root = tk.Tk()
|
|
try:
|
|
apply_tactical_theme(root)
|
|
except Exception as e:
|
|
log_exception(type(e), e, e.__traceback__)
|
|
VoiceActivationApp(root)
|
|
root.mainloop()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|