termigma 1.0.0__py3-none-any.whl

termigma/__init__.py

@@ -0,0 +1,6 @@
+"""termigma - an interactive terminal Enigma machine simulator."""
+
+from .engine import Enigma
+
+__version__ = "1.0.0"
+__all__ = ["Enigma", "__version__"]

termigma/__main__.py

@@ -0,0 +1,4 @@
+from .tui import main
+
+if __name__ == "__main__":
+    main()

termigma/engine.py

@@ -0,0 +1,381 @@
+"""
+Core Enigma engine: wheels, reflectors, plugboard, and the Enigma machine
+itself, plus the plain-data helpers used by the settings screen. No curses
+here on purpose, so this module is importable and testable on its own.
+
+Historical scope: Wehrmacht/Kriegsmarine Enigma I, M3 (rotors I-VIII) and
+M4 "Shark" (adds a non-stepping Beta/Gamma wheel and a thin reflector).
+See ../../data/wiring_tables.json for sourcing notes, including which
+commercial/national variants are deliberately NOT modelled here.
+"""
+
+import string
+
+ALPHA = string.ascii_uppercase
+
+# ---------------------------------------------------------------------------
+# Historical wiring tables
+# ---------------------------------------------------------------------------
+ROTOR_DATA = {
+    "I":    {"wiring": "EKMFLGDQVZNTOWYHXUSPAIBRCJ", "notches": {"Q"}},
+    "II":   {"wiring": "AJDKSIRUXBLHWTMCQGZNPYFVOE", "notches": {"E"}},
+    "III":  {"wiring": "BDFHJLCPRTXVZNYEIWGAKMUSQO", "notches": {"V"}},
+    "IV":   {"wiring": "ESOVPZJAYQUIRHXLNFTGKDCMWB", "notches": {"J"}},
+    "V":    {"wiring": "VZBRGITYUPSDNHLXAWMJQOFECK", "notches": {"Z"}},
+    "VI":   {"wiring": "JPGVOUMFYQBENHZRDKASXLICTW", "notches": {"Z", "M"}},
+    "VII":  {"wiring": "NZJHGRCXMYSWBOUFAIVLPEKQDT", "notches": {"Z", "M"}},
+    "VIII": {"wiring": "FKQHTLXOCBJSPDZRAMEWNIUYGV", "notches": {"Z", "M"}},
+}
+ROTOR_CHOICES = list(ROTOR_DATA.keys())
+
+FOURTH_WHEEL_DATA = {
+    "Beta":  {"wiring": "LEYJVCNIXWPBQMDRTAKZGFUHOS"},
+    "Gamma": {"wiring": "FSOKANUERHMBTIYCWLQPZXVGJD"},
+}
+FOURTH_WHEEL_CHOICES = list(FOURTH_WHEEL_DATA.keys())
+
+REFLECTOR_DATA = {
+    "B":      "YRUHQSLDPXNGOKMIEBFZCWVJAT",
+    "C":      "FVPJIAOYEDRZXWGCTKUQSBNMHL",
+    "B-thin": "ENKQAUYWJICOPBLMDXZVFTHRGS",
+    "C-thin": "RDOBJNTKVEHMLFCWZAXGYIPSUQ",
+}
+REFLECTOR_CHOICES = ["B", "C", "B-thin", "C-thin", "Custom"]
+THIN_REFLECTORS = {"B-thin", "C-thin"}
+
+# Historical Enigma keyboard / lampboard layout (QWERTZ, staggered)
+KB_ROWS = ["QWERTZUIO", "ASDFGHJK", "PYXCVBNML"]
+KB_INDENT = [0, 1, 2]
+COMMERCIAL_ETW_ORDER = "".join(KB_ROWS)  # commercial ETW follows keyboard order
+
+MAX_PLUGS = 13  # full theoretical stecker capacity (wartime issue was 10 cables)
+
+MODEL_NAMES = [
+    "Custom",
+    "Enigma I (Army/GAF)",
+    "M3 (Army/Navy)",
+    "M4 'Shark' (U-boats)",
+    "Commercial-style (K/D ETW demo)",
+]
+PRESETS = {
+    "Enigma I (Army/GAF)": dict(etw="military", plugboard_enabled=True, reflector="B",
+                                 L_type="I", M_type="II", R_type="III"),
+    "M3 (Army/Navy)": dict(etw="military", plugboard_enabled=True, reflector="B",
+                            L_type="I", M_type="V", R_type="VIII"),
+    "M4 'Shark' (U-boats)": dict(etw="military", plugboard_enabled=True, reflector="B-thin",
+                                  L_type="II", M_type="IV", R_type="I", G_type="Beta"),
+    "Commercial-style (K/D ETW demo)": dict(etw="commercial", plugboard_enabled=False,
+                                             reflector="B", L_type="I", M_type="II", R_type="III"),
+}
+
+
+def default_custom_pairs():
+    pairs = {}
+    for i in range(0, 26, 2):
+        a, b = ALPHA[i], ALPHA[i + 1]
+        pairs[a] = b
+        pairs[b] = a
+    return pairs
+
+
+# ---------------------------------------------------------------------------
+# Engine
+# ---------------------------------------------------------------------------
+class Wheel:
+    """Shared forward/backward substitution math for rotors and the 4th wheel."""
+
+    def __init__(self, wiring, ring_setting=1, start_pos="A"):
+        self.wiring = wiring
+        self.ring_setting = ring_setting
+        self.position = ALPHA.index(start_pos)
+
+    @property
+    def position_letter(self):
+        return ALPHA[self.position]
+
+    def forward(self, c):
+        shift = self.position - (self.ring_setting - 1)
+        entry = (c + shift) % 26
+        out = ord(self.wiring[entry]) - ord("A")
+        return (out - shift) % 26
+
+    def backward(self, c):
+        shift = self.position - (self.ring_setting - 1)
+        entry = (c + shift) % 26
+        out = self.wiring.index(ALPHA[entry])
+        return (out - shift) % 26
+
+
+class Rotor(Wheel):
+    def __init__(self, name, ring_setting=1, start_pos="A", notch_override=None):
+        super().__init__(ROTOR_DATA[name]["wiring"], ring_setting, start_pos)
+        self.name = name
+        self.notches = {notch_override} if notch_override else set(ROTOR_DATA[name]["notches"])
+
+    def at_notch(self):
+        return self.position_letter in self.notches
+
+    def step(self):
+        self.position = (self.position + 1) % 26
+
+
+class FourthWheel(Wheel):
+    """Non-stepping M4 'Greek' wheel (Beta/Gamma): set by hand, never turns."""
+
+    def __init__(self, name, ring_setting=1, start_pos="A"):
+        super().__init__(FOURTH_WHEEL_DATA[name]["wiring"], ring_setting, start_pos)
+        self.name = name
+
+
+class EntryWheel:
+    """Fixed (non-rotating) entry wiring. Military = straight-through.
+    Commercial = wired in QWERTZU keyboard order."""
+
+    def __init__(self, mode="military"):
+        self.mode = mode
+        order = COMMERCIAL_ETW_ORDER if mode == "commercial" else ALPHA
+        self.fwd = {order[i]: i for i in range(26)}
+        self.inv = [None] * 26
+        for letter, idx in self.fwd.items():
+            self.inv[idx] = ALPHA.index(letter)
+
+    def forward(self, c):
+        return self.fwd[ALPHA[c]]
+
+    def backward(self, c):
+        return self.inv[c]
+
+
+class Reflector:
+    def __init__(self, kind="B", custom_pairs=None):
+        self.kind = kind
+        self.pairs = dict(custom_pairs) if kind == "Custom" else None
+
+    def apply(self, c):
+        if self.kind == "Custom":
+            return ALPHA.index(self.pairs[ALPHA[c]])
+        return ord(REFLECTOR_DATA[self.kind][c]) - ord("A")
+
+
+class Plugboard:
+    def __init__(self, pairs=None):
+        self.pairs = dict(pairs or {})
+
+    def apply(self, c):
+        letter = ALPHA[c]
+        return ALPHA.index(self.pairs.get(letter, letter))
+
+    def pairs_list(self):
+        seen, out = set(), []
+        for a, b in self.pairs.items():
+            if a not in seen:
+                out.append((a, b))
+                seen.add(a)
+                seen.add(b)
+        return out
+
+
+class Enigma:
+    def __init__(self, rotor_names=("I", "II", "III"), ring_settings=(1, 1, 1),
+                 positions=("A", "A", "A"), reflector_kind="B", plug_pairs=None,
+                 etw_mode="military", fourth_wheel=None, fourth_ring=1, fourth_pos="A",
+                 rotor_notches=(None, None, None), custom_reflector_pairs=None,
+                 plugboard_enabled=True):
+        self.left = Rotor(rotor_names[0], ring_settings[0], positions[0], rotor_notches[0])
+        self.middle = Rotor(rotor_names[1], ring_settings[1], positions[1], rotor_notches[1])
+        self.right = Rotor(rotor_names[2], ring_settings[2], positions[2], rotor_notches[2])
+        self.reflector_kind = reflector_kind
+        self.custom_reflector_pairs = custom_reflector_pairs or default_custom_pairs()
+        self.reflector = Reflector(reflector_kind, self.custom_reflector_pairs)
+        self.plugboard = Plugboard(plug_pairs)
+        self.plugboard_enabled = plugboard_enabled
+        self.etw = EntryWheel(etw_mode)
+        self.fourth = FourthWheel(fourth_wheel, fourth_ring, fourth_pos) if fourth_wheel else None
+        self.movable_notches = any(n is not None for n in rotor_notches)
+
+    def step_rotors(self):
+        mid_notch = self.middle.at_notch()
+        right_notch = self.right.at_notch()
+        if mid_notch:
+            self.left.step()
+            self.middle.step()
+        elif right_notch:
+            self.middle.step()
+        self.right.step()
+
+    def encode_letter(self, letter):
+        self.step_rotors()
+        path = [("Keyboard", letter)]
+        c = ALPHA.index(letter)
+        if self.plugboard_enabled:
+            c = self.plugboard.apply(c)
+            path.append(("Plugboard", ALPHA[c]))
+        c = self.etw.forward(c)
+        path.append(("Entry Wheel (ETW)", ALPHA[c]))
+        c = self.right.forward(c)
+        path.append((f"Rotor R ({self.right.name}) ->", ALPHA[c]))
+        c = self.middle.forward(c)
+        path.append((f"Rotor M ({self.middle.name}) ->", ALPHA[c]))
+        c = self.left.forward(c)
+        path.append((f"Rotor L ({self.left.name}) ->", ALPHA[c]))
+        if self.fourth:
+            c = self.fourth.forward(c)
+            path.append((f"4th Wheel ({self.fourth.name}) ->", ALPHA[c]))
+        c = self.reflector.apply(c)
+        path.append((f"Reflector {self.reflector_kind}", ALPHA[c]))
+        if self.fourth:
+            c = self.fourth.backward(c)
+            path.append((f"<- 4th Wheel ({self.fourth.name})", ALPHA[c]))
+        c = self.left.backward(c)
+        path.append((f"<- Rotor L ({self.left.name})", ALPHA[c]))
+        c = self.middle.backward(c)
+        path.append((f"<- Rotor M ({self.middle.name})", ALPHA[c]))
+        c = self.right.backward(c)
+        path.append((f"<- Rotor R ({self.right.name})", ALPHA[c]))
+        c = self.etw.backward(c)
+        path.append(("<- Entry Wheel (ETW)", ALPHA[c]))
+        if self.plugboard_enabled:
+            c = self.plugboard.apply(c)
+            path.append(("Plugboard", ALPHA[c]))
+        path.append(("Lamp", ALPHA[c]))
+        return ALPHA[c], path
+
+
+# ---------------------------------------------------------------------------
+# Settings-screen logic (pure data; the curses UI in tui.py just renders it)
+# ---------------------------------------------------------------------------
+FIELD_LABEL = {
+    "model": "Model preset",
+    "etw": "Entry wheel (ETW)",
+    "plugboard_enabled": "Plugboard",
+    "movable_notches": "Movable notches",
+    "reflector": "Reflector (UKW)",
+    "G_type": "4th wheel type", "G_ring": "4th wheel ring", "G_pos": "4th wheel start",
+    "L_type": "Left rotor type", "L_ring": "Left ring", "L_pos": "Left start pos", "L_notch": "Left notch",
+    "M_type": "Mid rotor type", "M_ring": "Mid ring", "M_pos": "Mid start pos", "M_notch": "Mid notch",
+    "R_type": "Right rotor type", "R_ring": "Right ring", "R_pos": "Right start pos", "R_notch": "Right notch",
+}
+
+
+def build_field_order(settings):
+    order = ["model", "etw", "plugboard_enabled", "movable_notches", "reflector"]
+    if settings["reflector"] in THIN_REFLECTORS:
+        order += ["G_type", "G_ring", "G_pos"]
+    for p in ("L", "M", "R"):
+        order += [f"{p}_type", f"{p}_ring", f"{p}_pos"]
+        if settings["movable_notches"]:
+            order.append(f"{p}_notch")
+    return order
+
+
+def apply_model_preset(settings, name):
+    preset = PRESETS.get(name)
+    if not preset:
+        return
+    settings.update(preset)
+    for p in ("L", "M", "R"):
+        settings[f"{p}_ring"] = 1
+        settings[f"{p}_pos"] = "A"
+    settings["movable_notches"] = False
+    if settings["reflector"] in THIN_REFLECTORS:
+        settings["G_type"] = preset.get("G_type", "Beta")
+        settings["G_ring"] = 1
+        settings["G_pos"] = "A"
+
+
+def adjust_field(settings, field, d):
+    if field == "model":
+        names = MODEL_NAMES
+        settings[field] = names[(names.index(settings[field]) + d) % len(names)]
+        if settings[field] != "Custom":
+            apply_model_preset(settings, settings[field])
+        return
+
+    if field == "etw":
+        opts = ["military", "commercial"]
+        settings[field] = opts[(opts.index(settings[field]) + d) % 2]
+    elif field == "plugboard_enabled":
+        settings[field] = not settings[field]
+    elif field == "movable_notches":
+        settings[field] = not settings[field]
+        if settings[field]:
+            for p in ("L", "M", "R"):
+                settings[f"{p}_notch"] = sorted(ROTOR_DATA[settings[f"{p}_type"]]["notches"])[0]
+    elif field == "reflector":
+        opts = REFLECTOR_CHOICES
+        settings[field] = opts[(opts.index(settings[field]) + d) % len(opts)]
+        if settings[field] in THIN_REFLECTORS:
+            settings.setdefault("G_type", "Beta")
+            settings.setdefault("G_ring", 1)
+            settings.setdefault("G_pos", "A")
+    elif field == "G_type":
+        opts = FOURTH_WHEEL_CHOICES
+        settings[field] = opts[(opts.index(settings[field]) + d) % len(opts)]
+    elif field == "G_ring":
+        settings[field] = ((settings[field] - 1 + d) % 26) + 1
+    elif field == "G_pos":
+        i = ALPHA.index(settings[field])
+        settings[field] = ALPHA[(i + d) % 26]
+    elif field.endswith("_type"):
+        opts = ROTOR_CHOICES
+        settings[field] = opts[(opts.index(settings[field]) + d) % len(opts)]
+    elif field.endswith("_ring"):
+        settings[field] = ((settings[field] - 1 + d) % 26) + 1
+    elif field.endswith("_notch") or field.endswith("_pos"):
+        i = ALPHA.index(settings[field])
+        settings[field] = ALPHA[(i + d) % 26]
+
+    settings["model"] = "Custom"
+
+
+def fmt_val(v):
+    if isinstance(v, bool):
+        return "Yes" if v else "No"
+    if isinstance(v, int):
+        return f"{v:02d}"
+    return str(v)
+
+
+# ---------------------------------------------------------------------------
+# Plugboard / custom-reflector text parsing (pure logic, no curses)
+# ---------------------------------------------------------------------------
+def parse_plug_pairs(buf):
+    tokens = buf.split()
+    if len(tokens) > MAX_PLUGS:
+        return False, f"Max {MAX_PLUGS} plug pairs (historical limit)"
+    used, pairs = set(), {}
+    for t in tokens:
+        if len(t) != 2 or not t.isalpha():
+            return False, f"Invalid pair '{t}' (need two letters)"
+        a, b = t[0], t[1]
+        if a == b:
+            return False, f"Cannot plug {a} to itself"
+        if a in used or b in used:
+            return False, f"Letter reused in '{t}'"
+        used.add(a)
+        used.add(b)
+        pairs[a] = b
+        pairs[b] = a
+    return True, pairs
+
+
+def parse_reflector_pairs(buf):
+    tokens = buf.split()
+    if len(tokens) != 13:
+        return False, f"Need exactly 13 pairs covering all 26 letters (got {len(tokens)})"
+    used, pairs = set(), {}
+    for t in tokens:
+        if len(t) != 2 or not t.isalpha():
+            return False, f"Invalid pair '{t}'"
+        a, b = t[0], t[1]
+        if a == b:
+            return False, f"Cannot reflect {a} to itself"
+        if a in used or b in used:
+            return False, f"Letter reused in '{t}'"
+        used.add(a)
+        used.add(b)
+        pairs[a] = b
+        pairs[b] = a
+    if len(used) != 26:
+        return False, "All 26 letters must be used exactly once"
+    return True, pairs

