update versions of requirements

Reviewed-on: #3

.gitea/workflows/create_and_push_multiarch_container.yml

@@ -6,7 +6,7 @@ on:
       image_tag:
         description: '2. Tag für das Docker-Image (außer latest) (z.B. v1.0.0)'
         required: true
-        default: '0.6.0'
+        default: '0.7.0'
 
 env:
   image_name: mysteryhelfer

app/app.py

@@ -4,7 +4,7 @@ import streamlit as st
 import base64
 import tools
 import matplotlib.pyplot as plt
-from helper import show_map_folium
+import helper
 
 standard_output = ('#### Um den HILFE-Text zu einzelnen Funktionen aufzurufen bitte die Funktion mit leerem'
                   ' Eingabefeld aufrufen.')
@@ -224,6 +224,7 @@ if 'input_text' not in st.session_state:
     st.session_state.input_text = ""
 if 'output_text' not in st.session_state:
     st.session_state.output_text = standard_output
+    st.session_state.output_text += helper.generate_special_files()
 if 'map_data' not in st.session_state:
     st.session_state.map_data = None
 if 'graph_data' not in st.session_state:
@@ -361,7 +362,7 @@ st.markdown(st.session_state.output_text)
 # Karte anzeigen, falls aktiviert
 if st.session_state.map_data is not None:
     st.subheader("Kartenansicht")
-    show_map_folium(st.session_state.map_data)
+    helper.show_map_folium(st.session_state.map_data)
 
 
 if st.session_state.graph_data is not None:

app/helper.py

@@ -5,6 +5,7 @@ from re import match  # für unkennify
 import streamlit as st
 from streamlit_folium import st_folium
 import folium
+import os
 
 
 # ***recursive quersummenfunktion***
@@ -175,6 +176,20 @@ def unkennify(text):
         decoded = decoded + text[i:]
     return decoded
 
