tebarius/Mysteryhelfer-web
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

anagramm wortsuche remorse t9

Browse Source
This commit is contained in:
Martin Kayser
2025-07-23 23:40:25 +02:00
parent 8074b04ab7
commit a2ee24bf1d
3 changed files with 280 additions and 350 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
app/app.py
View File

@@ -158,15 +158,35 @@ def auswahl_verarbeiten():
elif auswahl == "Kreiszahl PI":
st.session_state.output_text = tools.pi_suche(text)
st.session_state.map_data = None
elif auswahl == "REPLACE":
st.session_state.output_text = tools.REPLACE(text)
elif auswahl == "Anagrammsuche-DE":
st.session_state.output_text = tools.anagramm_suche_de(text)
st.session_state.map_data = None
elif auswahl == "Anagrammsuche-EN":
st.session_state.output_text = tools.anagramm_suche_en(text)
st.session_state.map_data = None
elif auswahl == "Wortsuche-DE":
st.session_state.output_text = tools.wortsuche_de(text)
st.session_state.map_data = None
elif auswahl == "Wortsuche-EN":
st.session_state.output_text = tools.wortsuche_en(text)
st.session_state.map_data = None
elif auswahl == "Re-Morse-DE":
st.session_state.output_text = tools.remorse_de(text)
st.session_state.map_data = None
elif auswahl == "Re-Morse-EN":
st.session_state.output_text = tools.remorse_en(text)
st.session_state.map_data = None
elif auswahl == "T9-DE dekodieren":
st.session_state.output_text = tools.t9_de(text)
st.session_state.map_data = None
elif auswahl == "T9-EN dekodieren":
st.session_state.output_text = tools.t9_en(text)
st.session_state.map_data = None
elif auswahl == "REPLACE":
st.session_state.output_text = tools.REPLACE(text)
st.session_state.map_data = None
elif auswahl == "Dummy mit Karte":
output, mapd = tools.funktion_mit_karte(text, additional_parameter)
st.session_state.output_text = output
@@ -190,7 +210,6 @@ input_text = st.text_area('Gib deinen Text hier ein und wähle eine Funktion im
# --- Sidebar: Buttons selektieren und Aktion setzen ---
option = st.sidebar.radio("hidden_label",
options=("Wähle eine Funktion",
"Dummy mit Karte",
"Cesarchiffre (all)",
"BW,BWW,... ermitteln",
"Buchstabenwert->Text",
@@ -233,12 +252,16 @@ option = st.sidebar.radio("hidden_label",
"Nak-Nak -> Text",
"Navajo -> Text",
"Kreiszahl PI",
"Anagrammsuche-DE",
"Anagrammsuche-EN",
"Wortsuche-DE",
"Wortsuche-EN",
"Re-Morse-DE",
"Re-Morse-EN",
"T9-DE dekodieren",
"T9-EN dekodieren",
"",
"",
"",
"",
"",
"",
"Dummy mit Karte",
),
key='option',
on_change=auswahl_verarbeiten,

106
app/helper.py
View File

@@ -179,3 +179,109 @@ def unkennify(text):
if i < n_len:
decoded = decoded + text[i:]
return decoded
def remorse_generate_morsede():
alphabet = {'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.', 'G': '--.',
'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..', 'M': '--', 'N': '-.',
'O': '---', 'P': '.--.', 'Q': '--.-', 'R': '.-.', 'S': '...', 'T': '-', 'U': '..-',
'V': '...-', 'W': '.--', 'X': '-..-', 'Y': '-.--', 'Z': '--..', '1': '.----',
'2': '..---', '3': '...--', '4': '....-', '5': '.....', '6': '-....', '7': '--...',
'8': '---..', '9': '----.', '0': '-----', 'Ñ': '--.--', 'É': '..-..', 'È': '.-..-',
'À': '.--.-', 'Ü': '..--', 'Ö': '---.', 'Ä': '.-.-', '_': '..--.-', '@': '.--.-.',
'?': '..--..', '=': '-...-', ';': '-.-.-.', ':': '---...', '/': '-..-.',
'.': '.-.-.-', '-': '-....-', ',': '--..--', '+': '.-.-.', ')': '-.--.-',
'(': '-.--.', "'": '.----.', 'SS': '...--..'}
with open("./data/morse-de.dic", "w", encoding="iso-8859-1") as ofile:
for symbol, morse in alphabet.items():
ofile.write(f"{morse},{symbol}\n")
with open("./data/german.dic", "r", encoding="iso-8859-1") as infile:
for line in infile:
word = line.strip()
try:
morse_word = ''.join(alphabet[char.upper()] for char in word)
ofile.write(f"{morse_word},{word}\n")
except KeyError:
# Überspringe Wörter mit nicht-unterstützten Zeichen
continue
infile.close()
ofile.close()
def t9_generate_t9de():
alphabet = {'A': '2', 'B': '2', 'C': '2', 'D': '3', 'E': '3', 'F': '3', 'G': '4',
'H': '4', 'I': '4', 'J': '5', 'K': '5', 'L': '5', 'M': '6', 'N': '6',
'O': '6', 'P': '7', 'Q': '7', 'R': '7', 'S': '7', 'T': '8', 'U': '8',
'V': '8', 'W': '9', 'X': '9', 'Y': '9', 'Z': '9', '1': '1', '2': '2',
'3': '3', '4': '4', '5': '5', '6': '6', '7': '7', '8': '8', '9': '9',
'0': '0', 'Ñ': '6', 'É': '3', 'È': '3', 'À': '2', 'Ü': '8', 'Ö': '6',
'Ä': '2', '@': '1', '?': '1', '=': '0', ':': '1', '/': '1', '.': '1',
'-': '1', ',': '1', '+': '0', ')': '1', '(': '1', 'SS': '7'}
ofile = open("./data/t9-de.dic", "a", encoding="iso-8859-15")
file = open("./data/german.dic", "r", encoding="iso-8859-15")
for zeile in file:
omsg = ""
zeile = zeile.rstrip()
try:
for char in zeile:
omsg = omsg + alphabet[char.upper()]
except KeyError:
continue
else:
ofile.write(omsg + "," + zeile + "\n")
file.close()
ofile.close()
def remorse_germandic(eingabetext):
alphabet = {'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.', 'G': '--.',
'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..', 'M': '--', 'N': '-.',
'O': '---', 'P': '.--.', 'Q': '--.-', 'R': '.-.', 'S': '...', 'T': '-', 'U': '..-',
'V': '...-', 'W': '.--', 'X': '-..-', 'Y': '-.--', 'Z': '--..', '1': '.----',
'2': '..---', '3': '...--', '4': '....-', '5': '.....', '6': '-....', '7': '--...',
'8': '---..', '9': '----.', '0': '-----', 'Ñ': '--.--', 'É': '..-..', 'È': '.-..-',
'À': '.--.-', 'Ü': '..--', 'Ö': '---.', 'Ä': '.-.-', '_': '..--.-', '@': '.--.-.',
'?': '..--..', '=': '-...-', ';': '-.-.-.', ':': '---...', '/': '-..-.',
'.': '.-.-.-', '-': '-....-', ',': '--..--', '+': '.-.-.', ')': '-.--.-',
'(': '-.--.', "'": '.----.', 'SS': '...--..'}
ualphabet = {v: k for k, v in alphabet.items()}
ualphabet["...--.."] = "ß"
eingabetext = eingabetext.rstrip()
wbfile = open("./data/german.dic", "r", encoding="iso-8859-15")
ausgabetext = "_der eingegebene Morsecode kann für folgendes stehen:_ \n"
if eingabetext in ualphabet:
ausgabetext += ualphabet[eingabetext] + " \n"
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
mzeile = ""
try:
for char in zeile:
mzeile += alphabet[char.upper()]
except KeyError:
continue
if eingabetext == mzeile:
ausgabetext += zeile + " \n"
wbfile.close()
return ausgabetext
def t9_germandic(eingabetext):
alphabet = {'A': '2', 'B': '2', 'C': '2', 'D': '3', 'E': '3', 'F': '3', 'G': '4',
'H': '4', 'I': '4', 'J': '5', 'K': '5', 'L': '5', 'M': '6', 'N': '6',
'O': '6', 'P': '7', 'Q': '7', 'R': '7', 'S': '7', 'T': '8', 'U': '8',
'V': '8', 'W': '9', 'X': '9', 'Y': '9', 'Z': '9', '1': '1', '2': '2',
'3': '3', '4': '4', '5': '5', '6': '6', '7': '7', '8': '8', '9': '9',
'0': '0', 'Ñ': '6', 'É': '3', 'È': '3', 'À': '2', 'Ü': '8', 'Ö': '6',
'Ä': '2', '@': '1', '?': '1', '=': '0', ':': '1', '/': '1', '.': '1',
'-': '1', ',': '1', '+': '0', ')': '1', '(': '1', 'SS': '7'}
eingabetext = eingabetext.rstrip()
wbfile = open("./data/german.dic", "r", encoding="iso-8859-15")
ausgabetext = "_der eingegebene T9-Code kann für folgendes stehen:_ \n"
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
mzeile = ""
try:
for char in zeile:
mzeile += alphabet[char.upper()]
except KeyError:
continue
if eingabetext == mzeile:
ausgabetext += zeile + " \n"
wbfile.close()
return ausgabetext

481
app/tools.py
View File

@@ -1451,69 +1451,81 @@ def pi_suche(eingabetext):
f'{pistr[pos:pos + 20]}...')
return ausgabetext
'''
def anagramm_suche_de():
hilfetext = """HILFE: [Anagrammsuche mit Wörterbuch]
Diese Funktion benutzt eine deutsche Wörterbuchdatei
vom Project https://sourceforge.net/projects/germandict um
zu überprüfen ob sich unter Verwendung aller eingegebenen
Buchstaben Wörter bilden lassen, welche im Wörtebuch vorkommen.
"""
eingabetext = Eingabe.get(1.0, END)
def anagramm_suche_de(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
return ("### Anagrammsuche mit Wörterbuch\n"
"Diese Funktion benutzt eine deutsche Wörterbuchdatei vom Project "
"https://sourceforge.net/projects/germandict um zu überprüfen ob sich unter Verwendung __aller__ "
"eingegebenen Buchstaben Wörter bilden lassen, welche im Wörterbuch vorkommen.")
else:
try:
wbfile = open("./data/german.dic", "r",
encoding="iso-8859-15") # german.dic von https://sourceforge.net/projects/germandict/
except FileNotFoundError:
Ausgabe.insert(1.0, hilfetext + "\n")
return "Leider konnte die Wörterbuchdatei nicht geladen werden."
else:
eingabezaehl = wortzaehl(eingabetext)
Ausgabe.insert(1.0, "\n")
eingabezaehl = helper.wortzaehl(eingabetext)
ausgabetext = "_gefundene Anagramme:_ \n"
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
if eingabetext.upper() == zeile.upper():
continue
if len(eingabetext) != len(zeile):
continue
if eingabezaehl == wortzaehl(zeile):
Ausgabe.insert(1.0, zeile + "\n")
if eingabezaehl == helper.wortzaehl(zeile):
ausgabetext += zeile + " \n"
wbfile.close()
Ausgabe.insert(1.0, "gefundene Anagramme:\n", "bu")
return ausgabetext
def wortsuche_de():
hilfetext = """HILFE: [Wortsuche mit Wörterbuch]
Wer kennt es nicht? Man sucht ein Wort mit einer bestimmten
Anzahl an Buchstaben und weiß aber z.B. nur den Anfangsbuchstaben
und die letzten 3 Buchstaben. Hierbei soll diese Funktion helfen.
Unbekannte Buchstaben werden dabei einfach durch * ersetzt.
Klein-/Großschreibung in der Eingabe wird dabei ignoriert.
Beispiel:
Ge*ca**i** -> Geocaching
ge*ca**i** -> Geocaching
T*****dose -> Tupperdose, Tabaksdose
Da diese Funktion die deutsche Wörterbuchdatei german.dic
vom Project https://sourceforge.net/projects/germandict benutzt
muß sich natürlich die Datei german.dic im Unterverzeichnis "data"
befinden.
"""
eingabetext = Eingabe.get(1.0, END)
def anagramm_suche_en(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
return ("### Anagrammsuche mit Wörterbuch EN\n"
"Diese Funktion benutzt die englische Wörterliste en_US-large.txt vom Project "
"https://sourceforge.net/projects/wordlist um zu überprüfen ob sich unter Verwendung aller "
"eingegebenen Buchstaben Wörter bilden lassen, welche im Wörterbuch vorkommen. Dieses Wörterbuch "
"kennt übrigens auch viele Wörter mit Apostroph wie z.B. say's.")
else:
try:
wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
except FileNotFoundError:
return "Leider konnte die Wörterbuchdatei nicht geladen werden."
else:
eingabezaehl = helper.wortzaehl(eingabetext)
ausgabetext = "_gefundene Anagramme:_ \n"
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
if eingabetext.upper() == zeile.upper():
continue
if len(eingabetext) != len(zeile):
continue
if eingabezaehl == helper.wortzaehl(zeile):
ausgabetext += zeile + " \n"
wbfile.close()
return ausgabetext
def wortsuche_de(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return ("### Wortsuche mit Wörterbuch\n"
"Wer kennt es nicht? Man sucht ein Wort mit einer bestimmten Anzahl an Buchstaben und weiß aber z.B. "
"nur den Anfangsbuchstaben und die letzten 3 Buchstaben. Hierbei soll diese Funktion helfen. "
"Unbekannte Buchstaben werden dabei einfach durch * ersetzt. Klein-/Großschreibung in der Eingabe "
"wird dabei ignoriert. \n"
"Beispiel: \n"
"Ge*ca**i** -> Geocaching \n"
"ge*ca**i** -> Geocaching \n"
"T*****dose -> Tupperdose, Tabaksdose"
"Diese Funktion nutzt dafür die deutsche Wörterbuchdatei vom Project "
"https://sourceforge.net/projects/germandict")
else:
try:
wbfile = open("./data/german.dic", "r", encoding="iso-8859-15")
except FileNotFoundError:
Ausgabe.insert(1.0, hilfetext + "\n")
return "Leider konnte die Wörterbuchdatei nicht geladen werden."
else:
Ausgabe.insert(1.0, "\n")
ausgabetext = "_im Wörterbuch gefundene passende Wörter:_ \n"
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
if len(eingabetext) != len(zeile):
@@ -1525,41 +1537,32 @@ befinden.
if eingabetext[c].upper() != zeile[c].upper():
fehler += 1
if fehler == 0:
Ausgabe.insert(1.0, zeile + "\n")
ausgabetext += zeile + " \n"
wbfile.close()
Ausgabe.insert(1.0, "im Wörterbuch gefundene passende Wörter:\n", "bu")
return ausgabetext
def wortsuche_en():
hilfetext = """HILFE: [Wortsuche mit Wörterbuch]
Wer kennt es nicht? Man sucht ein Wort mit einer bestimmten
Anzahl an Buchstaben und weiß aber z.B. nur den Anfangsbuchstaben
und die letzten 3 Buchstaben. Hierbei soll diese Funktion helfen.
Unbekannte Buchstaben werden dabei einfach durch * ersetzt.
Klein-/Großschreibung in der Eingabe wird dabei ignoriert.
Beispiel:
Ge*ca**i** -> geocaching
ge*ca**i** -> geocaching
say*s -> say's (Die Wortliste kennt viele Wörter mit Apostroph)
coordinat** -> coordinator, coordinates, coordinated
Da diese Funktion die englische Wörterliste en_US-large.txt
vom Project https://sourceforge.net/projects/wordlist benutzt,
muß sich natürlich die Datei en_US-large.txt im Unterverzeichnis "data"
befinden.
"""
eingabetext = Eingabe.get(1.0, END)
def wortsuche_en(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
return ("### Wortsuche mit Wörterbuch\n"
"Wer kennt es nicht? Man sucht ein Wort mit einer bestimmten Anzahl an Buchstaben und weiß aber z.B. "
"nur den Anfangsbuchstaben und die letzten 3 Buchstaben. Hierbei soll diese Funktion helfen. "
"Unbekannte Buchstaben werden dabei einfach durch * ersetzt. Klein-/Großschreibung in der Eingabe "
"wird dabei ignoriert. \n"
"Beispiel: \n"
"Ge*ca**i** -> geocaching \n"
"ge*ca**i** -> geocaching \n"
"say*s -> say's (Die Wortliste kennt viele Wörter mit Apostroph) \n"
"coordinat** -> coordinator, coordinates, coordinated \n"
"Diese Funktion nutz dafür die englische Wörterliste en_US-large.txt vom Project "
"https://sourceforge.net/projects/wordlist")
else:
try:
wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
except FileNotFoundError:
Ausgabe.insert(1.0, hilfetext + "\n")
return "Leider konnte die Wörterbuchdatei nicht geladen werden."
else:
Ausgabe.insert(1.0, "\n")
ausgabetext = "_im Wörterbuch gefundene passende Wörter:_ \n"
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
if len(eingabetext) != len(zeile):
@@ -1571,69 +1574,23 @@ befinden.
if eingabetext[c].upper() != zeile[c].upper():
fehler += 1
if fehler == 0:
Ausgabe.insert(1.0, zeile + "\n")
ausgabetext += zeile + " \n"
wbfile.close()
Ausgabe.insert(1.0, "im Wörterbuch gefundene passende Wörter:\n", "bu")
return ausgabetext
def anagramm_suche_en():
hilfetext = """HILFE: [Anagrammsuche mit Wörterbuch EN]
Diese Funktion benutzt die englische Wörterliste en_US-large.txt
vom Project https://sourceforge.net/projects/wordlist
um zu überprüfen ob sich unter Verwendung aller eingegebenen
Buchstaben Wörter bilden lassen, welche im Wörterbuch vorkommen.
Die Datei en_US-large.txt muß sich dafür im Unterverzeichnis
"data" befinden. Dieses Wörterbuch kennt übrigens auch viele
Wörter mit Apostroph wie z.B. "say's".
"""
eingabetext = Eingabe.get(1.0, END)
def remorse_de(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
else:
try:
wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
except FileNotFoundError:
Ausgabe.insert(1.0, hilfetext + "\n")
else:
eingabezaehl = wortzaehl(eingabetext)
Ausgabe.insert(1.0, "\n")
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
if eingabetext.upper() == zeile.upper():
continue
if len(eingabetext) != len(zeile):
continue
if eingabezaehl == wortzaehl(zeile):
Ausgabe.insert(1.0, zeile + "\n")
wbfile.close()
Ausgabe.insert(1.0, "gefundene Anagramme:\n", "bu")
def remorse_de():
hilfetext = """HILFE: [RE-Morse DE]
Es gibt ja so Leute, die finden es lustig einen Morsecode
so aufzuschreiben, daß zwar Wort für Wort getrennt wird,
aber ansonsten einfach mal die Leerzeichen weggelassen werden.
Bei genau solchen fiesen Gemeinheiten hilft diese Funktion.
Diese Funktion benutzt die deutsche Wörterbuchdatei german.dic
vom Project https://sourceforge.net/projects/germandict .
Da eine Abfrage relativ lange dauert gibt es die Möglichkeit
aus dem german.dic ein ca. 100 MB großes remorse-de.dic bauen
zu lassen, welches ab der nächsten Abfrage dann genutzt wird
und wodurch dann nur noch ca. 20% der Zeit pro Abfrage benötigt
wird. Um die Erstellung des remorse-de.dic zu starten muß
das Wort GENERATE (Großschreibung beachten!) ins Eingabefeld
eingetragen werden und der Funktionsknopf betätigt werden.
Damit alles funktioniert, muß sich die Datei german.dic
im Unterverzeichnis "data" befinden.
"""
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
return ("### RE-Morse DE\n"
"Es gibt ja so Leute, die finden es lustig einen Morsecode so aufzuschreiben, daß zwar Wort für Wort "
"getrennt wird, aber ansonsten einfach mal die Leerzeichen weggelassen werden. Bei genau solchen "
"fiesen Gemeinheiten hilft diese Funktion. Diese Funktion benutzt die deutsche Wörterbuchdatei vom "
"Project https://sourceforge.net/projects/germandict \n"
"Da eine Abfrage relativ lange dauert gibt es die Möglichkeit ein ca. 100 MB großes remorse-de.dic "
"generieren zu lassen, welches ab der nächsten Abfrage dann genutzt wird und wodurch dann nur noch "
"ca. 20% der Zeit pro Abfrage benötigt wird. Um die Erstellung zu starten muß das Wort GENERATE "
"(Großschreibung beachten!) ins Eingabefeld eingetragen werden und der Funktionsknopf betätigt "
"werden.")
else:
try:
wbfile = open("./data/morse-de.dic", "r",
@@ -1643,35 +1600,28 @@ im Unterverzeichnis "data" befinden.
testfile = open("./data/german.dic", "r")
testfile.close()
if eingabetext == "GENERATE":
remorse_generate_morsede()
Ausgabe.insert(1.0,
"/data/remorse-de wurde erzeugt und \nwird ab dem nächsten Aufruf "
"der Funktion benutzt.\n", "gr")
helper.remorse_generate_morsede()
return "Remorse-Wörterbuch wurde erzeugt und wird ab dem nächsten Aufruf der Funktion benutzt."
else:
Ausgabe.insert(1.0, "ins Eingabefeld eingeben und die Funktion starten.\n", "gr")
Ausgabe.insert(1.0,
"Um das ca. 100 MB große morse-de.dic einmalig aus\ndem german.dic zu "
"erzeugen bitte das Wort: GENERATE\n", "gr")
Ausgabe.insert(1.0, "das dauert zwar ca. 5x so lange, aber geht auch.\n", "gr")
Ausgabe.insert(1.0,
"Da das Morsewörter /data/morse-de.dic nicht vorhanden ist,\n"
"wurde /data/german.dic für die Suche benutzt\n", "gr")
remorse_germandic()
return
ausgabetext = ("_Da das Remorse-Wörterbuch noch nicht generiert wurde, wurde das normale_ "
"_Wörterbuch für die Suche benutzt, das dauert zwar ca. 5x so lange, aber geht_ "
"_auch._ \n"
"_Um das Remorse-Wörterbuch zu erzeugen bitte das Wort:_ __GENERATE__ _ins_ "
"_Eingabefeld eingeben und die Funktion starten. \n \n")
return ausgabetext + helper.remorse_germandic(eingabetext)
except FileNotFoundError:
Ausgabe.insert(1.0, "Es konnte weder /data/german.dic noch /data/morse-de.dic gefunden werden!\n", "re")
return "Leider konnte die Wörterbuchdatei nicht geladen werden."
else:
Ausgabe.insert(1.0, "\n")
ausgabetext = "_der eingegebene Morsecode kann für folgendes stehen:_ \n"
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
mline = zeile.split(",")
if eingabetext == mline[0]:
Ausgabe.insert(1.0, mline[1] + "\n")
ausgabetext += mline[1] + " \n"
wbfile.close()
Ausgabe.insert(1.0, "der eingegebene Morsecode kann für folgendes stehen:\n", "bu")
return ausgabetext
def remorse_germandic():
def remorse_en(eingabetext):
alphabet = {'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.', 'G': '--.',
'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..', 'M': '--', 'N': '-.',
'O': '---', 'P': '.--.', 'Q': '--.-', 'R': '.-.', 'S': '...', 'T': '-', 'U': '..-',
@@ -1684,88 +1634,23 @@ def remorse_germandic():
'(': '-.--.', "'": '.----.', 'SS': '...--..'}
ualphabet = {v: k for k, v in alphabet.items()}
ualphabet["...--.."] = "ß"
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
wbfile = open("./data/german.dic", "r", encoding="iso-8859-15")
Ausgabe.insert(1.0, "\n")
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
mzeile = ""
try:
for char in zeile:
mzeile += alphabet[char.upper()]
except KeyError:
continue
if eingabetext == mzeile:
Ausgabe.insert(1.0, zeile + "\n")
wbfile.close()
if eingabetext in ualphabet:
Ausgabe.insert(1.0, ualphabet[eingabetext] + "\n")
Ausgabe.insert(1.0, "der eingegebene Morsecode kann für folgendes stehen:\n", "bu")
def remorse_generate_morsede():
alphabet = {'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.', 'G': '--.',
'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..', 'M': '--', 'N': '-.',
'O': '---', 'P': '.--.', 'Q': '--.-', 'R': '.-.', 'S': '...', 'T': '-', 'U': '..-',
'V': '...-', 'W': '.--', 'X': '-..-', 'Y': '-.--', 'Z': '--..', '1': '.----',
'2': '..---', '3': '...--', '4': '....-', '5': '.....', '6': '-....', '7': '--...',
'8': '---..', '9': '----.', '0': '-----', 'Ñ': '--.--', 'É': '..-..', 'È': '.-..-',
'À': '.--.-', 'Ü': '..--', 'Ö': '---.', 'Ä': '.-.-', '_': '..--.-', '@': '.--.-.',
'?': '..--..', '=': '-...-', ';': '-.-.-.', ':': '---...', '/': '-..-.',
'.': '.-.-.-', '-': '-....-', ',': '--..--', '+': '.-.-.', ')': '-.--.-',
'(': '-.--.', "'": '.----.', 'SS': '...--..'}
with open("./data/morse-de.dic", "w", encoding="iso-8859-1") as ofile:
for symbol, morse in alphabet.items():
ofile.write(f"{morse},{symbol}\n")
with open("./data/german.dic", "r", encoding="iso-8859-1") as infile:
for line in infile:
word = line.strip()
try:
morse_word = ''.join(alphabet[char.upper()] for char in word)
ofile.write(f"{morse_word},{word}\n")
except KeyError:
# Überspringe Wörter mit nicht-unterstützten Zeichen
continue
infile.close()
ofile.close()
def remorse_en():
hilfetext = """HILFE: [RE-Morse EN]
Es gibt ja so Leute, die finden es lustig einen
Morsecode so aufzuschreiben, daß zwar Wort für
Wort getrennt wird, aber ansonsten einfach mal
die Leerzeichen weggelassen werden. Bei genau
solchen fiesen Gemeinheiten hilft diese Funktion.
Mit Hilfe der englischen Wörterliste en_US-large.txt
vom Project https://sourceforge.net/projects/wordlist
wird überprüft, für welches Wort der eingegebene Morsecode
stehen könnte. Die Datei en_US-large.txt muß sich dafür
im Unterverzeichnis "data" befinden.
"""
alphabet = {'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.', 'G': '--.',
'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..', 'M': '--', 'N': '-.',
'O': '---', 'P': '.--.', 'Q': '--.-', 'R': '.-.', 'S': '...', 'T': '-', 'U': '..-',
'V': '...-', 'W': '.--', 'X': '-..-', 'Y': '-.--', 'Z': '--..', '1': '.----',
'2': '..---', '3': '...--', '4': '....-', '5': '.....', '6': '-....', '7': '--...',
'8': '---..', '9': '----.', '0': '-----', 'Ñ': '--.--', 'É': '..-..', 'È': '.-..-',
'À': '.--.-', 'Ü': '..--', 'Ö': '---.', 'Ä': '.-.-', '_': '..--.-', '@': '.--.-.',
'?': '..--..', '=': '-...-', ';': '-.-.-.', ':': '---...', '/': '-..-.',
'.': '.-.-.-', '-': '-....-', ',': '--..--', '+': '.-.-.', ')': '-.--.-',
'(': '-.--.', "'": '.----.', 'SS': '...--..'}
ualphabet = {v: k for k, v in alphabet.items()}
ualphabet["...--.."] = "ß"
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
return ("### RE-Morse EN\n"
"Es gibt ja so Leute, die finden es lustig einen Morsecode so aufzuschreiben, daß zwar Wort für Wort "
"getrennt wird, aber ansonsten einfach mal die Leerzeichen weggelassen werden. Bei genau solchen "
"fiesen Gemeinheiten hilft diese Funktion. Mit Hilfe der englischen Wörterliste en_US-large.txt vom "
"Project https://sourceforge.net/projects/wordlist wird überprüft, für welches Wort der eingegebene "
"Morsecode stehen könnte.")
else:
try:
wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
except FileNotFoundError:
Ausgabe.insert(1.0, hilfetext + "\n")
return "Leider konnte die Wörterbuchdatei nicht geladen werden."
else:
Ausgabe.insert(1.0, "\n")
ausgabetext = "_der eingegebene Morsecode kann für folgendes stehen:_ \n"
if eingabetext in ualphabet:
ausgabetext += ualphabet[eingabetext] + " \n"
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
mzeile = ""
@@ -1775,38 +1660,24 @@ im Unterverzeichnis "data" befinden.
except KeyError:
continue
if eingabetext == mzeile:
Ausgabe.insert(1.0, zeile + "\n")
ausgabetext += zeile + " \n"
wbfile.close()
if eingabetext in ualphabet:
Ausgabe.insert(1.0, ualphabet[eingabetext] + "\n")
Ausgabe.insert(1.0, "der eingegebene Morsecode kann für folgendes stehen:\n", "bu")
return ausgabetext
def t9_de():
hilfetext = """HILFE: [T9-DE]
Diese Funktion benutzt die deutsche Wörterbuchdatei german.dic
vom Project https://sourceforge.net/projects/germandict .
ermittelt diese Funktion alle im Wörterbuch enthaltenen
Wörter die zu der eingegebenen T9-kodierten Ziffernfolge
passen und gibt diese aus.
Bsp. 56673462836 liefert das Wort Koordinaten
Da eine Abfrage relativ lange dauert gibt es die Möglichkeit
aus dem german.dic ein ca. 60 MB großes t9-de.dic bauen
zu lassen, welches ab der nächsten Abfrage dann genutzt wird
und wodurch dann nur noch ca. 15% der Zeit pro Abfrage benötigt
wird. Um die Erstellung des t9-de.dic zu starten muß
das Wort GENERATE (Großschreibung beachten!) ins Eingabefeld
eingetragen werden und der Funktionsknopf betätigt werden.
Damit alles funktioniert, muß sich die Datei german.dic
im Unterverzeichnis "data" befinden.
"""
eingabetext = Eingabe.get(1.0, END)
def t9_de(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
return ("### T9-DE\n"
"Diese Funktion benutzt die deutsche Wörterbuchdatei german.dic vom Project "
"https://sourceforge.net/projects/germandict ermittelt diese Funktion alle im Wörterbuch "
"enthaltenen Wörter die zu der eingegebenen T9-kodierten Ziffernfolge passen und gibt "
"diese aus. \n"
"Bsp. 56673462836 liefert das Wort Koordinaten \n"
"Da eine Abfrage relativ lange dauert gibt es die Möglichkeit ein spezielles t9-Wörterbuch "
"generieren zu lassen, welches ab der nächsten Abfrage dann genutzt wird und wodurch dann nur noch ca. "
"15% der Zeit pro Abfrage benötigt wird. Um die Erstellung des t9-de.dic zu starten muß das Wort "
"GENERATE (Großschreibung beachten!) ins Eingabefeld eingetragen werden und der Funktionsknopf "
"betätigt werden.")
else:
try:
wbfile = open("./data/t9-de.dic", "r", encoding="iso-8859-15")
@@ -1815,35 +1686,27 @@ im Unterverzeichnis "data" befinden.
testfile = open("./data/german.dic", "r")
testfile.close()
if eingabetext == "GENERATE":
t9_generate_t9de()
Ausgabe.insert(1.0,
"/data/t9-de.dic wurde erzeugt und \n"
"wird ab dem nächsten Aufruf der Funktion benutzt.\n", "gr")
helper.t9_generate_t9de()
return "t9-Wörterbuch wurde erzeugt und wird ab dem nächsten Aufruf der Funktion benutzt."
else:
Ausgabe.insert(1.0, "ins Eingabefeld eingeben und die Funktion starten.\n", "gr")
Ausgabe.insert(1.0,
"Um das ca. 60 MB große t9-de.dic einmalig aus\n"
"dem german.dic zu erzeugen bitte das Wort: GENERATE\n", "gr")
Ausgabe.insert(1.0, "das dauert zwar ca. 7x so lange, aber geht auch.\n", "gr")
Ausgabe.insert(1.0,
"Da das T9-Wörterbuch /data/t9-de.dic nicht vorhanden ist,\n"
"wurde /data/german.dic für die Suche benutzt\n", "gr")
t9_germandic()
return
ausgabetext = ("_Da das T9-Wörterbuch nicht vorhanden ist, wurde das normale Wörterbuch für die_ "
"_Suche benutzt. Das dauert zwar ca. 7x so lange, aber geht auch._ \n"
"_Um das spezielle T9-Wörterbuch zu erzeugen bitte das Wort: GENERATE ins_ "
"_Eingabefeld eingeben und die Funktion starten._ \n \n")
return ausgabetext + helper.t9_germandic(eingabetext)
except FileNotFoundError:
Ausgabe.insert(1.0, "Es konnte weder /data/german.dic noch /data/t9-de.dic gefunden werden!\n", "re")
return "Leider konnte die Wörterbuchdatei nicht geladen werden."
else:
Ausgabe.insert(1.0, "\n")
ausgabetext = "_der eingegebene T9-Code kann für folgendes stehen:_ \n"
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
mline = zeile.split(",")
if eingabetext == mline[0]:
Ausgabe.insert(1.0, mline[1] + "\n")
ausgabetext += mline[1] + " \n"
wbfile.close()
Ausgabe.insert(1.0, "der eingegebene T9-Code kann für folgendes stehen:\n", "bu")
return ausgabetext
def t9_germandic():
def t9_en(eingabetext):
alphabet = {'A': '2', 'B': '2', 'C': '2', 'D': '3', 'E': '3', 'F': '3', 'G': '4',
'H': '4', 'I': '4', 'J': '5', 'K': '5', 'L': '5', 'M': '6', 'N': '6',
'O': '6', 'P': '7', 'Q': '7', 'R': '7', 'S': '7', 'T': '8', 'U': '8',
@@ -1852,82 +1715,20 @@ def t9_germandic():
'0': '0', 'Ñ': '6', 'É': '3', 'È': '3', 'À': '2', 'Ü': '8', 'Ö': '6',
'Ä': '2', '@': '1', '?': '1', '=': '0', ':': '1', '/': '1', '.': '1',
'-': '1', ',': '1', '+': '0', ')': '1', '(': '1', 'SS': '7'}
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
wbfile = open("./data/german.dic", "r", encoding="iso-8859-15")
Ausgabe.insert(1.0, "\n")
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
mzeile = ""
try:
for char in zeile:
mzeile += alphabet[char.upper()]
except KeyError:
continue
if eingabetext == mzeile:
Ausgabe.insert(1.0, zeile + "\n")
wbfile.close()
Ausgabe.insert(1.0, "der eingegebene T9-Code kann für folgendes stehen:\n", "bu")
def t9_generate_t9de():
alphabet = {'A': '2', 'B': '2', 'C': '2', 'D': '3', 'E': '3', 'F': '3', 'G': '4',
'H': '4', 'I': '4', 'J': '5', 'K': '5', 'L': '5', 'M': '6', 'N': '6',
'O': '6', 'P': '7', 'Q': '7', 'R': '7', 'S': '7', 'T': '8', 'U': '8',
'V': '8', 'W': '9', 'X': '9', 'Y': '9', 'Z': '9', '1': '1', '2': '2',
'3': '3', '4': '4', '5': '5', '6': '6', '7': '7', '8': '8', '9': '9',
'0': '0', 'Ñ': '6', 'É': '3', 'È': '3', 'À': '2', 'Ü': '8', 'Ö': '6',
'Ä': '2', '@': '1', '?': '1', '=': '0', ':': '1', '/': '1', '.': '1',
'-': '1', ',': '1', '+': '0', ')': '1', '(': '1', 'SS': '7'}
ofile = open("./data/t9-de.dic", "a", encoding="iso-8859-15")
file = open("./data/german.dic", "r", encoding="iso-8859-15")
for zeile in file:
omsg = ""
zeile = zeile.rstrip()
try:
for char in zeile:
omsg = omsg + alphabet[char.upper()]
except KeyError:
continue
else:
ofile.write(omsg + "," + zeile + "\n")
file.close()
ofile.close()
def t9_en():
hilfetext = """HILFE: [T9 EN]
Mit Hilfe der englischen Wörterliste en_US-large.txt
vom Project https://sourceforge.net/projects/wordlist
ermittelt diese Funktion alle im Wörterbuch enthaltenen
Wörter die zu der eingegebenen T9-kodierten Ziffernfolge
passen und gibt diese aus.
Bsp. 26673462837 liefert das Wort coordinates
Die Datei en_US-large.txt muß sich dafür
im Unterverzeichnis "data" befinden.
"""
alphabet = {'A': '2', 'B': '2', 'C': '2', 'D': '3', 'E': '3', 'F': '3', 'G': '4',
'H': '4', 'I': '4', 'J': '5', 'K': '5', 'L': '5', 'M': '6', 'N': '6',
'O': '6', 'P': '7', 'Q': '7', 'R': '7', 'S': '7', 'T': '8', 'U': '8',
'V': '8', 'W': '9', 'X': '9', 'Y': '9', 'Z': '9', '1': '1', '2': '2',
'3': '3', '4': '4', '5': '5', '6': '6', '7': '7', '8': '8', '9': '9',
'0': '0', 'Ñ': '6', 'É': '3', 'È': '3', 'À': '2', 'Ü': '8', 'Ö': '6',
'Ä': '2', '@': '1', '?': '1', '=': '0', ':': '1', '/': '1', '.': '1',
'-': '1', ',': '1', '+': '0', ')': '1', '(': '1', 'SS': '7'}
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
return ("### T9 EN\n"
"Mit Hilfe der englischen Wörterliste en_US-large.txt vom Project "
"https://sourceforge.net/projects/wordlist ermittelt diese Funktion alle im Wörterbuch "
"enthaltenen Wörter die zu der eingegebenen T9-kodierten Ziffernfolge passen und gibt diese aus. \n"
"Bsp. 26673462837 liefert das Wort coordinates")
else:
try:
wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
except FileNotFoundError:
Ausgabe.insert(1.0, hilfetext + "\n")
return "Leider konnte die Wörterbuchdatei nicht geladen werden."
else:
Ausgabe.insert(1.0, "\n")
ausgabetext = "_der eingegebene T9-Code kann für folgendes stehen:_ \n"
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
mzeile = ""
@@ -1937,11 +1738,11 @@ im Unterverzeichnis "data" befinden.
except KeyError:
continue
if eingabetext == mzeile:
Ausgabe.insert(1.0, zeile + "\n")
ausgabetext += zeile + " \n"
wbfile.close()
Ausgabe.insert(1.0, "der eingegebene T9-Code kann für folgendes stehen:\n", "bu")
return ausgabetext
'''
def vigenere():
hilfetext = """HILFE: [Vigenere-Chiffre]
Die Eingabe eines Schlüsselwortes ist hier erforderlich!!!