1
from pathlib import Path
2
import random
3
import math
4
from collections import Counter
5

6
from wordfreq import zipf_frequency
7

8
def load_ciphertext(path):
9
    return Path(path).read_text().splitlines()
10

11
def build_quadgram_model(corpus_paths):
12
    corpus = ""
13
    for path in corpus_paths:
14
        try:
15
            corpus += Path(path).read_text().lower()
16
        except Exception:
17
            pass
18
    corpus = "".join(ch for ch in corpus if ch.isalpha() or ch == " ")
19
    quad = Counter()
20
    for i in range(len(corpus) - 3):
21
        q = corpus[i : i + 4]
22
        if " " in q:
23
            continue
24
        quad[q] += 1
25
    total = sum(quad.values()) or 1
26
    quad_log = {k: math.log10(v / total) for k, v in quad.items()}
27
    floor = math.log10(0.01 / total)
28
    return quad_log, floor
29

30
def score_text(pt, quad_log, floor):
31
    score = 0.0
32
    words = pt.split()
33
    for w in words:
34
        if len(w) >= 2:
35
            score += zipf_frequency(w, "en")
36
    for i in range(len(pt) - 3):
37
        q = pt[i : i + 4]
38
        if " " in q:
39
            continue
40
        score += quad_log.get(q, floor)
41
    return score
42

43
def decrypt(text, keymap):
44
    alphabet = "abcdefghijklmnopqrstuvwxyz"
45
    out = []
46
    for ch in text:
47
        if ch in alphabet:
48
            out.append(keymap[ch])
49
        else:
50
            out.append(ch)
51
    return "".join(out)
52

53
def make_initial_key(cipher_letters):
54
    alphabet = "abcdefghijklmnopqrstuvwxyz"
55
    english_freq_order = "etaoinshrdlucmfwypvbgkjqxz"
56
    freq = Counter(ch for ch in cipher_letters if ch.isalpha())
57
    cipher_order = "".join([c for c, _ in freq.most_common()])
58
    for c in alphabet:
59
        if c not in cipher_order:
60
            cipher_order += c
61
    key = {c: english_freq_order[i] for i, c in enumerate(cipher_order)}
62
    return key
63

64
def hillclimb(cipher_text, quad_log, floor, restarts=6, iterations=12000, seed=0):
65
    random.seed(seed)
66
    alphabet = "abcdefghijklmnopqrstuvwxyz"
67
    best_key = None
68
    best_score = -1e18
69
    best_plain = None
70

71
    cipher_letters = "".join(ch for ch in cipher_text if ch.isalpha() or ch == " ")
72

73
    for r in range(restarts):
74
        key = make_initial_key(cipher_letters)
75
        letters = list(alphabet)
76
        for _ in range(60):
77
            a, b = random.sample(letters, 2)
78
            key[a], key[b] = key[b], key[a]
79

80
        cur_key = key.copy()
81
        cur_plain = decrypt(cipher_letters, cur_key)
82
        cur_score = score_text(cur_plain, quad_log, floor)
83

84
        for T in [20.0, 10.0, 5.0, 2.0, 1.0, 0.5]:
85
            for _ in range(iterations // 8):
86
                c1, c2 = random.sample(letters, 2)
87
                cur_key[c1], cur_key[c2] = cur_key[c2], cur_key[c1]
88
                new_plain = decrypt(cipher_letters, cur_key)
89
                new_score = score_text(new_plain, quad_log, floor)
90
                if new_score > cur_score or random.random() < math.exp(
91
                    (new_score - cur_score) / T
92
                ):
93
                    cur_score = new_score
94
                else:
95
                    cur_key[c1], cur_key[c2] = cur_key[c2], cur_key[c1]
96

97
        if cur_score > best_score:
98
            best_score = cur_score
99
            best_key = cur_key.copy()
100
            best_plain = decrypt(cipher_letters, best_key)
101

102
        print(
103
            f"restart {r + 1}/{restarts}: score {cur_score:.2f} best {best_score:.2f}"
104
        )
105

106
    return best_key, best_score, best_plain
107

108
def decrypt_lines(lines, keymap):
109
    alphabet = "abcdefghijklmnopqrstuvwxyz"
110
    out_lines = []
111
    for line in lines:
112
        out = []
113
        for ch in line:
114
            low = ch.lower()
115
            if low in alphabet:
116
                dec = keymap[low]
117
                if ch.isupper():
118
                    dec = dec.upper()
119
                out.append(dec)
120
            else:
121
                out.append(ch)
122
        out_lines.append("".join(out))
123
    return out_lines
124

125
def main():
126
    lines = load_ciphertext("/home/LIGHT/Downloads/texsaw_idiosyncratic_french/ciphertext.txt")
127
    cipher_text = " ".join(lines).lower()
128
    cipher_text = "".join(ch for ch in cipher_text if ch.isalpha() or ch == " ")
129

130
    quad_log, floor = build_quadgram_model(
131
        [
132
            "/usr/share/dict/words",
133
            "/home/LIGHT/Downloads/Adventure.txt",
134
        ]
135
    )
136

137
    key, score, plain = hillclimb(
138
        cipher_text, quad_log, floor, restarts=6, iterations=12000, seed=3
139
    )
140
    print("best score", score)
141
    print("best plain snippet:")
142
    print(plain[:600])
143
    print("key:")
144
    print(" ".join(f"{c}->{key[c]}" for c in "abcdefghijklmnopqrstuvwxyz"))
145

146
    dec_lines = decrypt_lines(lines, key)
147
    print("--- decrypted full file ---")
148
    for line in dec_lines:
149
        print(line)
150

151
if __name__ == "__main__":
152
    main()

1
from duckduckgo_search import DDGS
2

3
def main():
4
    quote = (
5
        "Noon rings out. A wasp, making an ominous sound, a sound akin to a klaxon "
6
        "or a tocsin, flits about. Augustus, who has had a bad night, sits up blinking "
7
        "and purblind."
8
    )
9
    with DDGS() as ddgs:
10
        results = ddgs.text(f'"{quote}"', max_results=12)
11
        for i, r in enumerate(results, start=1):
12
            print(f"{i}. {r.get('title')}")
13
            print(r.get("href"))
14
            print(r.get("body"))
15
            print("-")
16

17
if __name__ == "__main__":
18
    main()

1
import urllib.request
2

3
def main():
4
    url = "http://www-control.eng.cam.ac.uk/hu/Perec.html"
5
    with urllib.request.urlopen(url, timeout=20) as resp:
6
        data = resp.read().decode("utf-8", errors="replace")
7
    print(data)
8

9
if __name__ == "__main__":
10
    main()