peewee Abfrage: Ein Datensatz auslesen und Fehlerresident sein wenn es keinen Datensatz gibt

Hofei · Oct 13th 2019

Hallo,

erstelle aktuell einen Telegram Bot, welchen man Fotos sendet, mit Angabe, in welcher Ordnerstruktur die Fotos abgelegt werden sollen und eine Notiz für die Fotos.

Sind diese Informationen nicht enthalten, werden die Fotos in einer Zwischendatenbank abgelegt.

Führt man den entsprechenden Telegram Befehl aus, dass die undefinierten Fotos verarbeitet werden, so soll der Bot die Fotos als markierte Antwort wieder vorlegen und auf die Informationen warten. Bekommt er die Informationen soll das nächste Foto verarbeitet werden, solange bis in der Zwischendatenbank keine Fotos mehr zwischen gespeichert sind.

Da ich bei Telegram ja wieder auf Antworten warten muss etc. so funktioniert keine einfache for-Schleife über alle abgelegten Fotos. Deshalb hole ich nur einen Datensatz ab, und rufe am Ende die Funktion wieder rekrusiv auf:

Python

   def undefinierte_fotos_verarbeiten(self, message):
        if self.umenue is None:
            undefiniertes_foto = db.FotoUndefiniert.get()
            if len(undefiniertes_foto) > 0:
                self.menue = self.undefinierte_fotos_verarbeiten
            else:
                self.menue = None
                self.umenue = None
                return  # Es sind keine weiteren undefinierten Fotos vorhanden

            self.send_message(chat_id=undefiniertes_foto.chat_id,
                              text="Ordner und Notiz angeben",
                              reply_to_message_id=undefiniertes_foto.message_id)
            self.undefinierte_file_id = undefiniertes_foto.file_id
            self.undefinierte_message_id = undefiniertes_foto.message_id
            self.umenue = 1
        elif self.umenue == 1:
            ordner, notiz = caption_analysieren(message["message"]["text"])
            ordner_db_id = db.ordner_struktur_erstellen(ordner)
            verzeichnis = verzeichnis_erstellen(ordner)

            file_id = db.FotoUndefiniert.select(db.FotoUndefiniert.file_id).where(
                db.FotoUndefiniert.message_id == self.undefinierte_message_id).scalar()
            file, file_path = self.get_file(file_id)
            dateiendung = get_dateiendung(file_path)
            file_name = db.file_speichern(ordner_db_id, notiz, dateiendung)
            datei_speichern(verzeichnis, file_name, file)
            db.FotoUndefiniert.delete().where(db.FotoUndefiniert.message_id == self.undefinierte_message_id).execute()
            self.umenue = None
            self.undefinierte_fotos_verarbeiten("")

Display More

Am besten hätte mir folgender Weg gefallen um das zu realsieren:

Python

def undefinierte_fotos_verarbeiten(self, message):
    if self.umenue is None:
        undefiniertes_foto = db.FotoUndefiniert.get()
        if len(undefiniertes_foto) > 0:
            self.menue = self.undefinierte_fotos_verarbeiten
        else:
            self.menue = None
            self.umenue = None
            return  # Es sind keine weiteren undefinierten Fotos vorhanden

        self.send_message(chat_id=undefiniertes_foto.chat_id,
                          text="Ordner und Notiz angeben",
                          reply_to_message_id=undefiniertes_foto.message_id)
        self.undefinierte_file_id = undefiniertes_foto.file_id
        self.undefinierte_message_id = undefiniertes_foto.message_id
        self.umenue = 1

Display More

len() gibt es aber bei .get() nicht

Fehler

Das hatte ich aber so und so bei dieser Variante nur eingebaut, weil wenn kein Datensatz mehr in der Datenbank vorhanden ist, es zu folgendem Fehler kommt:

Code

Traceback (most recent call last):
...
IndexError: list index out of range

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "G:/Projekte/github/foto_ablage_telegrambot/fotoablage_bot.py", line 178, in <module>
    main()
  File "G:/Projekte/github/foto_ablage_telegrambot/fotoablage_bot.py", line 164, in main
    bot.undefinierte_fotos_verarbeiten("")
  File "G:/Projekte/github/foto_ablage_telegrambot/fotoablage_bot.py", line 51, in undefinierte_fotos_verarbeiten
    undefiniertes_foto = db.FotoUndefiniert.get()
  File "C:\Users\...\AppData\Roaming\Python\Python37\site-packages\peewee.py", line 5644, in get
    return sq.get()
  File "C:\Users\...\AppData\Roaming\Python\Python37\site-packages\peewee.py", line 6047, in get
    (clone.model, sql, params))