termigma/tui.py

@@ -0,0 +1,416 @@
+"""Curses front-end for the termigma Enigma engine. All model logic lives
+in engine.py; this module only draws things and reads the keyboard."""
+
+import curses
+
+from .engine import (
+    ALPHA, KB_ROWS, KB_INDENT, MAX_PLUGS, THIN_REFLECTORS,
+    Rotor, FourthWheel, Reflector, Plugboard, Enigma,
+    FIELD_LABEL, build_field_order, adjust_field, fmt_val,
+    parse_plug_pairs, parse_reflector_pairs,
+)
+
+
+def safe_addstr(win, y, x, text, attr=0):
+    h, w = win.getmaxyx()
+    if y < 0 or y >= h or x >= w or x < 0:
+        return
+    try:
+        win.addstr(y, x, text[: max(0, w - x - 1)], attr)
+    except curses.error:
+        pass
+
+
+def draw_box(win, y, x, h, w, title="", attr=0):
+    safe_addstr(win, y, x, "+" + "-" * (w - 2) + "+", attr)
+    for i in range(1, h - 1):
+        safe_addstr(win, y + i, x, "|", attr)
+        safe_addstr(win, y + i, x + w - 1, "|", attr)
+    safe_addstr(win, y + h - 1, x, "+" + "-" * (w - 2) + "+", attr)
+    if title:
+        safe_addstr(win, y, x + 2, f" {title} ", attr | curses.A_BOLD)
+
+
+def init_colors():
+    curses.start_color()
+    try:
+        curses.use_default_colors()
+        bg = -1
+    except curses.error:
+        bg = curses.COLOR_BLACK
+    curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_WHITE)   # pressed key
+    curses.init_pair(2, curses.COLOR_BLACK, curses.COLOR_YELLOW)  # lit lamp
+    curses.init_pair(3, curses.COLOR_WHITE, curses.COLOR_BLUE)    # title bar
+    curses.init_pair(4, curses.COLOR_CYAN, bg)                    # box borders
+    curses.init_pair(5, curses.COLOR_GREEN, bg)                   # signal path
+    curses.init_pair(6, curses.COLOR_WHITE, curses.COLOR_RED)     # errors
+    curses.init_pair(7, curses.COLOR_MAGENTA, bg)                 # plugboard
+
+
+def draw_keyrow(win, y, x0, row, indent, highlight_letter, attr_on, attr_off):
+    x = x0 + indent * 2
+    for ch in row:
+        attr = attr_on if ch == highlight_letter else attr_off
+        safe_addstr(win, y, x, f"[{ch}]", attr)
+        x += 4
+
+
+def draw_wheel_panel(win, y, x, label, wheel, attr_border, attr_val):
+    draw_box(win, y, x, 7, 14, label, attr_border)
+    safe_addstr(win, y + 1, x + 2, f"Type:{wheel.name:<5}")
+    safe_addstr(win, y + 2, x + 2, f"Ring:{wheel.ring_setting:02d}")
+    eff = ALPHA[(wheel.position - (wheel.ring_setting - 1)) % 26]
+    safe_addstr(win, y + 3, x + 2, f"Eff :{eff}")
+    safe_addstr(win, y + 5, x + 4, f" {wheel.position_letter} ", attr_val | curses.A_BOLD)
+
+
+def group5(s):
+    return " ".join(s[i:i + 5] for i in range(0, len(s), 5))
+
+
+def draw_all(stdscr, machine, state):
+    stdscr.erase()
+    h, w = stdscr.getmaxyx()
+    if h < 34 or w < 108:
+        safe_addstr(stdscr, 0, 0,
+                    f"Terminal too small ({w}x{h}). Please resize to at least 108x34.")
+        stdscr.refresh()
+        return
+
+    c_title = curses.color_pair(3)
+    c_press = curses.color_pair(1) | curses.A_BOLD
+    c_lamp = curses.color_pair(2) | curses.A_BOLD
+    c_dim = curses.A_DIM
+    c_border = curses.color_pair(4)
+    c_sig = curses.color_pair(5)
+    c_plug = curses.color_pair(7)
+
+    safe_addstr(stdscr, 0, 0, " " * w, c_title)
+    safe_addstr(stdscr, 0, 2, "T E R M I G M A  -  Interactive Enigma TUI", c_title | curses.A_BOLD)
+    safe_addstr(stdscr, 0, w - 22, "F1 Help   ESC Quit", c_title)
+
+    ry = 2
+    draw_box(stdscr, ry, 2, 10, 60, "ROTORS", c_border)
+    safe_addstr(stdscr, ry + 1, 4,
+                f"Reflector: {machine.reflector_kind:<8}  ETW: {machine.etw.mode:<10}"
+                f"Plugboard: {'ON' if machine.plugboard_enabled else 'OFF'}")
+    row = ry + 2
+    cols = []
+    if machine.fourth:
+        cols.append(("4TH", machine.fourth))
+    cols += [("LEFT", machine.left), ("MID", machine.middle), ("RIGHT", machine.right)]
+    for i, (label, wheel) in enumerate(cols):
+        draw_wheel_panel(stdscr, row, 4 + i * 14, label, wheel, c_border, c_lamp)
+
+    ky = 13
+    draw_box(stdscr, ky, 2, 6, 46, "KEYBOARD (type A-Z)", c_border)
+    pressed = state.get("last_key")
+    for i, krow in enumerate(KB_ROWS):
+        draw_keyrow(stdscr, ky + 1 + i, 4, krow, KB_INDENT[i], pressed, c_press, 0)
+
+    ly = 20
+    draw_box(stdscr, ly, 2, 6, 46, "LAMPBOARD (lit letter)", c_border)
+    lit = state.get("last_out")
+    for i, krow in enumerate(KB_ROWS):
+        draw_keyrow(stdscr, ly + 1 + i, 4, krow, KB_INDENT[i], lit, c_lamp, c_dim)
+
+    pby = 27
+    draw_box(stdscr, pby, 2, 4, 46, "PLUGBOARD (F3 edit, F2 on/off)", c_border)
+    if not machine.plugboard_enabled:
+        safe_addstr(stdscr, pby + 1, 4, "DISABLED for this model", c_dim)
+    else:
+        pairs = machine.plugboard.pairs_list()
+        ptxt = " ".join(f"{a}{b}" for a, b in pairs) if pairs else "(none)"
+        safe_addstr(stdscr, pby + 1, 4, ptxt[:42], c_plug)
+        safe_addstr(stdscr, pby + 2, 4, f"{len(pairs)}/{MAX_PLUGS} pairs used", c_dim)
+
+    sx = 64
+    sig_h = min(21, h - 3)
+    draw_box(stdscr, 2, sx, sig_h, max(30, w - sx - 2), "SIGNAL PATH (this keypress)", c_border)
+    path = state.get("last_path")
+    if not path:
+        safe_addstr(stdscr, 4, sx + 3, "Press a letter key to see the current flow", c_dim)
+        safe_addstr(stdscr, 5, sx + 3, "through plugboard -> ETW -> rotors ->", c_dim)
+        safe_addstr(stdscr, 6, sx + 3, "reflector -> rotors -> ETW -> plugboard -> lamp.", c_dim)
+    else:
+        for i, (label, val) in enumerate(path):
+            r = 4 + i
+            if r >= 2 + sig_h - 1:
+                break
+            safe_addstr(stdscr, r, sx + 3, f"{label:<24}", c_sig)
+            safe_addstr(stdscr, r, sx + 29, val, c_lamp)
+
+    logy = 2 + sig_h + 1
+    draw_box(stdscr, logy, sx, 9, max(30, w - sx - 2), "MESSAGE LOG", c_border)
+    plain = "".join(p for p, _ in state["log"])
+    cipher = "".join(cp for _, cp in state["log"])
+    inner_w = max(10, w - sx - 6)
+    safe_addstr(stdscr, logy + 1, sx + 3, "Plain :")
+    safe_addstr(stdscr, logy + 2, sx + 3, group5(plain)[-inner_w:])
+    safe_addstr(stdscr, logy + 4, sx + 3, "Cipher:")
+    safe_addstr(stdscr, logy + 5, sx + 3, group5(cipher)[-inner_w:], curses.A_BOLD)
+    letters_only = sum(1 for p, _ in state["log"] if p != "/")
+    safe_addstr(stdscr, logy + 7, sx + 3,
+                f"Count: {letters_only}   Last input: {pressed or '-'}", c_dim)
+
+    fy = h - 2
+    safe_addstr(stdscr, fy, 0, "-" * w, c_dim)
+    safe_addstr(stdscr, fy + 1, 2,
+                "F1 Help  F2 Settings  F3 Plugboard  F4 Reset  F5 Custom UKW  ESC/Q Quit")
+    stdscr.refresh()
+
+
+def flash_error(stdscr, msg):
+    h, w = stdscr.getmaxyx()
+    y = min(h - 4, 32)
+    safe_addstr(stdscr, y, 2, " " * min(len(msg) + 4, max(1, w - 4)))
+    safe_addstr(stdscr, y, 2, f" {msg} ", curses.color_pair(6) | curses.A_BOLD)
+    stdscr.refresh()
+    curses.napms(1200)
+
+
+def draw_help(stdscr):
+    stdscr.erase()
+    lines = [
+        "TERMIGMA - HELP",
+        "",
+        "Simulates the Wehrmacht/Kriegsmarine Enigma family: Enigma I (3 rotors",
+        "from I-V), M3 (3 rotors from I-VIII), and M4 'Shark' (3 rotors from",
+        "I-VIII plus a non-stepping Beta/Gamma 4th wheel and a thin reflector).",
+        "",
+        "Type a letter A-Z to encipher it; the SIGNAL PATH panel shows every",
+        "stage: plugboard -> entry wheel (ETW) -> 3 (or 4) rotors -> reflector",
+        "-> back through the rotors -> ETW -> plugboard -> lamp.",
+        "",
+        "Rotors step automatically every keypress (including the middle-rotor",
+        "double-step) and this cannot be undone, exactly like the real machine.",
+        "",
+        "Controls:",
+        "  A-Z    encipher a letter          SPACE  visual separator only",
+        "  F2     settings: model preset, ETW (military/commercial), plugboard",
+        "         on/off, reflector (B/C/B-thin/C-thin/Custom), movable notches,",
+        "         4th wheel (when a thin reflector is chosen), and all 3 rotors",
+        "         (type / ring / start position). UP/DOWN move, LEFT/RIGHT",
+        "         change, ENTER apply, ESC cancel.",
+        "  F3     plugboard editor - pairs like 'AB CD EF', up to 13 pairs",
+        "  F5     custom (rewirable) reflector editor - needs exactly 13 pairs",
+        "         covering all 26 letters (only used when Reflector = Custom)",
+        "  F4     reset to default settings          ESC/Q  quit",
+        "",
+        "Note: exact wirings for the more exotic commercial/national variants",
+        "(K, D, Swiss-K, Railway, Tirpitz, Norenigma, Sonder, Abwehr G-machines)",
+        "are not included - see data/wiring_tables.json for why. The",
+        "'commercial-style' preset demonstrates the real QWERTZU entry wiring",
+        "and no-plugboard quirk of commercial machines using the Enigma I",
+        "rotor set as a stand-in.",
+        "",
+        "Press any key to return...",
+    ]
+    for i, line in enumerate(lines):
+        safe_addstr(stdscr, 1 + i, 4, line)
+    stdscr.refresh()
+    stdscr.getch()
+
+
+def draw_rotor_settings(stdscr, settings, active_field, field_order):
+    stdscr.erase()
+    safe_addstr(stdscr, 1, 2, "SETTINGS", curses.A_BOLD)
+    safe_addstr(stdscr, 2, 2, "UP/DOWN move   LEFT/RIGHT change   ENTER apply   ESC cancel")
+    for i, field in enumerate(field_order):
+        y = 4 + i
+        attr = curses.A_REVERSE if field == active_field else 0
+        label = FIELD_LABEL[field]
+        val = fmt_val(settings[field])
+        safe_addstr(stdscr, y, 4, f"{label:<20}: < {val:<30} >", attr)
+    safe_addstr(stdscr, 5 + len(field_order), 4,
+                "Note: the three main rotors must all be different types.")
+    stdscr.refresh()
+
+
+def rotor_settings_screen(stdscr, machine):
+    settings = {
+        "model": "Custom",
+        "etw": machine.etw.mode,
+        "plugboard_enabled": machine.plugboard_enabled,
+        "movable_notches": machine.movable_notches,
+        "reflector": machine.reflector_kind,
+        "L_type": machine.left.name, "L_ring": machine.left.ring_setting, "L_pos": machine.left.position_letter,
+        "M_type": machine.middle.name, "M_ring": machine.middle.ring_setting, "M_pos": machine.middle.position_letter,
+        "R_type": machine.right.name, "R_ring": machine.right.ring_setting, "R_pos": machine.right.position_letter,
+        "G_type": machine.fourth.name if machine.fourth else "Beta",
+        "G_ring": machine.fourth.ring_setting if machine.fourth else 1,
+        "G_pos": machine.fourth.position_letter if machine.fourth else "A",
+    }
+    if machine.movable_notches:
+        settings["L_notch"] = sorted(machine.left.notches)[0]
+        settings["M_notch"] = sorted(machine.middle.notches)[0]
+        settings["R_notch"] = sorted(machine.right.notches)[0]
+    else:
+        from .engine import ROTOR_DATA
+        settings["L_notch"] = sorted(ROTOR_DATA[settings["L_type"]]["notches"])[0]
+        settings["M_notch"] = sorted(ROTOR_DATA[settings["M_type"]]["notches"])[0]
+        settings["R_notch"] = sorted(ROTOR_DATA[settings["R_type"]]["notches"])[0]
+
+    idx = 0
+    while True:
+        field_order = build_field_order(settings)
+        idx = idx % len(field_order)
+        draw_rotor_settings(stdscr, settings, field_order[idx], field_order)
+        ch = stdscr.getch()
+        if ch == 27:
+            return
+        elif ch in (10, 13, curses.KEY_ENTER):
+            types = [settings["L_type"], settings["M_type"], settings["R_type"]]
+            if len(set(types)) < 3:
+                flash_error(stdscr, "The three main rotors must be different!")
+                continue
+            notch_over = (None, None, None)
+            if settings["movable_notches"]:
+                notch_over = (settings["L_notch"], settings["M_notch"], settings["R_notch"])
+            machine.left = Rotor(settings["L_type"], settings["L_ring"], settings["L_pos"], notch_over[0])
+            machine.middle = Rotor(settings["M_type"], settings["M_ring"], settings["M_pos"], notch_over[1])
+            machine.right = Rotor(settings["R_type"], settings["R_ring"], settings["R_pos"], notch_over[2])
+            machine.reflector_kind = settings["reflector"]
+            machine.reflector = Reflector(settings["reflector"], machine.custom_reflector_pairs)
+            from .engine import EntryWheel
+            machine.etw = EntryWheel(settings["etw"])
+            machine.plugboard_enabled = settings["plugboard_enabled"]
+            machine.movable_notches = settings["movable_notches"]
+            if settings["reflector"] in THIN_REFLECTORS:
+                machine.fourth = FourthWheel(settings["G_type"], settings["G_ring"], settings["G_pos"])
+            else:
+                machine.fourth = None
+            return
+        elif ch == curses.KEY_UP:
+            idx = (idx - 1) % len(field_order)
+        elif ch == curses.KEY_DOWN:
+            idx = (idx + 1) % len(field_order)
+        elif ch == curses.KEY_LEFT:
+            adjust_field(settings, field_order[idx], -1)
+        elif ch == curses.KEY_RIGHT:
+            adjust_field(settings, field_order[idx], 1)
+
+
+def draw_plugboard_editor(stdscr, buf):
+    stdscr.erase()
+    safe_addstr(stdscr, 1, 2, "PLUGBOARD EDITOR", curses.A_BOLD)
+    safe_addstr(stdscr, 3, 2, "Type letter pairs separated by spaces, e.g.:  AB CD EF")
+    safe_addstr(stdscr, 4, 2, f"(max {MAX_PLUGS} pairs, each letter used at most once)")
+    safe_addstr(stdscr, 6, 2, "> " + buf, curses.A_REVERSE)
+    safe_addstr(stdscr, 8, 2, "ENTER: apply   ESC: cancel   BACKSPACE: delete")
+    stdscr.refresh()
+
+
+def plugboard_screen(stdscr, machine):
+    if not machine.plugboard_enabled:
+        flash_error(stdscr, "This model's plugboard is off - enable it in F2 first.")
+        return
+    buf = " ".join(f"{a}{b}" for a, b in machine.plugboard.pairs_list())
+    curses.curs_set(1)
+    while True:
+        draw_plugboard_editor(stdscr, buf)
+        ch = stdscr.getch()
+        if ch == 27:
+            break
+        elif ch in (10, 13, curses.KEY_ENTER):
+            ok, result = parse_plug_pairs(buf.upper())
+            if ok:
+                machine.plugboard = Plugboard(result)
+                break
+            else:
+                flash_error(stdscr, result)
+        elif ch in (curses.KEY_BACKSPACE, 127, 8):
+            buf = buf[:-1]
+        elif 32 <= ch < 127:
+            c = chr(ch).upper()
+            if c.isalpha() or c == " ":
+                if len(buf) < 45:
+                    buf += c
+    curses.curs_set(0)
+
+
+def draw_reflector_editor(stdscr, buf):
+    stdscr.erase()
+    safe_addstr(stdscr, 1, 2, "CUSTOM REFLECTOR EDITOR (rewirable, like UKW-D)", curses.A_BOLD)
+    safe_addstr(stdscr, 3, 2, "Type exactly 13 pairs covering all 26 letters, e.g.:")
+    safe_addstr(stdscr, 4, 2, "AB CD EF GH IJ KL MN OP QR ST UV WX YZ")
+    safe_addstr(stdscr, 6, 2, "> " + buf, curses.A_REVERSE)
+    safe_addstr(stdscr, 8, 2, "ENTER: apply   ESC: cancel   BACKSPACE: delete")
+    stdscr.refresh()
+
+
+def custom_reflector_screen(stdscr, machine):
+    if machine.reflector_kind != "Custom":
+        flash_error(stdscr, "Set Reflector to 'Custom' in F2 settings first.")
+        return
+    buf = " ".join(f"{a}{b}" for a, b in sorted(machine.custom_reflector_pairs.items()) if a < b)
+    curses.curs_set(1)
+    while True:
+        draw_reflector_editor(stdscr, buf)
+        ch = stdscr.getch()
+        if ch == 27:
+            break
+        elif ch in (10, 13, curses.KEY_ENTER):
+            ok, result = parse_reflector_pairs(buf.upper())
+            if ok:
+                machine.custom_reflector_pairs = result
+                machine.reflector = Reflector("Custom", result)
+                break
+            else:
+                flash_error(stdscr, result)
+        elif ch in (curses.KEY_BACKSPACE, 127, 8):
+            buf = buf[:-1]
+        elif 32 <= ch < 127:
+            c = chr(ch).upper()
+            if c.isalpha() or c == " ":
+                if len(buf) < 60:
+                    buf += c
+    curses.curs_set(0)
+
+
+def run(stdscr):
+    curses.curs_set(0)
+    stdscr.keypad(True)
+    init_colors()
+
+    machine = Enigma()
+    state = {"log": [], "last_path": [], "last_key": None, "last_out": None}
+
+    while True:
+        draw_all(stdscr, machine, state)
+        ch = stdscr.getch()
+
+        if ch in (27, ord("q"), ord("Q")):
+            break
+        elif ch == curses.KEY_F1:
+            draw_help(stdscr)
+        elif ch == curses.KEY_F2:
+            rotor_settings_screen(stdscr, machine)
+        elif ch == curses.KEY_F3:
+            plugboard_screen(stdscr, machine)
+        elif ch == curses.KEY_F4:
+            machine = Enigma()
+            state = {"log": [], "last_path": [], "last_key": None, "last_out": None}
+        elif ch == curses.KEY_F5:
+            custom_reflector_screen(stdscr, machine)
+        elif ch == 32:
+            state["log"].append(("/", "/"))
+            state["last_key"] = None
+            state["last_out"] = None
+        elif 65 <= ch <= 90 or 97 <= ch <= 122:
+            letter = chr(ch).upper()
+            out, path = machine.encode_letter(letter)
+            state["last_key"] = letter
+            state["last_out"] = out
+            state["last_path"] = path
+            state["log"].append((letter, out))
+            if len(state["log"]) > 500:
+                state["log"] = state["log"][-500:]
+
+
+def main():
+    curses.wrapper(run)
+
+
+if __name__ == "__main__":
+    main()

