PSE, Nak-Nak, Navajo, PI

and patching favicon.ico and index.html in streamlit-lib

Dockerfile

@@ -14,6 +14,8 @@ RUN pip3 install -r requirements.txt
 
 COPY ./app /app
 
+COPY ./patch-streamlit/* /usr/local/lib/python3.13/site-packages/streamlit/static/
+
 EXPOSE 8501
 
 HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health

app/app.py

@@ -7,8 +7,9 @@ standard_output = ('#### Um den HILFE-Text zu einzelnen Funktionen aufzurufen bi
                   ' Eingabefeld aufrufen.')
 
 st.set_page_config(
-    page_title="tebarius Mysteryhelfer (web)",
+    # we do this by patching static-files of streamlit in the container
-    page_icon="./favicon.ico",
+    # page_title="tebarius Mysteryhelfer (web)",
+    # page_icon="./favicon.ico",
     layout="wide"
 )
 
@@ -144,6 +145,21 @@ def auswahl_verarbeiten():
     elif auswahl == "Slash and Pipe->Text":
         st.session_state.output_text = tools.slashpipe_to_text(text)
         st.session_state.map_data = None
+    elif auswahl == "PSE: O.zahl<->Symbol":
+        st.session_state.output_text = tools.periodensystem(text)
+        st.session_state.map_data = None
+    elif auswahl == "Nak-Nak -> Text":
+        st.session_state.output_text = tools.naknak_to_text(text)
+        st.session_state.map_data = None
+    elif auswahl == "Navajo -> Text":
+        st.session_state.output_text = tools.navajo_to_text(text)
+        st.session_state.map_data = None
+    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)
+        st.session_state.map_data = None
     elif auswahl == "REPLACE":
         st.session_state.output_text = tools.REPLACE(text)
         st.session_state.map_data = None
@@ -212,6 +228,15 @@ option = st.sidebar.radio("hidden_label",
                                    "Tomtom->Text",
                                    "Text->Slash and Pipe",
                                    "Slash and Pipe->Text",
+                                   "PSE: O.zahl<->Symbol",
+                                   "Nak-Nak -> Text",
+                                   "Navajo -> Text",
+                                   "Kreiszahl PI",
+                                   "",
+                                   "",
+                                   "",
+                                   "",
+                                   "",
                                    "",
                                    ),
                           key='option',

app/tools.py

@@ -1,6 +1,7 @@
-from itertools import chain
+from itertools import chain # für primfaktoren zerlegung
 import helper
 import pandas as pd
+from urllib.parse import unquote as urllib_parse_unquote  # für nak-nak
 
 def funktion_mit_karte(text,param):
     """Verarbeitet Text und liefert Daten für eine Karte (z.B. Potsdam Zentrum)."""
@@ -978,7 +979,6 @@ def primfaktoren(eingabetext):
                 out += str(z) + ", "
         return out[:-2]
 
-
 def dez_to_hex_oct_bin(eingabetext):
     seperator = ("|,", "_", "/", ";", ",")
     eingabetext = eingabetext.rstrip()
@@ -1025,7 +1025,6 @@ def dez_to_hex_oct_bin(eingabetext):
             ausgabetext += f"_BIN:_ {bintxt[:-1]}  \n"
             return ausgabetext
 
-
 def hex_to_dez_oct_bin(eingabetext):
     seperator = ("|,", "_", "/", ";", ",")
     eingabetext = eingabetext.rstrip()
@@ -1221,7 +1220,6 @@ def tomtom_to_abc(eingabetext):
                 atxt = atxt + alphabet[sign]
         return atxt
 
-
 def text_to_slashpipe(eingabetext):
     alphabet = {"a": "| ", "b": "|\\\\ ", "c": "|| ", "d": "|/ ", "e": "\\\\ ", "f": "||\\\\ ", "g": "||| ",
                 "h": "\\\\\\\\ ", "i": "/ ", "j": "|\\\\\\\\ ", "k": "//|| ", "l": "|\\\\/ ", "m": "|\\\\| ",
@@ -1276,8 +1274,7 @@ def slashpipe_to_text(eingabetext):
                 atxt = atxt + alphabet[sign]
         return atxt
 
-'''
+def periodensystem(eingabetext):
-def periodensystem():
     seperator = ("|,", "_", ".", "-", "/", ";", ",")
     pse = {1: "H", 2: "He", 3: "Li", 4: "Be", 5: "B", 6: "C", 7: "N", 8: "O", 9: "F", 10: "Ne", 11: "Na", 12: "Mg",
            13: "Al",
@@ -1294,23 +1291,16 @@ def periodensystem():
            103: "Lr", 104: "Rf", 105: "Db", 106: "Sg", 107: "Bh", 108: "Hs", 109: "Mt", 110: "Ds", 111: "Rg", 112: "Cn",
            113: "Nh", 114: "Fl", 115: "Mc", 116: "Lv", 117: "Ts", 118: "Og"}
     um_pse = {v: k for k, v in pse.items()}
-    
-    eingabetext = Eingabe.get(1.0, END)
     eingabetext = eingabetext.rstrip()
     if eingabetext == "":
-        Ausgabe.insert(1.0, """HILFE: [Periodensystem: Ordnungszahl<->Symbol]
+        return ("### Periodensystem: Ordnungszahl<->Symbol\n"
-Eingegebenen Ordnungszahlen 1-118 aus dem Periodensystem der
+                "Eingegebenen Ordnungszahlen 1-118 aus dem Periodensystem der Elemente werden in die ihnen zugehörigen "
-Elemente werden in die ihnen zugehörigen Elementsymbole umgewandelt
+                "Elementsymbole umgewandelt und anschließend als Text ausgegeben, außerdem erscheint noch eine Ausgabe "
-und anschließend als Text ausgegeben, außerdem erscheint noch eine
+                "bei welcher nur die Anfangsbuchstaben der Symbole ausgegeben werden. Werden in der Eingabe Symbole "
-Ausgabe bei welcher nur die Anfangsbuchstaben der Symbole ausgegeben
+                "(z.B. N, He) erkannt werde diese zusammen mit ihren Ordnungszahlen ausgegeben. Als Trennungszeichen "
-werden.
+                "zwischen den Zahlen und/oder Symbolen sind folgende Zeichen erlaubt: | , _ . - / ; , und Leerzeichen. "
-Werden in der Eingabe Symbole (z.B. N, He) erkannt werde diese
+                "Bei Verwendung von Leerzeichen sollten möglichst nur 1 Leerzeichen zwischen den Zahlen verwendet "
-zusammen mit ihren Ordnungszahlen ausgegeben.
+                "werden (überzählige Leerzeichen werden sonst als nicht erkannte Zeichen behandelt).")
-Als Trennungszeichen zwischen den Zahlen und/oder Symbolen sind
-folgende Zeichen erlaubt: | , _ . - / ; , und Leerzeichen. 
-Bei Verwendung von Leerzeichen sollten möglichst nur 1 Leerzeichen
-zwischen den Zahlen verwendet werden (überzählige Leerzeichen werden
-sonst als nicht erkannte Zeichen behandelt).""" + "\n\n")
     else:
         se = ""
         for s in seperator:
@@ -1323,12 +1313,13 @@ sonst als nicht erkannte Zeichen behandelt).""" + "\n\n")
                 ausz = int(eingabetext)
             except ValueError:
                 if eingabetext in um_pse:
-                    Ausgabe.insert(1.0, str(um_pse[eingabetext]) + "\n")
+                    return str(um_pse[eingabetext])
                 else:
-                    Ausgabe.insert(1.0, "Keine gültige Eingabe erkannt!\n", "re")
+                    return "Keine gültige Eingabe erkannt!"
             else:
-                Ausgabe.insert(1.0, pse[ausz] + "\n")
+                return pse[ausz]
         else:
+            ausgabetext = ""
             txt = eingabetext.split(se)
             atxt = ""
             atxt2 = ""
@@ -1344,159 +1335,34 @@ sonst als nicht erkannte Zeichen behandelt).""" + "\n\n")
                         ignor = ignor + z + " "
                 else:
                     if az in pse:
-                        atxt = atxt + pse[az]
+                        atxt = atxt + pse[az] + " "
                         atxt2 = atxt2 + pse[az][0]
                     else:
                         ignor = ignor + z + " "
-            if atxt3 != "":
-                Ausgabe.insert(1.0, " " + atxt3 + "\n")
-                Ausgabe.insert(1.0, "Symbol:Ordnungszahl:", "bu")
-            if atxt2 != "":
-                Ausgabe.insert(1.0, " " + atxt2 + "\n")
-                Ausgabe.insert(1.0, "Nur Anfangsbuchstaben:", "bu")
-            if atxt != "":
-                Ausgabe.insert(1.0, " " + atxt + "\n")
-                Ausgabe.insert(1.0, "Symbole:", "bu")
             if ignor != "":
-                Ausgabe.insert(1.0, ignor + "\n")
+                ausgabetext += "_Achtung nicht erkannte Zeichen:_  \n" + ignor + "  \n"
-                Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:\n", "re")
+            if atxt != "":
+                ausgabetext += "_Symbole:_  \n" + atxt + "  \n"
+            if atxt2 != "":
+                ausgabetext += "_Nur Anfangsbuchstaben:_  \n" + atxt2 + "  \n"
+            if atxt3 != "":
+                ausgabetext += "_Symbol:Ordnungszahl_  \n" + atxt3 + "  \n"
+            return ausgabetext
 
-
+def naknak_to_text(eingabetext):
-def brainfuck_interpreter():
-    
-    eingabetext = Eingabe.get(1.0, END)
-    eingabetext = eingabetext.rstrip()
-    if eingabetext == "":
-        Ausgabe.insert(1.0, """HILFE: [Brainfuckinterpreter]
-!!!!!ACHTUNG DIESE FUNKTION KANN DAS PROGRAMM ZUM ABSTURZ BRINGEN!!!!!
-Brainfuck gehört zu den sogenannten esoterischen
-Programmiersprachen. Der Programmcode setzt sich 
-hier aus den 8 Zeichen ><+-.,[]' zusammen.
-Diese Funktion führt einen derartigen Programmcode
-aus, und gibt das Ergebnis aus, welches bei Geocaches
-meist eine kurze Nachricht oder die Koordinaten sind.
-Für eine umgekehrte Umwandlung von Text in Brainfuckcode
-gibt es im Internet genügend Möglichkeiten zu finden.
-Folgender Code wäre z.B. "Hello World!" in Brainfuck:
-++++++++++[>+++++++>++++++++++>+++>+<<<<-]
->++.>+.+++++++..+++.>++.<<+++++++++++++++.
->.+++.------.--------.>+.>.""" + "\n\n")
-    else:
-        # ein kleiner feiner Code von https://gist.github.com/kates/986792
-        c = [0] * 300000
-        p = 0
-        loop = []
-        rv = []
-        ts = list(eingabetext)
-        li = len(ts)
-        i = 0
-        while i < li:
-            t = ts[i]
-            if t == ">":
-                p += 1
-            elif t == "<":
-                p -= 1
-            elif t == "+":
-                c[p] += 1
-            elif t == "-":
-                c[p] -= 1
-            elif t == ".":
-                rv.append(chr(c[p]))
-            elif t == ",":
-                pass
-            elif t == "[":
-                if c[p] == 0:
-                    while ts[i] != "]":
-                        i += 1
-                    loop.pop()
-                else:
-                    loop.append(i - 1)
-            elif t == "]":
-                i = loop[-1]
-            i += 1
-        Ausgabe.insert(1.0, "".join(rv) + "\n")
-
-
-def ook_interpreter():
-    
-    eingabetext = Eingabe.get(1.0, END)
-    eingabetext = eingabetext.rstrip()
-    if eingabetext == "":
-        Ausgabe.insert(1.0, """HILFE: [Ook-Interpreter]
-!!!!!ACHTUNG DIESE FUNKTION KANN DAS PROGRAMM ZUM ABSTURZ BRINGEN!!!!!
-Ook ist eine Abwandlung von Brainfuck wobei die 
-8 Zeichen von Brainfuck hier durch eine Kombination
-von je zwei der folgenden 3 Satzzeichen .!? ersetzt
-werden. Dabei wird dann je das Wort Ook vor die Satzzeichen
-geschrieben. z.B.: Ook! Ook? Ook. Ook!
-Da Ook auch durch andere Wörter ersetzt oder auch
-ganz ohne Wörter (ShortOok) auftaucht ignoriert diese
-Funktion alle anderen Zeichen außer .!? bevor versucht wird
-den Code auszuführen.""" + "\n\n")
-    else:
-        ookzeichen = [".", "!", "?"]
-        ooktext = ""
-        for z in eingabetext:  # erstmal Short-Ook draus machen
-            if z in ookzeichen:
-                ooktext = ooktext + z
-        ookbf = {"..": "+", "!!": "-", ".?": ">", "?.": "<", "!?": "[", "?!": "]", "!.": ".", ".!": ","}
-        bftext = ""
-        for o in range(0, len(ooktext), 2):  # jetzt in Brainfuck umwandeln
-            ooz = ooktext[o:o + 2]
-            if ooz in ookbf:
-                bftext = bftext + ookbf[ooz]
-        c = [0] * 300000
-        p = 0
-        loop = []
-        rv = []
-        ts = list(bftext)
-        li = len(ts)
-        i = 0
-        while i < li:
-            t = ts[i]
-            if t == ">":
-                p += 1
-            elif t == "<":
-                p -= 1
-            elif t == "+":
-                c[p] += 1
-            elif t == "-":
-                c[p] -= 1
-            elif t == ".":
-                rv.append(chr(c[p]))
-            elif t == ",":
-                pass
-            elif t == "[":
-                if c[p] == 0:
-                    while ts[i] != "]":
-                        i += 1
-                    loop.pop()
-                else:
-                    loop.append(i - 1)
-            elif t == "]":
-                i = loop[-1]
-            i += 1
-        Ausgabe.insert(1.0, "".join(rv) + "\n")
-
-
-def naknaktotext():
     nakwb = {"Nak": "0", "Naknak": "6", "nanak": "B", "Nanak": "1", "Naknaknak": "7", "naknak": "C", "Nananak": "2",
              "Nak.": "8", "nak!": "D", "Nanananak": "3", "Naknak.": "9", "nak.": "E", "Nak?": "4", "Naknaknaknak": "A",
              "naknaknak": "F", "nak?": "5"}
-    
-    eingabetext = Eingabe.get(1.0, END)
     eingabetext = eingabetext.rstrip()
     if eingabetext == "":
-        Ausgabe.insert(1.0, """HILFE: [NakNak to Text]
+        return ("### NakNak to Text\n"
-Nak-Nak / Entensprache / Duck Speak ist eine Spaßsprache,
+                "Nak-Nak / Entensprache / Duck Speak ist eine Spaßsprache, welche vom Owner der Website "
-welche vom Owner der Website schnatterente.net entwickelt 
+                "[https://schnatterente.net](https://web.archive.org/web/20230807065421/https://www.schnatterente.net/)"
-wurde.
+                " entwickelt wurde. Diese Funktion übersetzt das Geschnatter in verständliche Buchstaben/Zeichen. "
-Diese Funktion übersetzt das Geschnatter in verständliche
+                "!!Bitte unbedingt die Groß- und Kleinschreibung beibehalten!! Wer diesen Quatsch unbedingt umgekehrt "
-Buchstaben/Zeichen.
+                "übersetzten will, wird wohl etwas suchen müssen, da der Original-Übersetzer, der unter "
-!!Bitte unbedingt die Groß- und Kleinschreibung beibehalten!!
+                "http://uebersetzer.schnatterente.net erreichbar war, nicht mehr online ist und ich ganz bestimmt "
-Wer diesen Quatsch unbedingt umgekehrt übersetzten will,
+                "keinen hier integrieren werde.")
-findet auf hier den passenden Übersetzer:
-http://uebersetzer.schnatterente.net""" + "\n\n")
     else:
         txt = eingabetext.split()
         utxt = ""
@@ -1509,11 +1375,9 @@ http://uebersetzer.schnatterente.net""" + "\n\n")
                 utxt = utxt + nakwb[nak]
                 z = 1
         atxt = urllib_parse_unquote(utxt)
-        Ausgabe.insert(1.0, atxt + "\n")
+        return  "_dekodiertes Geschnatter:_  \n" + atxt
-        Ausgabe.insert(1.0, "dekodiertes Geschnatter:", "bu")
 
-
+def navajo_to_text(eingabetext):
-def navajototext():
     nabc = {"WOL-LA-CHEE": "A", "BE-LA-SANA": "A", "TSE-NILL": "A", "NA-HASH-CHID": "B", "SHUSH": "B", "TOISH-JEH": "B",
             "MOASI": "C", "TLA-GIN": "C", "BA-GOSHI": "C", "BE": "D", "CHINDI": "D", "LHA-CHA-EH": "D", "AH-JAH": "E",
             "DZEH": "E", "AH-NAH": "E", "CHUO": "F", "TSA-E-DONIN-EE": "F", "MA-E": "F", "AH-TAD": "G", "KLIZZIE": "G",
@@ -1526,25 +1390,19 @@ def navajototext():
             "DIBEH": "S", "KLESH": "S", "D-AH": "T", "A-WOH": "T", "THAN-ZIE": "T", "SHI-DA": "U", "NO-DA-IH": "U",
             "A-KEH-DI-GLINI": "V", "GLOE-IH": "W", "AL-NA-AS-DZOH": "X", "AL-AN-AS-DZOH": "X", "TSAH-AS-ZIH": "Y",
             "BESH-DO-TLIZ": "Z", "BESH-DO-GLIZ": "Z", "BE-TKAH": " "}
-    
-    eingabetext = Eingabe.get(1.0, END)
     eingabetext = eingabetext.rstrip()
     if eingabetext == "":
-        Ausgabe.insert(1.0, """HILFE: [Navajo-ABC to Text]
+        return ("### Navajo-ABC to Text\n"
-Die Sprache der Navajo-Indianer wurde im zweiten Weltkrieg für
+                "Die Sprache der Navajo-Indianer wurde im zweiten Weltkrieg für den verschlüßelten Funkverkehr "
-den verschlüßelten Funkverkehr eingesetzt. Vorteile waren, daß
+                "eingesetzt. Vorteile waren, daß nahezu niemand außer Navajo-Volk die Sprache verstand und es keine "
-nahezu niemand außer Navajo-Volk die Sprache verstand und es keine
+                "schriftlichen Aufzeichnungen über die Sprache gab. Das Alphabet und die Codewörter wurden dabei von "
-schriftlichen Aufzeichnungen über die Sprache gab. Das Alphabet 
+                "den Codesprechern (natürlich Navajo's) auswendig gelernt. Die Dekodierfunktion hier übersetzt das "
-und die Codewörter wurden dabei von den Codesprechern (natürlich
+                "Codealphabet (A-Z), bei welchem es auch so ist, daß unterschiedliche Worte für den selben Buchstaben "
-Navajo's) auswendig gelernt.
+                "stehen, in normalen Text. Leider existieren leicht unterschiedliche Alphabete was die Wörter bzw. "
-Die Dekodierfunktion hier übersetzt das Codealphabet (A-Z), bei welchem es
+                "deren Schreibweise angeht im Netz, mit welchen codiert wird, weshalb ich hier nur die Dekodierung "
-auch so ist, daß unterschiedliche Worte für den selben Buchstaben stehen,
+                "anbiete. weitere Codewörter und Erklärungen gibt es z.B. hier: "
-in normalen Text. Leider existieren leicht unterschiedliche Alphabete was
+                "https://ww2db.com/other.php?other_id=29  oder hier: "
-die Wörter bzw. deren Schreibweise angeht im Netz, mit welchen codiert wird,
+                "http://math.ucsd.edu/~crypto/Projects/RobertoSandoval/NavajoWindtalkers.pdf")
-weshalb ich hier nur die Dekodierung anbiete.
-weitere Codewörter und Erklärungen gibt es z.B. hier: 
-https://ww2db.com/other.php?other_id=29
-http://math.ucsd.edu/~crypto/Projects/RobertoSandoval/NavajoWindtalkers.pdf""" + "\n\n")
     else:
         txt = eingabetext.split()
         atxt = ""
@@ -1552,38 +1410,21 @@ http://math.ucsd.edu/~crypto/Projects/RobertoSandoval/NavajoWindtalkers.pdf""" +
             w = wort.upper()
             if w in nabc:
                 atxt = atxt + nabc[w]
-        Ausgabe.insert(1.0, atxt + "\n")
+        return "_dekodierter Text:_  \n" + atxt
-        Ausgabe.insert(1.0, "dekodierter Text:", "bu")
 
-
+def pi_suche(eingabetext):
-def pi_suche():
-    hilfetext = """HILFE: [PI Nachkommastellensuche]
-Für die eingegebene Zahl/Zahlenreihe X wird versucht die
-entsprechende X. Nachkommastelle auszugeben und das erst
-Vorkommen der Zahlenreihe X innerhalb der Nachkommastellen
-von PI (3.141592653589793238462643...) zu ermitteln.
-
-Da es deutlich schnneller geht mit einer vorgefertigten
-Datei zu suchen als die Nachkommastellen zu berechnen 
-wird die Datei pi.txt im Unterverzeichnis "data" benötigt.
-Diese Datei enthält die Zahl PI mit den ersten 10 Millionen
-Nachkommastellen. Wer mehr Stellen braucht, kann sich mit 
-dem Tool y-cruncher (http://numberworld.org/y-cruncher/) 
-auch eine Datei mit deutlich mehr Nachkommastellen erstellen
-und pi.txt damit ersetzen. (Bei 1 Millarde Stellen ist
-die Datei dann allerdings schon knapp 1 GB groß und
-die Abfrage dauert auch etwas länger)
-"""
-    
-    eingabetext = Eingabe.get(1.0, END)
     eingabetext = eingabetext.rstrip()
     if eingabetext == "":
-        Ausgabe.insert(1.0, hilfetext + "\n")
+        return ("### PI Nachkommastellensuche\n"
+                "Für die eingegebene Zahl/Zahlenreihe X wird versucht die entsprechende X. Nachkommastelle auszugeben "
+                "und das erst Vorkommen der Zahlenreihe X innerhalb der Nachkommastellen von PI "
+                "(3.141592653589793238462643...) zu ermitteln. Aus Performance- und Speicherplatzgründen ist die Suche "
+                "auf die ersten 10 Millionen Nachkommastellen beschränkt.")
     else:
         try:
             piread = open("./data/pi.txt", "r")
         except FileNotFoundError:
-            Ausgabe.insert(1.0, hilfetext + "\n")
+            return "Sorry es scheint die Datei pi.txt zu fehlen, welche von dieser Funktion benötigt wird."
         else:
             pistr = ""
             for zeile in piread:
@@ -1593,34 +1434,31 @@ die Abfrage dauert auch etwas länger)
             try:
                 zahlx = int(eingabetext)
             except ValueError:
-                Ausgabe.insert(1.0, "Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!\n", "re")
+                return "Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!"
             else:
+                ausgabetext = "_PI (Kreiszahl)_  \n"
                 pos = pistr.find(eingabetext)
-                if pos == -1:
-                    Ausgabe.insert(1.0, "Zahlenreihe in {} Nachkommastellen nicht zu finden.\n\n".format(pilen), "re")
-                else:
-                    Ausgabe.insert(1.0,
-                                   "20 Stellen ab {}. Nachkommstelle: {}...\n\n".format(pos - 1, pistr[pos:pos + 20]))
-                    Ausgabe.insert(1.0, 'erstes Vorkommen von Zahlenfolge "{}" ab {}. Nachkommastelle\n'.format(
-                        eingabetext.rstrip(), pos - 1))
                 if pilen >= zahlx > 0:
-                    Ausgabe.insert(1.0, "20 Stellen ab {}. Nachkommstelle: "
+                    ausgabetext += (f"_Die {zahlx}. Nachkommstelle lautet:_ {pistr[zahlx + 1]}  \n_20 Stellen ab "
-                                        "{}...\n\n".format(zahlx, pistr[zahlx + 1:zahlx + 21]))
+                                    f"{zahlx}. Nachkommstelle:_ {pistr[zahlx + 1:zahlx + 21]}...  \n")
-                    Ausgabe.insert(1.0, "Die {}. Nachkommstelle: lautet {}\n".format(zahlx, pistr[zahlx + 1]))
                 else:
-                    Ausgabe.insert(1.0, "Die verwendete pi.txt kennt leider nur {} Nachkommstellen.\n\n".format(pilen),
+                    ausgabetext += f"_Die verwendete pi.txt kennt leider nur {pilen:,} Nachkommstellen._  \n"
-                                   "re")
+                if pos == -1:
-                Ausgabe.insert(1.0, "PI (Kreiszahl)\n\n", "gr")
+                    ausgabetext += f"_Zahlenreihe in {pilen:,} Nachkommastellen nicht zu finden._"
-
+                else:
+                    ausgabetext += (f'erstes Vorkommen von Zahlenfolge "{eingabetext.rstrip()}" ab {pos - 1}. '
+                                    f'Nachkommastelle  \n20 Stellen ab {pos - 1}. Nachkommstelle: '
+                                    f'{pistr[pos:pos + 20]}...')
+                return ausgabetext
 
+'''
 def anagramm_suche_de():
     hilfetext = """HILFE: [Anagrammsuche mit Wörterbuch]
-Diese Funktion benutzt die deutsche Wörterbuchdatei german.dic
+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.
-Die Datei german.dic muß sich dafür im Unterverzeichnis "data"
+
-befinden.
 """
     
     eingabetext = Eingabe.get(1.0, END)
@@ -3717,4 +3555,120 @@ für alle Zeilenanzahlen von 2-12.""" + "\n\n")
         except ValueError:
             Ausgabe.insert(1.0, "Schlüsselzahl fehlerhaft oder kleiner als 2.\n", "re")
 
+
+def brainfuck_interpreter():
+    eingabetext = Eingabe.get(1.0, END)
+    eingabetext = eingabetext.rstrip()
+    if eingabetext == "":
+        Ausgabe.insert(1.0, """HILFE: [Brainfuckinterpreter]
+!!!!!ACHTUNG DIESE FUNKTION KANN DAS PROGRAMM ZUM ABSTURZ BRINGEN!!!!!
+Brainfuck gehört zu den sogenannten esoterischen
+Programmiersprachen. Der Programmcode setzt sich 
+hier aus den 8 Zeichen ><+-.,[]' zusammen.
+Diese Funktion führt einen derartigen Programmcode
+aus, und gibt das Ergebnis aus, welches bei Geocaches
+meist eine kurze Nachricht oder die Koordinaten sind.
+Für eine umgekehrte Umwandlung von Text in Brainfuckcode
+gibt es im Internet genügend Möglichkeiten zu finden.
+Folgender Code wäre z.B. "Hello World!" in Brainfuck:
+++++++++++[>+++++++>++++++++++>+++>+<<<<-]
+>++.>+.+++++++..+++.>++.<<+++++++++++++++.
+>.+++.------.--------.>+.>.""" + "\n\n")
+    else:
+        # ein kleiner feiner Code von https://gist.github.com/kates/986792
+        c = [0] * 300000
+        p = 0
+        loop = []
+        rv = []
+        ts = list(eingabetext)
+        li = len(ts)
+        i = 0
+        while i < li:
+            t = ts[i]
+            if t == ">":
+                p += 1
+            elif t == "<":
+                p -= 1
+            elif t == "+":
+                c[p] += 1
+            elif t == "-":
+                c[p] -= 1
+            elif t == ".":
+                rv.append(chr(c[p]))
+            elif t == ",":
+                pass
+            elif t == "[":
+                if c[p] == 0:
+                    while ts[i] != "]":
+                        i += 1
+                    loop.pop()
+                else:
+                    loop.append(i - 1)
+            elif t == "]":
+                i = loop[-1]
+            i += 1
+        Ausgabe.insert(1.0, "".join(rv) + "\n")
+
+
+def ook_interpreter():
+    eingabetext = Eingabe.get(1.0, END)
+    eingabetext = eingabetext.rstrip()
+    if eingabetext == "":
+        Ausgabe.insert(1.0, """HILFE: [Ook-Interpreter]
+!!!!!ACHTUNG DIESE FUNKTION KANN DAS PROGRAMM ZUM ABSTURZ BRINGEN!!!!!
+Ook ist eine Abwandlung von Brainfuck wobei die 
+8 Zeichen von Brainfuck hier durch eine Kombination
+von je zwei der folgenden 3 Satzzeichen .!? ersetzt
+werden. Dabei wird dann je das Wort Ook vor die Satzzeichen
+geschrieben. z.B.: Ook! Ook? Ook. Ook!
+Da Ook auch durch andere Wörter ersetzt oder auch
+ganz ohne Wörter (ShortOok) auftaucht ignoriert diese
+Funktion alle anderen Zeichen außer .!? bevor versucht wird
+den Code auszuführen.""" + "\n\n")
+    else:
+        ookzeichen = [".", "!", "?"]
+        ooktext = ""
+        for z in eingabetext:  # erstmal Short-Ook draus machen
+            if z in ookzeichen:
+                ooktext = ooktext + z
+        ookbf = {"..": "+", "!!": "-", ".?": ">", "?.": "<", "!?": "[", "?!": "]", "!.": ".", ".!": ","}
+        bftext = ""
+        for o in range(0, len(ooktext), 2):  # jetzt in Brainfuck umwandeln
+            ooz = ooktext[o:o + 2]
+            if ooz in ookbf:
+                bftext = bftext + ookbf[ooz]
+        c = [0] * 300000
+        p = 0
+        loop = []
+        rv = []
+        ts = list(bftext)
+        li = len(ts)
+        i = 0
+        while i < li:
+            t = ts[i]
+            if t == ">":
+                p += 1
+            elif t == "<":
+                p -= 1
+            elif t == "+":
+                c[p] += 1
+            elif t == "-":
+                c[p] -= 1
+            elif t == ".":
+                rv.append(chr(c[p]))
+            elif t == ",":
+                pass
+            elif t == "[":
+                if c[p] == 0:
+                    while ts[i] != "]":
+                        i += 1
+                    loop.pop()
+                else:
+                    loop.append(i - 1)
+            elif t == "]":
+                i = loop[-1]
+            i += 1
+        Ausgabe.insert(1.0, "".join(rv) + "\n")
+
+
 '''

patch-streamlit/index.html

@@ -0,0 +1,47 @@
+<!--
+ Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2025)
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1, shrink-to-fit=no"
+    />
+    <link rel="shortcut icon" href="./favicon.ico" />
+    <link
+      rel="preload"
+      href="./static/media/SourceSansVF-Upright.ttf.BsWL4Kly.woff2"
+      as="font"
+      type="font/woff2"
+      crossorigin
+    />
+
+    <title>tebarius Mysteryhelfer (web)</title>
+
+    <!-- initialize window.prerenderReady to false and then set to true in React app when app is ready for indexing -->
+    <script>
+      window.prerenderReady = false
+    </script>
+    <script type="module" crossorigin src="./static/js/index.BTGIlECR.js"></script>
+    <link rel="stylesheet" crossorigin href="./static/css/index.CJVRHjQZ.css">
+  </head>
+  <body>
+    <noscript>You need to enable JavaScript to run this app.</noscript>
+    <div id="root"></div>
+  </body>
+</html>