Upload folder using huggingface_hub

main.py

@@ -1,118 +1,85 @@
-# 导入所需的库
-from pycipher import SimpleSubstitution as SimpleSub
 import random
-import re
-from ngram_score import ngram_score
-import proability
 import gradio as gr
+from ngram_score import ngram_score
+
+
+def get_keydict(key_dict, current_key, original_alphabet):
+    for i in range(len(current_key)):
+        key_dict[current_key[i]] = original_alphabet[i]  # 这是将当前的密文进行映射
+    return key_dict
+
+
+def exchange(mydict, message):
+    message = list(message)
+    cnt = 0
+    for i in message:
+        if i in mydict:
+            message[cnt] = mydict[i]
+        cnt = cnt + 1
+    return "".join(message)
+
+
+def solve_cipher(ciphertext):
+    S_new = ciphertext.replace(" ", "")
+    S_new = S_new.replace(",", "")
+    S_new = S_new.replace("-", "")
+    S_new = S_new.replace(".", "")
+    # 参数初始化
+    m_message = S_new.upper()  # 这是全部改变为大写的密文
+    current_key = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')  # 这是当前的密文
+    original_alphabet = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
+    key_dict = dict()  # 这是一个字典，用来将字母映射到上面字母表上去
+    fitness = ngram_score('english_quadgrams.txt')
+
+    last_score = -2 ** 31
+    current_max_score = -2 ** 31
+    generation = 0  # generation就是迭代的数量
+
+    best_plaintext = ""
+
+    while generation < 10:
+        # 上面是迭代最高次数，一般10以内就能出结果
+        generation = generation + 1
+
+        # 随机改变顺序
+        random.shuffle(current_key)
+        key_dict = get_keydict(key_dict, current_key, original_alphabet)  # 获得明密文映射
+        last_score = fitness.score(exchange(key_dict, m_message))  # 计算适应度
 
-# 全局变量，避免重复加载大文件
-_fitness = None
-
-def get_fitness():
-    global _fitness
-    if _fitness is None:
-        print("Loading quadgrams data...")
-        _fitness = ngram_score('quadgrams.txt')
-        print("Quadgrams data loaded successfully.")
-    return _fitness
-
-def decrypt_text_internal(ciphertext):
-    fitness = get_fitness()
-    ctext = re.sub('[^A-Z]', '', ciphertext.upper())
-    maxkey = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
-    maxscore = -99e9
-    parentscore, parentkey = maxscore, maxkey[:]
-    
-    i = 0
-    # 进一步减少迭代次数以加快响应速度
-    while i < 500:  # 减少迭代次数
-        i = i + 1
-        random.shuffle(parentkey)
-        deciphered = SimpleSub(parentkey).decipher(ctext)
-        parentscore = fitness.score(deciphered)
         count = 0
-        while count < 500:  # 减少内部迭代次数
+        while count < 1000:
             a = random.randint(0, 25)
             b = random.randint(0, 25)
-            child = parentkey[:]
-            child[a], child[b] = child[b], child[a]
-            deciphered = SimpleSub(child).decipher(ctext)
-            score = fitness.score(deciphered)
-            if score > parentscore:
-                parentscore = score
-                parentkey = child[:]
+            # 随机交换并进行比较
+            child_current_key = current_key[:]
+            child_current_key[a], child_current_key[b] = child_current_key[b], child_current_key[a]
+
+            child_key_dict = dict()
+            child_key_dict = get_keydict(child_key_dict, child_current_key, original_alphabet)
+            score = fitness.score(exchange(child_key_dict, m_message))
+            # 说明新的key_dict更高效
+            if score > last_score:
+                last_score = score
+                current_key = child_current_key
                 count = 0
             count = count + 1