+def generate_special_files():
+    out="\n\n\n"
+    if os.path.exists("./data/morse-de.dic"):
+        pass
+    else:
+        remorse_generate_morsede()
+        out+=":blue[deutsches Re-Morse-Wörterbuch wurde generiert]  \n"
+    if os.path.exists("./data/t9-de.dic"):
+        pass
+    else:
+        t9_generate_t9de()
+        out+=":blue[deutsches T9-Wörterbuch wurde generiert]  \n"
+    return out
+
 def remorse_generate_morsede():
     alphabet = {'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.', 'G': '--.',
                 'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..', 'M': '--', 'N': '-.',
@@ -225,62 +240,6 @@ def t9_generate_t9de():
     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 = ":blue[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 = ":blue[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
-
 def rail_encrypt(plain_text: str, rails: int):
     arr = [["" for _ in range(len(plain_text))] for _ in range(rails)]
     r = 0

app/hilfetexte.py

@@ -299,13 +299,9 @@ wortsuche_en = ("### Wortsuche mit Wörterbuch EN\n"
 remorse_de = ("### 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 "
+              "fiesen Gemeinheiten hilft diese Funktion. Für diese Funktion wurde basierend auf der deutschen "
-              "Project https://sourceforge.net/projects/germandict  \n"
+              "Wörterbuchdatei vom Project https://sourceforge.net/projects/germandict eine "
-              "Da eine Abfrage relativ lange dauert gibt es die Möglichkeit ein ca. 100 MB großes remorse-de.dic "
+              "spezielle Wörterbuchdatei generiert, um eine beschleunigte Abfrage zu ermöglichen.")
-              "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.")
 
 remorse_en = ("### RE-Morse EN\n"
               "Es gibt ja so Leute, die finden es lustig einen Morsecode so aufzuschreiben, daß zwar Wort für Wort "
@@ -320,11 +316,9 @@ t9_de = ("### T9-DE\n"
          "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 "
+         "Für diese Funktion wurde basierend auf der deutschen Wörterbuchdatei vom Project "
-         "generieren zu lassen, welches ab der nächsten Abfrage dann genutzt wird und wodurch dann nur noch ca. "
+         "https://sourceforge.net/projects/germandict eine spezielle Wörterbuchdatei generiert, um eine beschleunigte "
-         "15% der Zeit pro Abfrage benötigt wird. Um die Erstellung des t9-de.dic zu starten muß das Wort "
+         "Abfrage zu ermöglichen.")
-         "GENERATE (Großschreibung beachten!) ins Eingabefeld eingetragen werden und der Funktionsknopf "
-         "betätigt werden.")
 
 t9_en = ("### T9-EN\n"
          "Mit Hilfe der englischen Wörterliste en_US-large.txt vom Project "

app/tools.py

@@ -172,11 +172,14 @@ def zeichenanzahl(eingabetext):
             else:
                 anzahl[b] = 1
         s = []
+        zeichensumme = 0
         for key in anzahl:
             s.append(key)
+            zeichensumme += anzahl[key]
         s.sort()
-        ausgabetext += f"Es wurden __:orange[{len(anzahl)}]__ unterschiedliche Zeichen gefunden.  \n"
+        ausgabetext += (f"Es wurden __:orange[{len(anzahl)}]__ unterschiedliche Zeichen in insgesamt "
-        ausgabetext += "| :blue[Zeichen] | :blue[Anzahl] |\n|----|----|\n"
+                        f"__:orange[{zeichensumme}]__ Zeichen gefunden.  \n"
+                        f"| :blue[Zeichen] | :blue[Anzahl] |\n|----|----|\n")
         for i in s:
             if ord(i) == 9:
                 ausgabetext += f"|TAB|{anzahl[i]}|\n"
@@ -1461,34 +1464,19 @@ def remorse_de(eingabetext):
     if eingabetext == "":
         return hilfetexte.remorse_de
     else:
-        try:
+        wbfile = open("./data/morse-de.dic", "r", encoding="iso-8859-15")
-            wbfile = open("./data/morse-de.dic", "r",
+        ausgabetext = ":blue[der eingegebene Morsecode kann für folgendes stehen:]  \n"
-                          encoding="iso-8859-15")  # german.dic von https://sourceforge.net/projects/germandict/
+        count = 0
-        except FileNotFoundError:
+        for zeile in wbfile:
-            try:
+            zeile = zeile.strip(" \t\n\r")
-                testfile = open("./data/german.dic", "r")
+            mline = zeile.split(",")
-                testfile.close()
+            if eingabetext == mline[0]:
-                if eingabetext == "GENERATE":
+                ausgabetext += mline[1] + "  \n"
-                    helper.remorse_generate_morsede()
+                count += 1
-                    return (":green[Remorse-Wörterbuch wurde erzeugt und wird ab dem nächsten Aufruf der Funktion "
+        wbfile.close()
-                            "benutzt.]")
+        if count == 0:
-                else:
+            return ":red[leider nichts gefunden :disappointed:]"
-                    ausgabetext = (":green[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:] :orange[GENERATE] "
-                                   ":green[ins Eingabefeld eingeben und die Funktion starten.]  \n  \n")
-                return ausgabetext + helper.remorse_germandic(eingabetext)
-            except FileNotFoundError:
-                return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
         else:
-            ausgabetext = ":blue[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]:
-                    ausgabetext += mline[1] + "  \n"
-            wbfile.close()
             return ausgabetext
 
 def remorse_en(eingabetext):
@@ -1516,6 +1504,7 @@ def remorse_en(eingabetext):
             ausgabetext = ":blue[der eingegebene Morsecode kann für folgendes stehen:]  \n"
             if eingabetext in ualphabet:
                 ausgabetext += ualphabet[eingabetext] + "  \n"
+            count = 0
             for zeile in wbfile:
                 zeile = zeile.strip(" \t\n\r")
                 mzeile = ""
@@ -1526,39 +1515,31 @@ def remorse_en(eingabetext):
                     continue
                 if eingabetext == mzeile:
                     ausgabetext += zeile + "  \n"
+                    count += 1
             wbfile.close()
-            return ausgabetext
+            if count == 0:
+                return ":red[leider nichts gefunden :disappointed:]"
+            else:
+                return ausgabetext
 
 def t9_de(eingabetext):
     eingabetext = eingabetext.rstrip()
     if eingabetext == "":
         return hilfetexte.t9_de
     else:
-        try:
+        wbfile = open("./data/t9-de.dic", "r", encoding="iso-8859-15")
-            wbfile = open("./data/t9-de.dic", "r", encoding="iso-8859-15")
+        ausgabetext = ":blue[der eingegebene T9-Code kann für folgendes stehen:]  \n"
-        except FileNotFoundError:
+        count = 0
-            try:
+        for zeile in wbfile:
-                testfile = open("./data/german.dic", "r")
+            zeile = zeile.strip(" \t\n\r")
-                testfile.close()
+            mline = zeile.split(",")
-                if eingabetext == "GENERATE":
+            if eingabetext == mline[0]:
-                    helper.t9_generate_t9de()
+                ausgabetext += mline[1] + "  \n"
-                    return ":green[t9-Wörterbuch wurde erzeugt und wird ab dem nächsten Aufruf der Funktion benutzt.]"
+                count += 1
-                else:
+        wbfile.close()
-                    ausgabetext = (":green[Da das T9-Wörterbuch nicht vorhanden ist, wurde das normale Wörterbuch für "
+        if count == 0:
-                                   "die Suche benutzt. Das dauert zwar ca. 7x so lange, aber geht auch.  \n"
+            return ":red[leider nichts gefunden :disappointed:]"
-                                   "Um das spezielle T9-Wörterbuch zu erzeugen bitte das Wort:] :orange[GENERATE] "
-                                   ":green[ins Eingabefeld eingeben und die Funktion starten.]  \n  \n")
-                return ausgabetext + helper.t9_germandic(eingabetext)
-            except FileNotFoundError:
-                return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
         else:
-            ausgabetext = ":blue[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]:
-                    ausgabetext += mline[1] + "  \n"
-            wbfile.close()
             return ausgabetext
 
 def t9_en(eingabetext):
@@ -1580,6 +1561,7 @@ def t9_en(eingabetext):
             return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
         else:
             ausgabetext = ":blue[der eingegebene T9-Code kann für folgendes stehen:]  \n"
+            count = 0
             for zeile in wbfile:
                 zeile = zeile.strip(" \t\n\r")
                 mzeile = ""
@@ -1590,8 +1572,12 @@ def t9_en(eingabetext):
                     continue
                 if eingabetext == mzeile:
                     ausgabetext += zeile + "  \n"
+                    count += 1
             wbfile.close()
-            return ausgabetext
+            if count == 0:
+                return ":red[leider nichts gefunden :disappointed:]"
+            else:
+                return ausgabetext
 
 def vigenere(eingabetext, pw):
     bw = {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6, 'G': 7, 'H': 8, 'I': 9, 'J': 10, 'K': 11, 'L': 12, 'M': 13,

readme.md

@@ -26,3 +26,6 @@ Der einfachst Weg, um die App lokal laufen zu lassen, ist mit Docker, wobei ich
     - `docker compose up`
      
 bei allen 3 Varianten ist die App anschließend im Browser unter http://127.0.0.1:8501/ aufrufbar
+
+__HINWEIS: Beim ersten Aufruf der Adresse werden Special-Wörterbücher für RE-Morse und T9 generiert, 
+was ca. 15-30s in Anspruch nimmt und dadurch das Laden der Seite einmalig verzögert.__