db_modell.FotoUndefiniertDoesNotExist: <Model: FotoUndefiniert> instance matching query does not exist:
SQL: SELECT "t1"."message_id", "t1"."chat_id", "t1"."file_id" FROM "fotoundefiniert" AS "t1" LIMIT ? OFFSET ?
Params: [1, 0]

Display More

Die oben gezeigte Struktur würde dann beim rekrusiv aufruf etwas anders ausseden, sonst wär eine Endlosschleife gebaut, aber das betrifft das Problem nicht...

Wie ließe sich der auftretende Fehler db_modell.FotoUndefiniertDoesNotExist: denn gezielt mit try/except abfangen.

das db_modell.FotoUndefiniert kommt wohl über mich zustanden

-> db_modell = Dateiname

-> FotoUndefiniert = Klassenname

Da ich da keine Lösung gefunden habe, wechselte ich von get zu select

Code

def undefinierte_fotos_verarbeiten(self, message):
    if self.umenue is None:
        undefiniertes_foto = db.FotoUndefiniert.select().limit(1).execute()
        if len(undefiniertes_foto) > 0:
            self.menue = self.undefinierte_fotos_verarbeiten
        else:
            self.menue = None
            self.umenue = None
            return  # Es sind keine weiteren undefinierten Fotos vorhanden

        self.send_message(chat_id=undefiniertes_foto.chat_id,
                          text="Ordner und Notiz angeben",
                          reply_to_message_id=undefiniertes_foto.message_id)
        self.undefinierte_file_id = undefiniertes_foto.file_id
        self.undefinierte_message_id = undefiniertes_foto.message_id
        self.umenue = 1
    elif self.umenue == 1:

Display More

Daher kommt auch das len(), denn wenn die Abfrage keine Datensätze enthält funktioniert alles.

Wenn es aber Datensätze enthält, kommt es zu Problemen bei der Verarbeitung, dort wo es mit get() keine Probleme gegeben hat:

Code

