python-docs-de/tools/tx_diff.py at 3.15 · python/python-docs-de

History

339 lines (283 loc) · 12.5 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

#!/usr/bin/env python3

"""Vergleicht Transifex mit dem lokalen Repo -- Eintrag fuer Eintrag.

Sucht zuerst die Ressourcen, in denen in den letzten Tagen jemand etwas

geaendert hat, und stellt dann fuer jede davon den Text aus Transifex dem

lokalen msgstr gegenueber. Ausgegeben werden nur die Abweichungen.

Der Token kommt aus TX_TOKEN oder aus ~/.transifexrc.

Aufruf (im Repo, im Branch, dessen Projekt gemeint ist):

python tools/tx_diff.py --tage 7 -o bericht.md

python tools/tx_diff.py --benutzer JystBreisgau --tage 14 -o jyst.md

python tools/tx_diff.py --ressource reference--datamodel -o datamodel.md

python tools/tx_diff.py --tage 7 --voll -o bericht.md # ungekuerzte Texte

Es wird nur gelesen; weder Transifex noch die lokalen Dateien werden

veraendert.

"""

import argparse

import configparser

import json

import os

import re

import ssl

import subprocess

import sys

import urllib.error

import urllib.parse

import urllib.request

from datetime import datetime, timedelta, timezone

from pathlib import Path

API = "https://rest.api.transifex.com"

KUERZUNG = 160

def ssl_kontext() -> ssl.SSLContext:

try:

import certifi

return ssl.create_default_context(cafile=certifi.where())

except ImportError:

return ssl.create_default_context()

KONTEXT = ssl_kontext()

def token() -> str:

t = os.environ.get("TX_TOKEN")

if t:

return t.strip()

rc = Path.home() / ".transifexrc"

if rc.is_file():

cfg = configparser.ConfigParser()

cfg.read(rc)

for abschnitt in cfg.sections():

if cfg[abschnitt].get("token"):

return cfg[abschnitt]["token"].strip()

sys.exit("Kein API-Token gefunden. Setze TX_TOKEN oder pflege ~/.transifexrc.")

def git(*args: str) -> str:

e = subprocess.run(["git", *args], capture_output=True, text=True)

return e.stdout if e.returncode == 0 else ""

def repo_wurzel() -> Path:

aus = git("rev-parse", "--show-toplevel").strip()

if not aus:

sys.exit("Kein Git-Repository -- bitte im python-docs-de-Verzeichnis starten.")

return Path(aus)

def ressourcen(wurzel: Path) -> tuple:

pfad = wurzel / ".tx" / "config"

if not pfad.is_file():

sys.exit(f"{pfad} nicht gefunden.")

cfg = configparser.ConfigParser()

cfg.read(pfad, encoding="utf-8")

karte, org, projekt = {}, None, None

for name in cfg.sections():

m = re.match(r"o:([^:]+):p:([^:]+):r:(.+)", name)

if not m:

continue

org, projekt, slug = m.groups()

datei = (cfg[name].get("trans.de") or cfg[name].get("file_filter", ""))

karte[slug] = datei.replace("<lang>", "de").strip()

if not karte:

sys.exit("In .tx/config wurden keine Ressourcen gefunden.")

return karte, org, projekt

def seiten(pfad: str, params: dict, tok: str):

"""Liefert (data-Eintrag, included-Karte) fuer alle Seiten."""

url = API + pfad + ("?" + urllib.parse.urlencode(params) if params else "")

while url:

req = urllib.request.Request(url, headers={

"Authorization": "Bearer " + tok,

"Accept": "application/vnd.api+json",

})

try:

with urllib.request.urlopen(req, timeout=90, context=KONTEXT) as antwort:

daten = json.load(antwort)

except urllib.error.HTTPError as e:

rumpf = e.read().decode("utf-8", "replace")[:300]

raise RuntimeError(f"HTTP {e.code}: {rumpf}") from None

except urllib.error.URLError as e:

if "CERTIFICATE_VERIFY_FAILED" in str(e.reason):

sys.exit('Wurzelzertifikate fehlen -- "Install Certificates.command" '

"ausfuehren oder certifi installieren.")

raise RuntimeError(f"Netzwerkfehler: {e.reason}") from None

beigefuegt = {e["id"]: e for e in daten.get("included", [])}

for eintrag in daten.get("data", []):

yield eintrag, beigefuegt

