Die angezeigte Version springt von 4.0 auf 1.5.0 zurueck. Damit Updates weiter ankommen, vergleicht das Programm jetzt eine Zaehlnummer BUILD statt der Anzeige. version.json fuehrt "anzeige" und "build" und fuer Programme bis 4.0 dauerhaft "version": "4.1". Getestet mit dem echten pruefe_update() aus 3.2, 3.3 und 4.0. Der Release-Bau warnt, wenn BUILD nicht hoeher ist als auf dem Server. Die Downloadseite zeigt "anzeige". Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
293 lines
12 KiB
Python
293 lines
12 KiB
Python
"""
|
|
Erzeugt aus der Quelle ein vollstaendiges Release.
|
|
|
|
Ergebnis in dist/:
|
|
paket/ aufbereitete Programmdateien
|
|
SquadManager-<v>.zip Paket fuer den Auto-Updater
|
|
SquadManager-Setup-<v>.exe
|
|
version.json Steuerdatei fuer den Server
|
|
server/ genau das, was hochgeladen wird
|
|
|
|
Aufruf: .venv\\Scripts\\python.exe werkzeuge\\baue_release.py
|
|
"""
|
|
|
|
import hashlib
|
|
import html
|
|
import io
|
|
import json
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
import tokenize
|
|
import zipfile
|
|
from pathlib import Path
|
|
|
|
WURZEL = Path(__file__).resolve().parent.parent
|
|
DIST = WURZEL / "dist"
|
|
BASIS_URL = "https://sva.tyrveil.com"
|
|
# Programme bis 4.0 vergleichen nur das Feld "version" mit ihrer eigenen
|
|
# Nummer. Es muss deshalb dauerhaft groesser als 4.0 bleiben - nie senken,
|
|
# sonst bekommen sie kein Update mehr. Neuere Programme lesen "build".
|
|
VERSION_FUER_ALTE_PROGRAMME = "4.1"
|
|
|
|
PYTHON_DATEIEN = ("squad_manager.py", "theme.py", "akte.py", "akte_modell.py",
|
|
"akte_vorlagen.py", "akte_karte.py", "update_helfer.py", "start.pyw",
|
|
"make_icon.py")
|
|
MITKOPIEREN = ("requirements.txt", "icon.png", "icon.ico")
|
|
|
|
ISCC_KANDIDATEN = (
|
|
Path.home() / "AppData/Local/Programs/Inno Setup 6/ISCC.exe",
|
|
Path("C:/Program Files (x86)/Inno Setup 6/ISCC.exe"),
|
|
Path("C:/Program Files/Inno Setup 6/ISCC.exe"),
|
|
)
|
|
|
|
UMLAUTE = [
|
|
("Aenderung", "Änderung"), ("aendern", "ändern"), ("Geraet", "Gerät"),
|
|
("Haelt", "Hält"), ("haelt", "hält"), ("laesst", "lässt"),
|
|
("laeuft", "läuft"), ("Laeuft", "Läuft"), ("naechst", "nächst"),
|
|
("Praefix", "Präfix"), ("waehl", "wähl"), ("Waehl", "Wähl"),
|
|
("gewaehlt", "gewählt"), ("waehrend", "während"), ("zulaessig", "zulässig"),
|
|
("Zulaessig", "Zulässig"), ("faellt", "fällt"), ("spaeter", "später"),
|
|
("Staender", "Ständer"), ("Behaelter", "Behälter"), ("oeffn", "öffn"),
|
|
("Oeffn", "Öffn"), ("moeglich", "möglich"), ("koenn", "könn"),
|
|
("Koenn", "Könn"), ("loesch", "lösch"), ("noetig", "nötig"),
|
|
("hoeher", "höher"), ("hoechst", "höchst"), ("Menue", "Menü"),
|
|
("Buegel", "Bügel"), ("Stueck", "Stück"), ("drueck", "drück"),
|
|
("Drueck", "Drück"), ("gedrueckt", "gedrückt"), ("zurueck", "zurück"),
|
|
("Zurueck", "Zurück"), ("ueber", "über"), ("Ueber", "Über"),
|
|
("fuer", "für"), ("Fuer", "Für"), ("muess", "müss"),
|
|
("ausfuehr", "ausführ"), ("fuehrt", "führt"), ("unterstuetz", "unterstütz"),
|
|
("gueltig", "gültig"), ("Schluessel", "Schlüssel"), ("ueblich", "üblich"),
|
|
("zusaetzlich", "zusätzlich"), ("pruef", "prüf"), ("Pruef", "Prüf"),
|
|
("Verknuepfung", "Verknüpfung"), ("verknuepf", "verknüpf"),
|
|
("verzoeger", "verzöger"), ("schliess", "schließ"), ("Schliess", "Schließ"),
|
|
("heisst", "heißt"), ("ausser", "außer"), ("Ausser", "Außer"),
|
|
("gross", "groß"), ("Gross", "Groß"), ("weiss", "weiß"), ("Fuss", "Fuß"),
|
|
("Oberflaeche", "Oberfläche"), ("Flaeche", "Fläche"),
|
|
("Abhaengigkeit", "Abhängigkeit"), ("regelmaessig", "regelmäßig"),
|
|
("Verhaelt", "Verhält"), ("Erklaerung", "Erklärung"),
|
|
("standardmaessig", "standardmäßig"), ("hoehe", "höhe"),
|
|
("uebernommen", "übernommen"), ("haengt", "hängt"),
|
|
("abgestuerzt", "abgestürzt"), ("loesst", "löst"), ("Loest", "Löst"),
|
|
("tatsaechlich", "tatsächlich"), ("Haeufige", "Häufige"),
|
|
("Rueckmeldung", "Rückmeldung"), ("geoeffnet", "geöffnet"),
|
|
("kuerzt", "kürzt"), ("laengeren", "längeren"), ("Faerbt", "Färbt"),
|
|
("aelteren", "älteren"), ("massgeblich", "maßgeblich"),
|
|
("Pruefsumme", "Prüfsumme"), ("entschluesselt", "entschlüsselt"),
|
|
("unveraendert", "unverändert"), ("Netzwerkfehler", "Netzwerkfehler"),
|
|
("schuetz", "schütz"), ("kuenftig", "künftig"), ("Rueckfrage", "Rückfrage"),
|
|
]
|
|
|
|
|
|
def version_lesen():
|
|
text = (WURZEL / "squad_manager.py").read_text(encoding="utf-8")
|
|
treffer = re.search(r'^VERSION\s*=\s*"([^"]+)"', text, re.M)
|
|
build = re.search(r'^BUILD\s*=\s*(\d+)', text, re.M)
|
|
if not treffer or not build:
|
|
raise SystemExit("VERSION oder BUILD nicht gefunden")
|
|
return treffer.group(1), int(build.group(1))
|
|
|
|
|
|
def build_pruefen(build):
|
|
"""Warnt, wenn BUILD nicht hoeher ist als online - das Update kaeme sonst nirgends an."""
|
|
import urllib.request
|
|
try:
|
|
with urllib.request.urlopen(f"{BASIS_URL}/version.json", timeout=8) as antwort:
|
|
online = json.loads(antwort.read(65536).decode("utf-8"))
|
|
except Exception as fehler:
|
|
print(f" Server nicht erreichbar, Build nicht verglichen ({type(fehler).__name__})")
|
|
return
|
|
online_build = online.get("build")
|
|
if online_build is not None and int(online_build) >= build:
|
|
print(f" WARNUNG: Online liegt schon Build {online_build}. BUILD in "
|
|
"squad_manager.py erhoehen, sonst sieht niemand das Update.")
|
|
else:
|
|
print(f" Build {build} ist neuer als online ({online_build or online.get('version')})")
|
|
|
|
|
|
def aufbereiten(pfad: Path):
|
|
"""Kommentare entfernen und echte Umlaute setzen."""
|
|
quelle = pfad.read_text(encoding="utf-8")
|
|
|
|
behalten = [t for t in tokenize.generate_tokens(io.StringIO(quelle).readline)
|
|
if t.type != tokenize.COMMENT]
|
|
text = tokenize.untokenize(behalten)
|
|
|
|
zeilen, leer = [], 0
|
|
for zeile in text.split("\n"):
|
|
zeile = zeile.rstrip()
|
|
leer = leer + 1 if not zeile else 0
|
|
if leer <= 2:
|
|
zeilen.append(zeile)
|
|
text = "\n".join(zeilen).strip() + "\n"
|
|
|
|
tokens = []
|
|
for tok in tokenize.generate_tokens(io.StringIO(text).readline):
|
|
if tok.type == tokenize.STRING:
|
|
neu = tok.string
|
|
for alt, ersatz in UMLAUTE:
|
|
neu = neu.replace(alt, ersatz)
|
|
tok = tok._replace(string=neu)
|
|
tokens.append(tok)
|
|
text = tokenize.untokenize(tokens)
|
|
|
|
# f-Zeichenketten sind seit Python 3.12 keine STRING-Token mehr
|
|
for alt, ersatz in (("uebernommen", "übernommen"), ("geoeffnet", "geöffnet"),
|
|
("ueblichen", "üblichen"), ("Bildpunkte gross",
|
|
"Bildpunkte groß")):
|
|
text = text.replace(alt, ersatz)
|
|
|
|
pfad.write_text(text, encoding="utf-8", newline="\n")
|
|
|
|
|
|
def paket_bauen(version):
|
|
paket = DIST / "paket"
|
|
if paket.exists():
|
|
shutil.rmtree(paket)
|
|
(paket / "Programm").mkdir(parents=True)
|
|
|
|
for name in PYTHON_DATEIEN:
|
|
ziel = paket / "Programm" / name
|
|
shutil.copy2(WURZEL / name, ziel)
|
|
aufbereiten(ziel)
|
|
subprocess.run([sys.executable, "-m", "py_compile", str(ziel)],
|
|
check=True, capture_output=True)
|
|
for name in MITKOPIEREN:
|
|
shutil.copy2(WURZEL / name, paket / "Programm" / name)
|
|
|
|
vorlage = WURZEL / "installer" / "paketdateien"
|
|
if vorlage.is_dir():
|
|
for datei in vorlage.iterdir():
|
|
shutil.copy2(datei, paket / "Programm" / datei.name)
|
|
|
|
for unter in (paket / "Programm").rglob("__pycache__"):
|
|
shutil.rmtree(unter, ignore_errors=True)
|
|
|
|
# Der Installer legt die Dateien flach ab, der Updater erwartet sie
|
|
# unter Programm/. Beides getrennt halten, sonst landet im
|
|
# Installationsordner ein ueberfluessiger Unterordner.
|
|
flach = DIST / "installerdateien"
|
|
if flach.exists():
|
|
shutil.rmtree(flach)
|
|
flach.mkdir(parents=True)
|
|
for datei in (paket / "Programm").iterdir():
|
|
if datei.is_file():
|
|
shutil.copy2(datei, flach / datei.name)
|
|
return paket
|
|
|
|
|
|
def zip_bauen(paket, version):
|
|
ziel = DIST / f"SquadManager-{version}.zip"
|
|
if ziel.exists():
|
|
ziel.unlink()
|
|
with zipfile.ZipFile(ziel, "w", zipfile.ZIP_DEFLATED) as archiv:
|
|
for datei in sorted((paket / "Programm").iterdir()):
|
|
if datei.is_file():
|
|
archiv.write(datei, f"Programm/{datei.name}")
|
|
return ziel
|
|
|
|
|
|
def installer_bauen(version):
|
|
iscc = next((p for p in ISCC_KANDIDATEN if p.is_file()), None)
|
|
if iscc is None:
|
|
print(" Inno Setup nicht gefunden - Installer wird uebersprungen")
|
|
return None
|
|
skript = WURZEL / "installer" / "setup.iss"
|
|
inhalt = skript.read_text(encoding="utf-8")
|
|
inhalt = re.sub(r'(#define Version\s+)"[^"]+"', rf'\1"{version}"', inhalt)
|
|
skript.write_text(inhalt, encoding="utf-8")
|
|
|
|
ergebnis = subprocess.run([str(iscc), str(skript)],
|
|
capture_output=True, text=True)
|
|
if ergebnis.returncode != 0:
|
|
print(ergebnis.stdout[-1500:])
|
|
print(ergebnis.stderr[-1500:])
|
|
raise SystemExit("Installer konnte nicht erstellt werden")
|
|
return DIST / f"SquadManager-Setup-{version}.exe"
|
|
|
|
|
|
def seite_bauen(server, version, setup_pfad):
|
|
"""
|
|
Downloadseite index.html aus installer/downloadseite.html.
|
|
|
|
Die Seite liest beim Aufruf version.json und zeigt dann ohnehin die
|
|
Version vom Server. Die hier eingesetzten Werte greifen, wenn das nicht
|
|
klappt, und liefern Groesse und Datum der gebauten Fassung.
|
|
"""
|
|
vorlage = WURZEL / "installer" / "downloadseite.html"
|
|
if not vorlage.is_file():
|
|
return
|
|
groesse = ""
|
|
if setup_pfad and setup_pfad.exists():
|
|
groesse = f"{setup_pfad.stat().st_size / 1048576:.1f} MB".replace(".", ",")
|
|
werte = {
|
|
"__VERSION__": version,
|
|
"__INSTALLER__": setup_pfad.name if setup_pfad else "",
|
|
"__GROESSE__": groesse,
|
|
"__DATUM__": time.strftime("%d.%m.%Y"),
|
|
}
|
|
text = vorlage.read_text(encoding="utf-8")
|
|
for platzhalter, wert in werte.items():
|
|
text = text.replace(platzhalter, html.escape(wert))
|
|
(server / "index.html").write_text(text, encoding="utf-8", newline="\n")
|
|
shutil.copy2(WURZEL / "icon.png", server / "icon.png")
|
|
|
|
|
|
def server_bauen(version, build, zip_pfad, setup_pfad):
|
|
server = DIST / "server"
|
|
if server.exists():
|
|
shutil.rmtree(server)
|
|
server.mkdir(parents=True)
|
|
|
|
shutil.copy2(zip_pfad, server / zip_pfad.name)
|
|
if setup_pfad and setup_pfad.exists():
|
|
shutil.copy2(setup_pfad, server / setup_pfad.name)
|
|
anleitung = WURZEL / "installer" / "HOCHLADEN.txt"
|
|
if anleitung.is_file():
|
|
text = anleitung.read_text(encoding="utf-8").replace("__VERSION__", version)
|
|
(server / anleitung.name).write_text(text, encoding="utf-8", newline="\r\n")
|
|
seite_bauen(server, version, setup_pfad)
|
|
|
|
pruefsumme = hashlib.sha256(zip_pfad.read_bytes()).hexdigest()
|
|
angaben = {
|
|
"version": VERSION_FUER_ALTE_PROGRAMME,
|
|
"anzeige": version,
|
|
"build": build,
|
|
"datei": f"{BASIS_URL}/{zip_pfad.name}",
|
|
"sha256": pruefsumme,
|
|
"hinweis": "",
|
|
# Ab 4.0: Ziel fuer den Hinweis, wenn ein Update nicht einspielbar ist
|
|
"installer": f"{BASIS_URL}/SquadManager-Setup-{version}.exe",
|
|
}
|
|
(server / "version.json").write_text(
|
|
json.dumps(angaben, indent=2, ensure_ascii=False) + "\n",
|
|
encoding="utf-8")
|
|
return server, pruefsumme
|
|
|
|
|
|
def main():
|
|
version, build = version_lesen()
|
|
DIST.mkdir(exist_ok=True)
|
|
print(f"Version {version} (Build {build})")
|
|
build_pruefen(build)
|
|
|
|
paket = paket_bauen(version)
|
|
print(" Programmdateien aufbereitet")
|
|
|
|
zip_pfad = zip_bauen(paket, version)
|
|
print(f" {zip_pfad.name} ({zip_pfad.stat().st_size // 1024} KB)")
|
|
|
|
setup_pfad = installer_bauen(version)
|
|
if setup_pfad:
|
|
print(f" {setup_pfad.name} ({setup_pfad.stat().st_size // 1024} KB)")
|
|
|
|
server, pruefsumme = server_bauen(version, build, zip_pfad, setup_pfad)
|
|
print(f" server/ vorbereitet, SHA256 {pruefsumme[:16]}...")
|
|
print()
|
|
print(f"Zum Hochladen bereit: {server}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|