Traceback (most recent call last):
  File "G:/Projekte/github/foto_ablage_telegrambot/fotoablage_bot.py", line 178, in <module>
    main()
  File "G:/Projekte/github/foto_ablage_telegrambot/fotoablage_bot.py", line 164, in main
    bot.undefinierte_fotos_verarbeiten("")
  File "G:/Projekte/github/foto_ablage_telegrambot/fotoablage_bot.py", line 59, in undefinierte_fotos_verarbeiten
    self.send_message(chat_id=undefiniertes_foto.chat_id,
AttributeError: 'ModelObjectCursorWrapper' object has no attribute 'chat_id'

Process finished with exit code 1

Auch wenn ich das execute() weg lasse in der Abfrage ist es der selbe Fehler.

Jemand eine Idee?

Hofei · Oct 13th 2019

So, ich muss über das select() iterieren, dann funktioniert es.

Auch wenn die Schleife an der Stelle ziemlich umsonst ist, es funktioniert

Python

    def undefinierte_fotos_verarbeiten(self, message):
        self.menue = self.undefinierte_fotos_verarbeiten
        if self.umenue is None:
            for undefiniertes_foto in db.FotoUndefiniert.select():
                self.send_message(chat_id=undefiniertes_foto.chat_id,
                                  text="Ordner und Notiz angeben",
                                  reply_to_message_id=undefiniertes_foto.message_id)
                self.undefinierte_file_id = undefiniertes_foto.file_id
                self.undefinierte_message_id = undefiniertes_foto.message_id
                self.umenue = 1
                break
            else:
                self.menue = None
                self.umenue = None
        elif self.umenue == 1:
            ordner, notiz = caption_analysieren(message["message"]["text"])
            ordner_db_id = db.ordner_struktur_erstellen(ordner)
            verzeichnis = verzeichnis_erstellen(ordner)

            file_id = db.FotoUndefiniert.select(db.FotoUndefiniert.file_id).where(
                db.FotoUndefiniert.message_id == self.undefinierte_message_id).scalar()
            file, file_path = self.get_file(file_id)
            dateiendung = get_dateiendung(file_path)
            file_name = db.file_speichern(ordner_db_id, notiz, dateiendung)
            datei_speichern(verzeichnis, file_name, file)
            db.FotoUndefiniert.delete().where(db.FotoUndefiniert.message_id == self.undefinierte_message_id).execute()
            self.umenue = None
            self.menue = None

Display More

noisefloor · Oct 13th 2019

Hallo,

Quote

So, ich muss über das select() iterieren, dann funktioniert es.

Genau. `get` ist der falsche Ansatz, weil `get` ja nur genau einen Datensatz liefert. Und wenn wäre sowie so `get_or_none` besser gewesen.

Quote

Auch wenn die Schleife an der Stelle ziemlich umsonst ist, es funktioniert

Wieso umsonst? Das ist doch genau das, was du willst. Besser als Rekursion, weil Rekursion in Python eigentlich nie gut ist.

Was soll denn das `break`? Ich davon würde ich Schleife denke ich so bauen:

Code

...
undefinierte_fotos = db.FotoUndefiniert.select():
if undefinierte_fotos:
    for undefiniertes_foto in undefinierte_fotos:
        #do something
...

Gruß, noisefloor

Hofei · Oct 13th 2019

Quote from noisefloor

Was soll denn das `break`? Ich davon würde ich Schleife denke ich so bauen:

Weil ich die Schleife verlassen muss, um die Antwort dann in umenue == 1 zu verarbeiten.

Deswegen ja auch, dass die Schleife an sich umsonst ist.

noisefloor · Oct 13th 2019

Hallo,

nee, wieso? Wenn du ein Erebnis der DB-Abfrage hast, dann wird umenue zwangsläufig gleich 1. Von daher kannst du doch den ganzen `elfI umenue==1` Block mit _in_ die for-Schleife packen.

Gruß, noisefloor

Hofei · Oct 13th 2019

Ne, da hast du jetzt einen Denkfehler, denn der If Elif Block wird nur einmal abgearbeitet

->

Code

a = 1
if a == 1:
    print(a)
    a += 1
elif a == 2:
    print(a)

Code

1

Process finished with exit code 0

Somit wird zunächst die Funktion wieder verlassen, und erst wieder betreten wenn eine Antwort in Telegram gesendet worden ist und da steigt er dann im Programmblock bei umenue==1 ein.

Und im Else Block setze ich ja auf None, nicht auf 1.

Sofern Interesse, so sieht aktuell der Gesamtcode aus, wenn gleich wieder mit Englisch Deutsch vermischt. Iwann schaff ich das mal mir abzugewöhnen,vielleicht.

Python

import os
import time

import toml
from peewee import SqliteDatabase

import db_modell as db
from telegram_api import telegram_bot_api as api


def load_config():
    configfile = os.path.join(SKRIPTPFAD, "config_fotobot.toml")
    with open(configfile) as conffile:
        config = toml.loads(conffile.read())
    return config 
 
 
SKRIPTPFAD = os.path.abspath(os.path.dirname(__file__))       
CONFIG = load_config()
# Nur für Testzwecke!
CONFIG["root_verzeichnis"] = SKRIPTPFAD

db.DB_PROXY.initialize(SqliteDatabase(os.path.join(SKRIPTPFAD, "datenbank.db3")))


class FotoBot(api.Bot):
    def __init__(self, token):
        super().__init__(token)
        
        self.menue = None
        self.umenue = None

        self.undefinierte_file_id = None
        self.undefinierte_message_id = None
        
        self.bot_kommando = {
            "undefiniertefotos": self.undefinierte_fotos_verarbeiten
        }
        
    def message_handler(self, message):
        if self.menue is not None:
            self.menue(message)
            return
    
    def bot_kommando_exec(self, kommando, message):
        self.menue = self.bot_kommando.get(kommando, self.kommando_unbekannt)
        self.menue(message)

    def undefinierte_fotos_verarbeiten(self, message):
        self.menue = self.undefinierte_fotos_verarbeiten
        if self.umenue is None:
            for undefiniertes_foto in db.FotoUndefiniert.select():
                self.send_message(chat_id=undefiniertes_foto.chat_id,
                                  text="Ordner und Notiz angeben",
                                  reply_to_message_id=undefiniertes_foto.message_id)
                self.undefinierte_file_id = undefiniertes_foto.file_id
                self.undefinierte_message_id = undefiniertes_foto.message_id
                self.umenue = 1
                break
            else:
                self.menue = None
                self.umenue = None
        elif self.umenue == 1:
            ordner, notiz = caption_analysieren(message["message"]["text"])
            ordner_db_id = db.ordner_struktur_erstellen(ordner)
            verzeichnis = verzeichnis_erstellen(ordner)

            file_id = db.FotoUndefiniert.select(db.FotoUndefiniert.file_id).where(
                db.FotoUndefiniert.message_id == self.undefinierte_message_id).scalar()
            file, file_path = self.get_file(file_id)
            dateiendung = get_dateiendung(file_path)
            file_name = db.file_speichern(ordner_db_id, notiz, dateiendung)
            datei_speichern(verzeichnis, file_name, file)
            db.FotoUndefiniert.delete().where(db.FotoUndefiniert.message_id == self.undefinierte_message_id).execute()
            self.umenue = None
            self.menue = None

    @staticmethod
    def kommando_unbekannt(_):
        print("Unbekannt")
    

def verzeichnis_erstellen(ordner):
    verzeichnis = os.path.join(CONFIG["root_verzeichnis"], *ordner)
    os.makedirs(verzeichnis, mode=0o660, exist_ok=True)
    return verzeichnis


def get_biggest_size(photos):
    max_file_size = 0
    max_index = None
    for index, photo in enumerate(photos):
        if photo["file_size"] > max_file_size:
            max_index = index
    return max_index
    

def datei_speichern(verzeichnis, file_name, inhalt):
    file = os.path.join(verzeichnis, file_name)
    with open(file, "wb") as file_:
        file_.write(inhalt)


def caption_analysieren(caption):
    caption_split = caption.split(";")
    ordner = caption_split[0].split(",")
    ordner = [ordner_einzel.replace(" ", "") for ordner_einzel in ordner]
    try:
        notizen = caption_split[1]
        if notizen.startswith(" "):
            notizen = notizen.replace(" ", "", 1)
    except IndexError:
        notizen = []
    return ordner, notizen


def get_dateiendung(file_path):
    return file_path.split(".")[-1]


def nachricht_auswerten(bot, message):
    absender = message["message"]["from"].get("id", 0)
    if absender not in CONFIG["erlaubte_telegram_ids"]:
        bot.send_message(absender, "User nicht freigegeben")
        return
    if bot.menue is None:
        if "entities" in message["message"]:
            if "bot_command" in message["message"]["entities"][0]["type"]:  
                text = message["message"]["text"]
                kommando = text.replace("/", "")
                bot.bot_kommando_exec(kommando, message)

        if "photo" in message["message"]:
            max_index = get_biggest_size(message["message"]["photo"])
            if "caption" in message["message"]:
                ordner, notiz = caption_analysieren(message["message"]["caption"])
                ordner_db_id = db.ordner_struktur_erstellen(ordner)
                verzeichnis = verzeichnis_erstellen(ordner)

                file, file_path = bot.get_file(message["message"]["photo"][max_index]["file_id"])
                dateiendung = get_dateiendung(file_path)
                file_name = db.file_speichern(ordner_db_id, notiz, dateiendung)
                datei_speichern(verzeichnis, file_name, file)

            else:
                bot.send_message(chat_id=absender,
                                 text="Bild kann nicht verabeitet werden, Ordner wurde nicht angegeben",
                                 reply_to_message_id=message["message"]["message_id"])
                db.FotoUndefiniert.create(message_id=message["message"]["message_id"],
                                          chat_id=absender,
                                          file_id=message["message"]["photo"][max_index]["file_id"])

    else:
        bot.menue(message)


def main():
    bot = FotoBot(CONFIG["token"])
    db.db_create_table()
    db.update_root_verzeichnis(CONFIG["root_verzeichnis"])

    while True:
        nachricht_vorhanden = False
        for message in bot.get_updates():
            nachricht_vorhanden = True
            nachricht_auswerten(bot, message)
            
        if not nachricht_vorhanden and bot.menue is None:
            break
        time.sleep(0.1)
            
            
if __name__ == "__main__":
    main()

Display More

noisefloor · Oct 13th 2019

Hallo,

Quote

Ne, da hast du jetzt einen Denkfehler, denn der If Elif Block wird nur einmal abgearbeitet

Ach so, dass ganze ist kein vorlaufender Prozess, also du _musst_ nicht das Bearbeiten eines undefinierten Fotos abschließen, wenn du dir angeben lässt, welche Fotos ohne Ordner / Text gesendet wurden?

Warum packst du nicht die Funktionen nicht auch in die Klasse? Ich sehe da gerade keine Grund für die Trennung (wobei ich mir zugegebener Maßen den Code nicht sooo genau angeschaut habe...).

Gruß, noisefloor

Hofei · Oct 14th 2019

Ist das Zitat wirklich für mich gedacht? Wenn ja verstehe ich die Bedeutung nicht.

noisefloor · Oct 14th 2019

Hallo,

Hofei : ups - nee, das ist aus einem anderem Forum. Habe das Zitat korrigiert.

Gruß, noisefloor

Hofei · Oct 16th 2019

Du meinst also, die Funktion gar nicht verlassen, sondern innerhalb dieser auf die Antwort des Benutzers warten.

Das wäre in der Tat auch eine Möglichkeit.

Aktuell verlässt er seinen "Menüpunkt" (Funktion) wieder, und speichert aktuelles Menü und Untermenü in den Attributen menue und umenue zwischen. Bei einer neuen Antwort weiß somit das Programm, wo es zurückkehren muss und die Nachricht an passender Stelle zu verarbeiten. Hat auch den Vorteil, dass es sich so leichter erweitern lässt, wenn es mehrere Useranfragen verarbeiten soll, wie bei meinen Wetterbot. Von da hab ich mir auch das mit menue und umenue einfallen lassen und warum von etwas bewährten abweichen