url = (daten.get("links") or {}).get("next")

# --- lokale PO-Datei --------------------------------------------------------

def po_lesen(pfad: Path) -> dict:

"""{(msgctxt, msgid): msgstr} der lokalen Datei."""

if not pfad.is_file():

return {}

def join(block, key):

out, on = [], False

for l in block.split("\n"):

if l.startswith(key + " "):

on = True; out += re.findall(r'"(.*)"', l)

elif l.startswith('"') and on:

out += re.findall(r'"(.*)"', l)

elif l.startswith("msg") or l.startswith("#"):

on = False

return "".join(out)

def ent(s):

try:

return s.encode().decode("unicode_escape").encode("latin-1").decode("utf-8")

except Exception:

return s

aus = {}

for b in pfad.read_text(encoding="utf-8").split("\n\n"):

if not b.strip() or b.lstrip().startswith("#~"):

continue

mid = join(b, "msgid")

if not mid:

continue

aus[(ent(join(b, "msgctxt")), ent(mid))] = ent(join(b, "msgstr"))

return aus

# --- Transifex --------------------------------------------------------------

def text_von(strings) -> str:

if isinstance(strings, dict):

return strings.get("other") or strings.get("one") or ""

return strings or ""

def benutzer(eintrag: dict) -> str:

for rolle in ("translator", "reviewer"):

bez = ((eintrag.get("relationships") or {}).get(rolle) or {}).get("data")

if bez and bez.get("id"):

return bez["id"].split(":", 1)[-1]

return ""

def zeit(eintrag: dict) -> str:

return (eintrag.get("attributes") or {}).get("datetime_translated") or ""

def tx_eintraege(res_id: str, tok: str) -> dict:

"""{(context, msgid): (text, benutzer, zeit, herkunft)} aus Transifex."""

aus = {}

params = {"filter[resource]": res_id, "filter[language]": "l:de",

"include": "resource_string"}

for e, beigefuegt in seiten("/resource_translations", params, tok):

bez = ((e.get("relationships") or {}).get("resource_string") or {}).get("data")

quelle = beigefuegt.get(bez["id"]) if bez else None

if not quelle:

continue

qa = quelle.get("attributes") or {}

schluessel = (qa.get("context") or "", text_von(qa.get("strings")))

aus[schluessel] = (

text_von((e.get("attributes") or {}).get("strings")),

benutzer(e), zeit(e)[:16].replace("T", " "),

(e.get("attributes") or {}).get("origin") or "?",

)

return aus

def kuerzen(s: str, voll: bool) -> str:

s = s.replace("\n", " ⏎ ").replace("|", "\\|").strip()

if not voll and len(s) > KUERZUNG:

s = s[:KUERZUNG] + " …"

return s or "—"

# --- Hauptprogramm ----------------------------------------------------------

def main() -> None:

p = argparse.ArgumentParser(

description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)

p.add_argument("--tage", type=int, default=7, help="Zeitraum rueckwaerts (Vorgabe 7)")

p.add_argument("--benutzer", help="nur Ressourcen, die dieser Benutzer geaendert hat")

p.add_argument("--ressource", action="append",

help="bestimmte Ressource(n) statt Suche nach Aenderungen")

p.add_argument("--voll", action="store_true", help="Texte nicht kuerzen")

p.add_argument("-o", "--out", default="tx_diff.md", help="Zieldatei (Vorgabe tx_diff.md)")

args = p.parse_args()

tok = token()

wurzel = repo_wurzel()

karte, org, projekt = ressourcen(wurzel)

branch = git("branch", "--show-current").strip()

seit = (datetime.now(timezone.utc) - timedelta(days=args.tage)).strftime(

"%Y-%m-%dT%H:%M:%SZ")

# 1. Welche Ressourcen sind betroffen?

if args.ressource:

betroffen = {r: None for r in args.ressource if r in karte}

fehlend = [r for r in args.ressource if r not in karte]

for r in fehlend:

print(f"!! unbekannte Ressource: {r}", file=sys.stderr)

else:

print(f"Suche Aenderungen seit {seit} in {len(karte)} Ressourcen ...",

file=sys.stderr)

betroffen = {}

for nr, slug in enumerate(sorted(karte), 1):

if nr % 100 == 0:

print(f" {nr}/{len(karte)}", file=sys.stderr)

try:

treffer = list(seiten("/resource_translations", {

"filter[resource]": f"o:{org}:p:{projekt}:r:{slug}",

"filter[language]": "l:de",

"filter[date_translated][gt]": seit,

}, tok))

except RuntimeError:

continue

leute = {benutzer(e) for e, _ in treffer}

if not treffer:

continue

if args.benutzer and args.benutzer not in leute:

continue

betroffen[slug] = leute

if not betroffen:

print("Keine betroffenen Ressourcen gefunden.")

return

# 2. Je Ressource vergleichen

zeilen = [f"# Abgleich Transifex ↔ lokales Repo",

"",

f"Projekt **{org}:{projekt}**, Branch **{branch}**, Sprache de ",

f"Erstellt: {datetime.now().strftime('%Y-%m-%d %H:%M')} ",

(f"Zeitraum: letzte {args.tage} Tage"

+ (f", Benutzer **{args.benutzer}**" if args.benutzer else "")

if not args.ressource else "Ausgewaehlte Ressourcen"),

""]

gesamt_nur_tx = gesamt_abw = gesamt_nur_lokal = 0

for slug in sorted(betroffen):

datei = karte[slug]

print(f"vergleiche {slug} ...", file=sys.stderr)

try:

tx = tx_eintraege(f"o:{org}:p:{projekt}:r:{slug}", tok)

except RuntimeError as fehler:

print(f"!! {slug}: {fehler}", file=sys.stderr)

continue

lokal = po_lesen(wurzel / datei)

nur_tx, abweichend, nur_lokal = [], [], []

for schluessel, (txt, wer, wann, quelle) in tx.items():

lok = lokal.get(schluessel)

if lok is None:

continue # String kennt die lokale Datei nicht

if txt and not lok:

nur_tx.append((schluessel[1], txt, wer, wann, quelle))

elif txt and lok and txt != lok:

abweichend.append((schluessel[1], lok, txt, wer, wann, quelle))

elif lok and not txt:

nur_lokal.append((schluessel[1], lok))

if not (nur_tx or abweichend or nur_lokal):

continue

gesamt_nur_tx += len(nur_tx)

gesamt_abw += len(abweichend)

gesamt_nur_lokal += len(nur_lokal)

zeilen += [f"## `{datei}`", "",

f"Ressource `{slug}` — nur in Transifex: **{len(nur_tx)}**, "

f"abweichend: **{len(abweichend)}**, nur lokal: **{len(nur_lokal)}**",

""]

if nur_tx:

zeilen += ["### Nur in Transifex übersetzt (lokal leer)", "",

"| msgid | Transifex | wer | wann | Herkunft |",

"|---|---|---|---|---|"]

for mid, txt, wer, wann, quelle in nur_tx:

zeilen.append(f"| {kuerzen(mid, args.voll)} | {kuerzen(txt, args.voll)} "

f"| {wer} | {wann} | {quelle} |")

zeilen.append("")

if abweichend:

zeilen += ["### Unterschiedlich übersetzt", "",

"|---|---|---|---|---|---|"]

for mid, lok, txt, wer, wann, quelle in abweichend:

zeilen.append(f"| {kuerzen(mid, args.voll)} | {kuerzen(lok, args.voll)} "

f"| {kuerzen(txt, args.voll)} | {wer} | {wann} | {quelle} |")

zeilen.append("")

if nur_lokal:

zeilen += ["### Nur lokal übersetzt (in Transifex leer)", "",

"| msgid | lokal |", "|---|---|"]

for mid, lok in nur_lokal:

zeilen.append(f"| {kuerzen(mid, args.voll)} | {kuerzen(lok, args.voll)} |")

zeilen.append("")

zeilen[5:5] = [

"",

"| | |",

"|---|---:|",

f"| nur in Transifex übersetzt | {gesamt_nur_tx} |",

f"| unterschiedlich übersetzt | {gesamt_abw} |",

f"| nur lokal übersetzt | {gesamt_nur_lokal} |",

]

Path(args.out).write_text("\n".join(zeilen) + "\n", encoding="utf-8")

print(f"\nGeschrieben: {args.out}", file=sys.stderr)

print(f"nur Transifex: {gesamt_nur_tx}, abweichend: {gesamt_abw}, "

f"nur lokal: {gesamt_nur_lokal}", file=sys.stderr)

if __name__ == "__main__":

main()

FilesExpand file tree

tx_diff.py

Latest commit

History

tx_diff.py

File metadata and controls