kimal3 0.9.2 → 0.9.3

package/zeigen/zeitleiste.py

@@ -43,6 +43,17 @@ UMSCHALTER = {"ctrl": "Strg", "ctrl_l": "Strg", "ctrl_r": "Strg", "alt": "Alt",
               "cmd": "Win", "cmd_l": "Win", "cmd_r": "Win", "shift": "Umschalt", "shift_l": "Umschalt",
               "shift_r": "Umschalt", "alt_gr": "AltGr"}
 KOMBI = ("Strg", "Alt", "Win")
+# Mac (Aufnehmer macOS, input_observer/darwin.py `_KEY_NAMES`): In `key_name` -- der Spalte, die wir lesen -- stehen die
+# ROHEN Namen mit Seite (cmd_l/cmd_r, alt_l/alt_r, shift_l/shift_r, ctrl_l/ctrl_r); vereinheitlicht ist nur
+# `canonical_key_name`. Beide Formen gelten, damit auch eine Aufnahme mit vereinheitlichten Namen stimmt.
+# `fn` und `caps_lock` kommen als eigene Tasten und sind weder Text noch Kombination.
+MAC_UMSCHALTER = {name + seite: zeichen for name, zeichen in {"cmd": "⌘", "alt": "⌥", "ctrl": "⌃", "shift": "⇧"}.items()
+                  for seite in ("", "_l", "_r")}
+MAC_REIHENFOLGE = ("⌃", "⌥", "⇧", "⌘")  # wie das Mac-Menue: Ctrl, Option, Umschalt, Befehl
+MAC_KOMBI = ("⌃", "⌥", "⌘")  # nur diese machen eine Kombination; Umschalt allein ist Grossschreibung
+MAC_STUMM = ("fn", "caps_lock")
+MAC_PFEILE = {"up": "↑", "down": "↓", "left": "←", "right": "→"}
+MAC_EINGABEFELDER = ("edit", "axtextfield", "axtextarea", "axcombobox", "axsearchfield")
 ZEICHEN = {"space": " ", "enter": "⏎", "tab": "⇥", "up": "↑", "down": "↓", "left": "←", "right": "→"}
 # Passwortfelder: Windows meldet `IsPassword`, gespeichert wird das Merkmal aber nicht (StructuralElement kennt kein
 # Feld dafuer, structural.py). Deshalb wie der Aufnehmer selbst (shadow/events.py native_field_is_secure) zusaetzlich
@@ -66,7 +77,7 @@ def _woerter_teilen(text: str) -> str:
     return re.sub(r"(?<=[a-z0-9])(?=[A-Z])", " ", re.sub(r"[-_.#]+", " ", text))
 
 
-def passwortfeld(beobachtung: dict | None) -> bool:
+def passwortfeld(beobachtung: dict | None, plattform: str = "win32") -> bool:
     if not isinstance(beobachtung, dict):
         return False
     e = beobachtung.get("element") or {}
@@ -76,7 +87,8 @@ def passwortfeld(beobachtung: dict | None) -> bool:
     if "password" in rollen or "secure" in rollen:
         return True
     namen = [e.get("automation_id"), e.get("class_name")]
-    if str(e.get("control_type") or e.get("role") or "").casefold() == "edit":
+    felder = MAC_EINGABEFELDER if plattform == "darwin" else ("edit",)
+    if str(e.get("control_type") or e.get("role") or "").casefold() in felder:
         namen.append(e.get("name"))
     return any(isinstance(n, str) and GEHEIM.search(_woerter_teilen(n)) for n in namen)
 
@@ -86,11 +98,14 @@ def _programm(beobachtung: dict) -> str | None:
     return re.sub(r"\.exe$", "", name, flags=re.IGNORECASE).casefold() or None
 
 
-def _klick_text(beobachtung: dict | None, t: dict) -> str:
+def _klick_text(beobachtung: dict | None, t: dict, plattform: str = "win32") -> str:
     if not isinstance(beobachtung, dict) or not beobachtung.get("element"):
         return t["unbekannt"]
     e = beobachtung["element"]
-    teile = [_eine_zeile(e.get("role") or e.get("control_type"))]
+    rolle = _eine_zeile(e.get("role") or e.get("control_type"))
+    if plattform == "darwin":
+        rolle = re.sub(r"^AX(?=[A-Z])", "", rolle)  # AXLink -> Link
+    teile = [rolle]
     if _eine_zeile(e.get("name")):
         teile.append(f"{t['auf']}{_eine_zeile(e['name'])}{t['zu']}")
     programm = _programm(beobachtung)