-        if parentscore > maxscore:
-            maxscore, maxkey = parentscore, parentkey[:]
-            ss = SimpleSub(maxkey)
-            plaintext = ss.decipher(ctext)
-            plaintext1 = add_punctuation_and_spaces(ciphertext, plaintext)
-            # In a web context, we return the first good result.
-            # The original loop was infinite, which is not suitable for a server.
-            return plaintext1
-    # Fallback if no good solution is found within the iteration limit
-    ss = SimpleSub(maxkey)
-    plaintext = ss.decipher(ctext)
-    return add_punctuation_and_spaces(ciphertext, plaintext)
-
-
-def output(string1, dic, string2):
-    modified_string1 = list(string1)
-    modified_string2 = list(string2)
-    for i in range(len(string1)):
-        if modified_string1[i] in dic and modified_string2[i] != ' ':
-            modified_string2[i] = dic[modified_string1[i]]
-    modified_string2 = ''.join(modified_string2)
-    return modified_string2
-
-def add_punctuation_and_spaces(ciphertext, plaintext):
-    result = ""
-    j = 0
-    for i in range(len(ciphertext)):
-        if not ciphertext[i].isalpha():
-            result += ciphertext[i]
-        else:
-            if ciphertext[i].islower():
-                result += plaintext[j].lower()
-            else:
-                # The original code had a bug here, always making it lowercase.
-                # This is a guess at the intended behavior.
-                result += plaintext[j] 
-            j += 1
-    return result
-
-def decrypt_interface(ciphertext, key):
-    """
-    This is the main function that will be exposed through the Gradio interface.
-    """
-    if not ciphertext:
-        return "Please enter some ciphertext."
-        
-    plaintext = decrypt_text_internal(ciphertext)
-    
-    if key:
-        try:
-            key_dic = proability.read_key(key)
-            plaintext = output(ciphertext, key_dic, plaintext)
-        except Exception as e:
-            return f"Error processing key: {e}. Please check the key format (e.g., a=B c=D)."
-            
-    return plaintext
-
-# Create the Gradio interface
+
+        # 输出结果
+        if last_score > current_max_score:
+            current_max_score = last_score
+            maxkey = current_key
+            key_dict = get_keydict(key_dict, current_key, original_alphabet)
+            best_plaintext = exchange(key_dict, ciphertext.upper()).lower()
+
+    return best_plaintext
+
 iface = gr.Interface(
-    fn=decrypt_interface,
-    inputs=[
-        gr.Textbox(lines=10, label="Ciphertext", placeholder="Enter the text to decrypt..."),
-        gr.Textbox(lines=2, label="Known Key Mappings (Optional)", placeholder="e.g., a=B c=D")
-    ],
-    outputs=gr.Textbox(lines=10, label="Plaintext"),
-    title="Simple Substitution Cipher Decryptor",
-    description="An automatic decryption tool for simple substitution ciphers. You can optionally provide known letter mappings to improve accuracy."
+    fn=solve_cipher,
+    inputs=gr.Textbox(lines=10, placeholder="Enter ciphertext here..."),
+    outputs="text",
+    title="Substitution Cipher Solver",
+    description="Enter the ciphertext and see the decrypted plaintext."
 )
 
-# Launch the app
 if __name__ == "__main__":
-    iface.launch(server_name="0.0.0.0", server_port=7860)
+    iface.launch()

ngram_score.py

@@ -3,27 +3,26 @@ from math import log10
 
 class ngram_score(object):
     def __init__(self, ngramfile, sep=' '):
-        '''加载包含ngrams和计数的文件,计算对数概率'''
-        self.ngrams = {}  # 存储ngrams及其计数的字典
-        with open(ngramfile, 'r') as file:
-            for line in file:
-                key, count = line.split(sep)  # 将行按分隔符分割为ngram和计数
-                self.ngrams[key] = int(count)  # 将ngram及其计数存储到字典中
-        self.L = len(key)  # ngram的长度
-        self.N = sum(self.ngrams.values())  # 所有ngrams的总计数
-        # 计算对数概率
+        ''' load a file containing ngrams and counts, calculate log probabilities '''
+        self.ngrams = {}
+        for line in open(ngramfile):
+            key, count = line.split(sep)
+            self.ngrams[key] = int(count)
+        self.L = len(key)
+        self.N = sum(self.ngrams.values())
+        # calculate log probabilities
         for key in self.ngrams.keys():
-            self.ngrams[key] = log10(
-                float(self.ngrams[key]) / self.N)  # 计算ngram的对数概率
-        self.floor = log10(0.01 / self.N)  # 用于处理未知的ngrams的默认对数概率阈值
+            self.ngrams[key] = log10(float(self.ngrams[key]) / self.N)
+        self.floor = log10(0.01 / self.N)
 
     def score(self, text):
-        '''计算文本的分数'''
+        ''' compute the score of text '''
         score = 0
-        ngrams = self.ngrams.__getitem__  # 获取ngrams的对数概率函数
+        ngrams = self.ngrams.__getitem__
         for i in range(len(text) - self.L + 1):
-            if text[i:i+self.L] in self.ngrams:
-                score += ngrams(text[i:i+self.L])  # 若ngrams在文本中存在，则加上对数概率
+            if text[i:i + self.L] in self.ngrams:
+                score += ngrams(text[i:i + self.L])
             else:
-                score += self.floor  # 若ngrams在文本中不存在，则加上默认对数概率阈值
+                score += self.floor
         return score
+

requirements.txt

@@ -1,2 +1,2 @@
 pycipher
-gradio>=4.0.0
+gradio