termigma-1.0.0.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: termigma
+Version: 1.0.0
+Summary: An interactive terminal (TUI) Enigma machine simulator
+Author: Rex Ackermann
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/rexackermann/termigma
+Project-URL: Repository, https://github.com/rexackermann/termigma
+Project-URL: Issues, https://github.com/rexackermann/termigma/issues
+Project-URL: Changelog, https://github.com/rexackermann/termigma/blob/main/CHANGELOG.md
+Project-URL: Reference simulator, https://people.physik.hu-berlin.de/~palloks/js/enigma/enigma-u_v262_en.html
+Keywords: enigma,cipher,cryptography,tui,curses,terminal,wwii,history
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console :: Curses
+Classifier: Intended Audience :: Education
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Games/Entertainment :: Simulation
+Classifier: Topic :: Education
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: windows-curses; platform_system == "Windows"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# termigma
+
+A terminal simulator of the Wehrmacht/Kriegsmarine Enigma machine — rotors,
+plugboard, lampboard, and a live signal-path monitor, all in your terminal.
+
+```
+pip install termigma
+termigma
+```
+
+No dependencies on Linux/macOS (just the standard library's `curses`). On
+Windows, `pip install termigma` pulls in `windows-curses` automatically.
+
+## What it does
+
+You type a letter, it lights up on the lampboard, and the **signal path**
+panel shows exactly how it got there: plugboard → entry wheel → through each
+rotor → reflector → back through the rotors → entry wheel → plugboard → lamp.
+The rotors step on every keypress, including the historically correct
+middle-rotor "double step," and there's no undo — same as the real machine.
+
+It covers three points in the machine's history:
+
+- **Enigma I** (Army/Air Force) — 3 rotors chosen from I–V
+- **M3** (Army/Navy) — 3 rotors chosen from I–VIII
+- **M4 "Shark"** (U-boats) — adds a fourth, non-stepping Beta/Gamma wheel and
+  a thin reflector
+
+Plus a **commercial-style** mode that demonstrates the real quirk of
+commercial Enigmas: no plugboard, and an entry wheel wired in keyboard
+(QWERTZU) order instead of straight A–Z.
+
+## Controls
+
+| Key | Does |
+|---|---|
+| `A`–`Z` | Encipher a letter |
+| `Space` | Visual separator (doesn't step the rotors) |
+| `F1` | Help |
+| `F2` | Settings — model preset, ETW mode, plugboard on/off, reflector, movable notches, 4th wheel, all three rotors |
+| `F3` | Plugboard editor |
+| `F5` | Custom rewirable reflector editor (needs Reflector = Custom) |
+| `F4` | Reset to defaults |
+| `Esc` / `Q` | Quit |
+
+Terminal needs to be at least 108×34 or it'll ask you to resize.
+
+## Why it looks the way it does
+
+Real Enigmas didn't have an undo button, a Ctrl-Z, or a way to peek inside
+while it ran. This tries to keep that feel — the rotors always turn, the
+plugboard is genuinely optional depending on which model you pick — while
+also showing you the one thing the real machine couldn't: what's happening
+electrically at every stage, for every keystroke.
+
+## Project layout
+
+```
+src/termigma/engine.py   the machine itself — no curses, fully unit-testable
+src/termigma/tui.py      curses rendering and the input loop
+tests/test_engine.py     pytest suite (reciprocity checks, stepping, etc.)
+data/wiring_tables.json  the historical wiring data, with sourcing notes
+```
+
+## Running from source
+
+```
+git clone https://github.com/rexackermann/termigma
+cd termigma
+pip install -e ".[dev]"
+pytest
+termigma
+```
+
+## Accuracy
+
+The rotor and reflector wiring (rotors I–VIII, the M4 Beta/Gamma wheels, and
+reflectors B/C plus their thin M4 counterparts) is the widely published
+historical data, checked here against a known reference test vector and a
+set of round-trip (reciprocity) tests — see `tests/test_engine.py`.
+
+What's **not** included: exact wiring for the more exotic commercial and
+national variants (Enigma K, Enigma D, Swiss-K, Railway, Tirpitz, Norenigma,
+Sonder-Enigma, the Abwehr G-machines). This project doesn't have confidently
+sourced wiring for those, and a guess dressed up as fact is worse than an
+honest gap. The "commercial-style" preset demonstrates the real no-plugboard
+/ QWERTZU-entry-wheel behavior of commercial machines but reuses the Enigma I
+rotor set rather than true K/D rotors. See `data/wiring_tables.json` for the
+full sourcing note, and cross-check the Crypto Museum's Enigma pages if you
+need one of those specific machines to be byte-exact.
+
+## Credits
+
+- Inspired by Daniel Palloks' [Universal Enigma](https://people.physik.hu-berlin.de/~palloks/js/enigma/enigma-u_v262_en.html),
+  a browser-based simulator covering a much wider range of historical
+  Enigma variants than this project attempts.
+- Enigma explainer video: https://www.youtube.com/watch?v=JsBZOcqZerk — for inspiration.
+- Built with help from [Claude](https://claude.ai) (Anthropic).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

termigma-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+termigma/__init__.py,sha256=7qibzk03V2ookkUXN_dSpZMILxY0bA4mTo5ZvoETfB0,154
+termigma/__main__.py,sha256=RHyE9mNpvuVsj3mMvjuuDh7TjxHzLE0DppyxR_-Td0o,61
+termigma/engine.py,sha256=x6EhdLeWFHHQaOfsYdp3KymqK9xszjkieB05UbecyPQ,14499
+termigma/tui.py,sha256=us91FmYnx1iKIdkvQ2UFjujMV-PV1vtfxhQouExueRo,17219
+termigma-1.0.0.dist-info/licenses/LICENSE,sha256=WxWOtff7tYX_f8A_q-uOJj_OAFUnqh_AW1zdKjG9u4U,1070
+termigma-1.0.0.dist-info/METADATA,sha256=LpE-GQmK2_hpYD6waDMRBuTFhI_Jhbs9K8ElploqG9I,5205
+termigma-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+termigma-1.0.0.dist-info/entry_points.txt,sha256=eVfdT6PtORuzEoKwbM656dEe-cJXl69wE_2A5c0i3XE,47
+termigma-1.0.0.dist-info/top_level.txt,sha256=F652UW-vzCk1u3I6_i_z1F37isZ1XQ4B_ZbV2DwK2I4,9
+termigma-1.0.0.dist-info/RECORD,,

termigma-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

termigma-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+termigma = termigma.tui:main

termigma-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rex Ackermann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

termigma-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+termigma