@@ -118,7 +133,9 @@ def _saetze(woerter: list) -> list:
     return saetze + ([satz] if satz else [])
 
 
-def _kombi_name(e: dict) -> str:
+def _kombi_name(e: dict, plattform: str = "win32") -> str:
+    if plattform == "darwin" and e.get("taste") in MAC_PFEILE:
+        return MAC_PFEILE[e["taste"]]
     zeichen = e.get("zeichen") or ""
     if len(zeichen) == 1 and 1 <= ord(zeichen) <= 26:  # Strg+Buchstabe kommt als Steuerzeichen: \x03 = Strg+C
         return chr(64 + ord(zeichen))
@@ -127,11 +144,15 @@ def _kombi_name(e: dict) -> str:
     return (e.get("taste") or "?").replace("_", " ").title()
 
 
-def zeitleiste_aus(kopf: dict, woerter: list, ereignisse: list, sprache: str, ohne_getipptes: bool) -> tuple:
+def zeitleiste_aus(kopf: dict, woerter: list, ereignisse: list, sprache: str, ohne_getipptes: bool,
+                   plattform: str = "win32") -> tuple:
     """Text der Zeitleiste und ihre Zahlen. kopf: aufgabe, datum (fertiger Text), dauer_sek. woerter: (Anfang, Ende, Wort)
     in Sekunden ab Aufnahmestart. ereignisse: dicts mit t, art (click|press|release|…), beobachtung, bei Tasten
-    taste und zeichen."""
+    taste und zeichen. plattform: `recording.platform` der Aufnahme, "darwin" = Mac, sonst wie Windows."""
     t = TEXTE[sprache]
+    mac = plattform == "darwin"
+    umschalter = MAC_UMSCHALTER if mac else UMSCHALTER
+    kombi_reihe = MAC_KOMBI if mac else KOMBI
     zahlen = {"saetze": 0, "klicks": 0, "tippstellen": 0, "passwortfelder": 0}
     zeilen = []  # (Sekunde, Verb, Text)
 
@@ -161,27 +182,36 @@ def zeitleiste_aus(kopf: dict, woerter: list, ereignisse: list, sprache: str, oh
         if art == "click":
             folge_ende()
             gehalten.clear()
-            klick_geheim = passwortfeld(e.get("beobachtung"))
-            zeilen.append((e["t"], t["klickt"], _klick_text(e.get("beobachtung"), t)))
+            klick_geheim = passwortfeld(e.get("beobachtung"), plattform)
+            zeilen.append((e["t"], t["klickt"], _klick_text(e.get("beobachtung"), t, plattform)))
             zahlen["klicks"] += 1
             continue
         if art == "release":
-            gehalten.discard(UMSCHALTER.get(taste))
+            gehalten.discard(umschalter.get(taste))
             continue
         if art != "press":
             continue  # Mausbewegung, Scrollen
-        if taste in UMSCHALTER:
-            gehalten.add(UMSCHALTER[taste])
+        if mac and taste in MAC_STUMM:
+            continue
+        if taste in umschalter:
+            gehalten.add(umschalter[taste])
             continue
         zeichen = e.get("zeichen") or ""
         steuer = taste is None and len(zeichen) == 1 and 1 <= ord(zeichen) <= 26  # Tab/Enter haben einen Namen
         # Windows meldet AltGr als ctrl_l + alt_r, also Strg+Alt: ein druckbares Zeichen dabei ist Text („@", „€").
         altgr = bool(zeichen) and zeichen.isprintable() and ("AltGr" in gehalten or {"Strg", "Alt"} <= gehalten)
+        if mac:  # Option (auch mit Umschalt) + druckbares Zeichen ist Text („@" auf Option+L); mit Befehl oder Ctrl nicht
+            altgr = bool(zeichen) and zeichen.isprintable() and "⌥" in gehalten and not {"⌘", "⌃"} & gehalten
         # Im Passwortfeld wird keine Kombination eine eigene Zeile: sie verriete Tasten und teilte die Ausblendung.
-        geheim = klick_geheim or (folge is not None and folge["geheim"]) or passwortfeld(e.get("beobachtung"))
-        kombi = [m for m in KOMBI if m in gehalten] or (["Strg"] if steuer else [])
+        geheim = klick_geheim or (folge is not None and folge["geheim"]) or passwortfeld(e.get("beobachtung"), plattform)
+        kombi = [m for m in kombi_reihe if m in gehalten] or ([("⌃" if mac else "Strg")] if steuer else [])
         if kombi and not altgr and not geheim:
             folge_ende()
+            if mac:  # Mac-Schreibweise ohne Plus: [⌘C], [⌥→]; Umschalt kommt nur dazu, wenn schon eine Kombination da ist
+                kombi = [m for m in MAC_REIHENFOLGE if m in kombi or (m == "⇧" and m in gehalten)]
+                zeilen.append((e["t"], t["tippt"], "[" + "".join(kombi) + _kombi_name(e, plattform) + "]"))
+                gehalten.clear()
+                continue
             mods = kombi + (["Umschalt"] if "Umschalt" in gehalten else [])
             zeilen.append((e["t"], t["tippt"], "[" + "+".join(t.get(m, m) for m in mods) + f"+{_kombi_name(e)}]"))
             gehalten.clear()  # eine Kombination verbraucht die Umschalter; die naechste Taste kommt wieder mit eigenen
@@ -192,7 +222,7 @@ def zeitleiste_aus(kopf: dict, woerter: list, ereignisse: list, sprache: str, oh
         if folge is None:
             folge = {"t": e["t"], "text": "", "geheim": klick_geheim, "zuletzt": e["t"]}
         folge["zuletzt"] = e["t"]
-        folge["geheim"] = folge["geheim"] or passwortfeld(e.get("beobachtung"))
+        folge["geheim"] = folge["geheim"] or passwortfeld(e.get("beobachtung"), plattform)
         if taste == "backspace":
             folge["text"] = folge["text"][:-1]
         elif zeichen and zeichen.isprintable():
@@ -209,6 +239,18 @@ def zeitleiste_aus(kopf: dict, woerter: list, ereignisse: list, sprache: str, oh
 
 # --- Aufnahme lesen, Ton in Woerter ------------------------------------------------------------------------------
 
+def _lies_plattform(ordner: str) -> str:
+    """`recording.platform` ("darwin" auf dem Mac). Aeltere Aufnahmen ohne Spalte oder mit leerem Wert: "win32"."""
+    db = sqlite3.connect(f"file:{os.path.join(ordner, ROH, 'recording.db')}?mode=ro", uri=True)
+    try:
+        wert = db.execute("select platform from recording").fetchone()
+    except sqlite3.OperationalError:  # keine Spalte
+        return "win32"
+    finally:
+        db.close()
+    return wert[0] if wert and wert[0] else "win32"
+
+
 def _lies_aufnahme(ordner: str):
     db = sqlite3.connect(f"file:{os.path.join(ordner, ROH, 'recording.db')}?mode=ro", uri=True)
     try:
@@ -307,6 +349,7 @@ def auswerten(ordner: str, sprache: str, ohne_getipptes: bool, modell_da) -> dic
         return dict(daten, grund="keine-aufnahme")
     try:
         start, beschreibung, ereignisse, letzte, ton = _lies_aufnahme(ordner)
+        plattform = _lies_plattform(ordner)
     except (sqlite3.Error, TypeError, ValueError):
         return dict(daten, grund="aufnahme-unlesbar")
     daten["dauer_sek"] = round(max(letzte, 0.0), 2)
@@ -321,7 +364,7 @@ def auswerten(ordner: str, sprache: str, ohne_getipptes: bool, modell_da) -> dic
     dauer = max(letzte, ton_ende)
     kopf = {"aufgabe": _aufgabe(ordner, beschreibung), "datum": time.strftime("%Y-%m-%d %H:%M", time.localtime(start)),
             "dauer_sek": dauer}
-    text, zahlen = zeitleiste_aus(kopf, woerter, ereignisse, sprache, ohne_getipptes)
+    text, zahlen = zeitleiste_aus(kopf, woerter, ereignisse, sprache, ohne_getipptes, plattform)
     daten.update(zahlen, dauer_sek=round(dauer, 2))
     if zahlen["saetze"] == 0:
         return dict(daten, ergebnis="keine-sprache")