2 Skripte kombinieren (sched + discord.py)

Hofei · April 15, 2024 at 4:28 PM

Hallo zusammen,

mein Ziel ist es einen eigenen Discord Erinnerungsbot zu erstellen, der aus dem jeweiligen Eintrag aus der data.toml wöchentlich eine Erinnerung in Discord schickt. Die Uhrzeit und Wochentag lässt sich aus date entnehmen, wann das Ereignis stattfindet. Anschließend wird noch eine Vorlaufzeit (remind_offset) abgezogen, sodass die Erinnerung um x Minuten vor Stattfinden des Ereignisses abgeschickt wird. Um die Ereignisse innerhalb von Python zu erstellen und planen, verwende ich die Modul sched. Dieser Part funktioniert auch nach meinen Vorstellungen, solange die Ausgabe mit einem print() erfolgt und nicht die wirkliche Erinnerung über Discord gesendet wird. Ebenfalls funktioniert ein alleinstehendes Discord Skript, mit dem ich nach Start des Skriptes eine Testnachricht an den gewünschten Discord Server und Kanal sende. Mein Problem tritt auf sobald ich beides vereinen möchte, vermutlich auf Grund meiner mangelnden Kenntnisse von async. Bzw. diese beiden Befehle vertragen sich nicht: client.run(toml.load("config.toml")["dc_token"]) und scheduler.run(blocking=True). Ändere ich das blocking in False funktioniert es auch nicht mehr. Bei einer Kombination habe ich es zwar geschafft beides zu vereinen aber dann bekomme ich Fehler von async wie diese hier

Code

[<coroutine object create_territory_capture at 0x04C19568>,
 <coroutine object create_territory_capture at 0x04C190A8>,
 <coroutine object create_territory_capture at 0x04C192E8>,
 <coroutine object create_territory_capture at 0x04C190E8>,
 <coroutine object create_territory_capture at 0x04C19168>,
 <coroutine object create_territory_capture at 0x04C196A8>,
 <coroutine object create_territory_capture at 0x04C196E8>]
C:\Users\***\Nextcloud\P_Python\tabellenanzeige\dc_kombi.py:60: RuntimeWarning: coroutine 'create_territory_capture' was never awaited
  create_territory_captures_after_start(scheduler,
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
Exception ignored in: <function _ProactorBasePipeTransport.__del__ at 0x0389CA00>
Traceback (most recent call last):
  File "C:\Users\***\AppData\Local\Programs\Python\Python38-32\lib\asyncio\proactor_events.py", line 116, in __del__
  File "C:\Users\***\AppData\Local\Programs\Python\Python38-32\lib\asyncio\proactor_events.py", line 108, in close
  File "C:\Users\***\AppData\Local\Programs\Python\Python38-32\lib\asyncio\base_events.py", line 719, in call_soon
  File "C:\Users\***\AppData\Local\Programs\Python\Python38-32\lib\asyncio\base_events.py", line 508, in _check_closed
RuntimeError: Event loop is closed

Display More

Zugehöriger Kombinationsversuch:

Python: dc_kombi.py

import datetime
import pprint
import toml
import sched
import time
import utils
import discord

REMIND_OFFSET = toml.load("data.toml")["remind_offset"]
WORK_CHANNEL_NAME = toml.load("config.toml")["channel"]

intents = discord.Intents.default()
client = discord.Client(intents=intents)


def search_work_channel(work_channel_name):
    channels = client.get_all_channels()
    work_channel = None
    for channel in channels:
        if str(channel) == work_channel_name:
            work_channel = client.get_channel(channel.id)
            break
    return work_channel


async def send_reminder(scheduler, remind_offset, territory, text, target_ts, _):
    workchannel = search_work_channel(WORK_CHANNEL_NAME)
    print(f"Verteidigung {territory['system']} um {datetime.datetime.fromtimestamp(target_ts)}")
    print(text)
    pprint.pprint(create_territory_capture(scheduler, remind_offset, territory))
    await workchannel.send("Hello World")


async def create_territory_capture(scheduler, remind_offset, territory):
    target_ts = utils.get_target_ts(territory["date"], remind_time_offset=remind_offset)
    remind_ts = utils.get_remind_ts(target_ts, remind_offset)
    return scheduler.enterabs(remind_ts, 1, send_reminder,
                              (scheduler,
                               remind_offset,
                               territory,
                               "Text...",
                               target_ts,
                               datetime.datetime.fromtimestamp(target_ts)))


def create_territory_captures_after_start(scheduler, remind_offset, territories):
    reminders = []
    for territory in territories:
        reminders.append(create_territory_capture(scheduler, remind_offset, territory))
    pprint.pprint(reminders)


@client.event
async def on_ready():
    main()


def main():
    scheduler = sched.scheduler(time.time, time.sleep)
    create_territory_captures_after_start(scheduler,
                                          REMIND_OFFSET,
                                          toml.load("data.toml")["territories"])
    scheduler.run(blocking=True)


if __name__ == "__main__":
    client.run(toml.load("config.toml")["dc_token"])

Display More

Auch habe ich schon damit begonnen blind await und async bei diversen Funktionen einzubauen, aber leider noch kein Erfolg.

Im Anschluss poste ich die getrennten Varianten, die soweit funktionieren, inkl der data.toml.

Python: gebietserinnerung.py

import datetime
import pprint
import toml
import sched
import time
import utils


REMIND_OFFSET = toml.load("data.toml")["remind_offset"]


def send_reminder(scheduler, remind_offset, territory, text, target_ts, _):
    print(f"Verteidigung {territory['system']} um {datetime.datetime.fromtimestamp(target_ts)}")
    print(text)
    pprint.pprint(create_territory_capture(scheduler, remind_offset, territory))


def create_territory_capture(scheduler, remind_offset, territory):
    target_ts = utils.get_target_ts(territory["date"], remind_time_offset=remind_offset)
    remind_ts = utils.get_remind_ts(target_ts, remind_offset)
    return scheduler.enterabs(remind_ts, 1, send_reminder,
                              (scheduler,
                               remind_offset,
                               territory,
                               "Text...",
                               target_ts,
                               datetime.datetime.fromtimestamp(target_ts)))


def create_territory_captures_after_start(scheduler, remind_offset, territories):
    reminders = []
    for territory in territories:
        reminders.append(create_territory_capture(scheduler, remind_offset, territory))
    pprint.pprint(reminders)


def main():
    scheduler = sched.scheduler(time.time, time.sleep)
    create_territory_captures_after_start(scheduler,
                                          REMIND_OFFSET,
                                          toml.load("data.toml")["territories"])
    scheduler.run(blocking=True)


if __name__ == "__main__":
    main()

Display More

Python: utils.py

import datetime
import pytz


def weekday_mapping(weekday):
    weekdays = {
        "Montag": 0,
        "Dienstag": 1,
        "Mittwoch": 2,
        "Donnerstag": 3,
        "Freitag": 4,
        "Samstag": 5,
        "Sonntag": 6,
    }
    return weekdays[weekday]


def get_target_datetime(date_string, current_datetime, remind_time_offset=0):
    weekday = date_string.split()[0]
    time_ = date_string.split()[1].split(":")
    target_datetime_utc = datetime.datetime.today().replace(hour=int(time_[0]), minute=int(time_[1]),
                                                            second=0, microsecond=0,
                                                            tzinfo=pytz.utc)
    target_datetime = target_datetime_utc.astimezone(pytz.timezone('Europe/Berlin'))
    weekdaynumber = weekday_mapping(weekday)
    one_day = datetime.timedelta(days=1)

    while True:
        if target_datetime.weekday() == weekdaynumber:
            if target_datetime > current_datetime + datetime.timedelta(minutes=remind_time_offset):
                break
            else:
                target_datetime = target_datetime + one_day
        else:
            target_datetime = target_datetime + one_day
    return target_datetime


def get_remaining_time(date_string):
    current_datetime_utc = datetime.datetime.utcnow().replace(tzinfo=pytz.utc)
    current_datetime = current_datetime_utc.astimezone(pytz.timezone('Europe/Berlin'))
    target_datetime = get_target_datetime(date_string, current_datetime)
    remaining_time = target_datetime - current_datetime
    return int(remaining_time.total_seconds() * 1000)


def get_target_ts(date_string, remind_time_offset=0):
    current_datetime_utc = datetime.datetime.utcnow().replace(tzinfo=pytz.utc)
    current_datetime = current_datetime_utc.astimezone(pytz.timezone('Europe/Berlin'))
    target_datetime = get_target_datetime(date_string, current_datetime, remind_time_offset)
    return target_datetime.timestamp()


def get_remind_ts(target_ts, remind_offset):
    return (datetime.datetime.fromtimestamp(target_ts) - datetime.timedelta(minutes=remind_offset)).timestamp()

Display More

Code: data.toml

remind_offset = 120  # minutes

[[territories]]
system = "Test"
kategorie = 1
ressource = "Testxyz"
date = "Montag 16:16"
other_data = "Quantenteilchen, Forschungsverstärker"
priority = 0

[[territories]]
system = "Otima"
kategorie = 1
ressource = "Parstahl, Iso2"
date = "Mittwoch 10:00"
other_data = "Quantenteilchen, Forschungsverstärker"
priority = 0

Display More

Python: dc_alleine.py

import discord
import toml


WORK_CHANNEL_NAME = toml.load("config.toml")["channel"]

intents = discord.Intents.default()
client = discord.Client(intents=intents)


def search_work_channel(work_channel_name):
    channels = client.get_all_channels()
    work_channel = None
    for channel in channels:
        if str(channel) == work_channel_name:
            work_channel = client.get_channel(channel.id)
            break
    return work_channel


async def send_reminder(text):
    workchannel = search_work_channel(WORK_CHANNEL_NAME)
    await workchannel.send(text)


@client.event
async def on_ready():
    await send_reminder("Hello World")


if __name__ == "__main__":
    client.run(toml.load("config.toml")["dc_token"])

Display More

Im Grunde muss ich es schaffen, dass die Funktion ab Zeile 12 in gebietserinnerung.py def send_reminder(scheduler, remind_offset, territory, text, target_ts, _): statt der print Ausgabe den gewünschten Inhalt in Discord sendet. Aktuell weiß ich aber nicht mehr weiter wie ich das kombinieren kann und hoffe auf eure Hilfe.

Bot · Vor 5 Minuten

2 Skripte kombinieren (sched + discord.py)? Schau mal ob du hier fündig wirst!

Hofei · April 15, 2024 at 6:44 PM

Hallo,

mir ist jetzt tatsächlich eine funktionierende Lösung eingefallen, weshalb ich meinen Eingangspost nicht editieren wollte, sondern die Lösung in einem separaten Post herzeigen möchte. Die Lösung ist zwar nicht elegant, aber sie funktioniert. Mittels subprocess starte ich beim Eintreten des Ereignisses das Discord Skript und übergebe dabei als Parameter den zu postenden Text, anschließend kann sich der Discord Bot sofort wieder beenden.

Skript welches Dauerhaft läuft:

Python

import datetime
import pprint
import toml
import sched
import time
import utils
import subprocess
import sys

DATA = toml.load("data.toml")
REMIND_OFFSET = DATA["remind_offset"]


def create_text(territory, target_datetime):
    text = (f"**{DATA['ueberschrift']} {territory['system']} {target_datetime.strftime('am %d. %B')}**\n"
            f"{DATA['text'][0]} {territory['system']} {target_datetime.strftime('ist um %H:%M Uhr')}\n"
            f"{DATA['text'][1]} {toml.load('config.toml')['rule_link']}")
    return text


def send_reminder(scheduler, remind_offset, territory, target_datetime):
    text = create_text(territory, target_datetime)
    subprocess.run([sys.executable, "dc_start.py", text], check=False)
    pprint.pprint(create_territory_capture(scheduler, remind_offset, territory))


def create_territory_capture(scheduler, remind_offset, territory):
    target_ts = utils.get_target_ts(territory["date"], remind_time_offset=remind_offset)
    remind_ts = utils.get_remind_ts(target_ts, remind_offset)
    return scheduler.enterabs(remind_ts, 1, send_reminder,
                              (scheduler,
                               remind_offset,
                               territory,
                               datetime.datetime.fromtimestamp(target_ts)))


def create_territory_captures_after_start(scheduler, remind_offset, territories):
    reminders = []
    for territory in territories:
        reminders.append(create_territory_capture(scheduler, remind_offset, territory))
    pprint.pprint(reminders)


def main():
    scheduler = sched.scheduler(time.time, time.sleep)
    create_territory_captures_after_start(scheduler,
                                          REMIND_OFFSET,
                                          toml.load("data.toml")["territories"])
    scheduler.run(blocking=True)


if __name__ == "__main__":
    main()

Display More

und hier das Skript, welches durch subproccess aufgerufen wird

Python

import discord
import toml
import sys


CONFIG = toml.load("config.toml")

intents = discord.Intents.default()
client = discord.Client(intents=intents)


async def get_role_id(ctx, role_name):
    for role in ctx.guild.roles:
        if role.name == role_name:
            return role.mention


def search_work_channel(work_channel_name):
    channels = client.get_all_channels()
    work_channel = None
    for channel in channels:
        if str(channel) == work_channel_name:
            work_channel = client.get_channel(channel.id)
            break
    return work_channel


async def send_reminder(text):
    workchannel = search_work_channel(CONFIG["channel"])
    role = await get_role_id(workchannel, CONFIG["role"])
    await workchannel.send(f"{role}: {text}")
    exit(0)


@client.event
async def on_ready():
    await send_reminder(sys.argv[1])


if __name__ == "__main__":
    client.run(toml.load("config.toml")["dc_token"])

Display More

und zur Vollständigkeit noch utils und data.toml

Python

import datetime
import pytz


def weekday_mapping(weekday):
    weekdays = {
        "Montag": 0,
        "Dienstag": 1,
        "Mittwoch": 2,
        "Donnerstag": 3,
        "Freitag": 4,
        "Samstag": 5,
        "Sonntag": 6,
    }
    return weekdays[weekday]


def get_target_datetime(date_string, current_datetime, remind_time_offset=0):
    weekday = date_string.split()[0]
    time_ = date_string.split()[1].split(":")
    target_datetime_utc = datetime.datetime.today().replace(hour=int(time_[0]), minute=int(time_[1]),
                                                            second=0, microsecond=0,
                                                            tzinfo=pytz.utc)
    target_datetime = target_datetime_utc.astimezone(pytz.timezone('Europe/Berlin'))
    weekdaynumber = weekday_mapping(weekday)
    one_day = datetime.timedelta(days=1)

    while True:
        if target_datetime.weekday() == weekdaynumber:
            if target_datetime > current_datetime + datetime.timedelta(minutes=remind_time_offset):
                break
            else:
                target_datetime = target_datetime + one_day
        else:
            target_datetime = target_datetime + one_day
    return target_datetime


def get_remaining_time(date_string):
    current_datetime_utc = datetime.datetime.utcnow().replace(tzinfo=pytz.utc)
    current_datetime = current_datetime_utc.astimezone(pytz.timezone('Europe/Berlin'))
    target_datetime = get_target_datetime(date_string, current_datetime)
    remaining_time = target_datetime - current_datetime
    return int(remaining_time.total_seconds() * 1000)


def get_target_ts(date_string, remind_time_offset=0):
    current_datetime_utc = datetime.datetime.utcnow().replace(tzinfo=pytz.utc)
    current_datetime = current_datetime_utc.astimezone(pytz.timezone('Europe/Berlin'))
    target_datetime = get_target_datetime(date_string, current_datetime, remind_time_offset)
    return target_datetime.timestamp()


def get_remind_ts(target_ts, remind_offset):
    return (datetime.datetime.fromtimestamp(target_ts) - datetime.timedelta(minutes=remind_offset)).timestamp()

Display More

Code

remind_offset = 120  # minutes
ueberschrift = "Verteidigung von"
text = ["Beginn der Verteidigung von", "Wir bitten um zahlreiches erscheinen! Außerdem beachten:"]

[[territories]]
system = "Test"
kategorie = 1
ressource = "Testxyz"
date = "Montag 18:38"
other_data = "Quantenteilchen, Forschungsverstärker"
priority = 1


[[territories]]
system = "Thaylen"
kategorie = 1
ressource = "Dilithium, Iso2"
date = "Mittwoch 12:00"
other_data = "Quantenteilchen, Armadakampfverstärker, Kinetische Waffenverstärker"
priority = 1

Display More

Obwohl ich nun eine funktionierende Lösung habe, würde es mich dennoch interessieren, wie und ob es anders auch zu lösen ist.

Dennis89 · April 15, 2024 at 8:39 PM

Hi,

kurze Zwischenfrage, ich habe mal die Fehlermeldung gegooglt und bin zwei mal auf diese Lösung gestoßen:

"Asyncio Event Loop is Closed" when getting loop

When trying to run the asyncio hello world code example given in the docs: import asyncio async def hello_world(): print("Hello World!") loop =…

stackoverflow.com

Hast du das schon probiert?

Grüße

Dennis

Bot · Vor einem Moment

Schau mal ob du hier fündig wirst:

Hofei · April 15, 2024 at 9:10 PM

Nein, mir wäre jetzt aber auch die Stelle nicht bekannt, an der ich die loop bewusst schließe, sodass ich an der Stelle die loop wieder neu starten müsste. An welcher Stelle würdest du die loop neu starten? Genau in der Zeile bzw. eine zuvor wo der Fehler auftritt? Oder meinst du gar nicht das neustarten sondern viel mehr diesen Teil hier?

Code

import platform
if platform.system()=='Windows':
    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())

Zu Problemen wird es bestimmt deswegen kommen, da discord.py mit asyncroner Programmierung arbeitet (wo ich mir immer sehr schwer tue) und sched Multi Thread tauglich ist. Aber reine Vermutung....

Dennis89 · April 15, 2024 at 9:21 PM

Ja ich meinte eher den Teil, da du Windows nutzt, und ein User auf SO geschrieben hat, dass es da seit einer Änderung Probleme gibt, hätte ich es vermutlich mal so versucht:

Code

import datetime
import pprint
import toml
import sched
import time
import utils
import discord
import asyncio

REMIND_OFFSET = toml.load("data.toml")["remind_offset"]
WORK_CHANNEL_NAME = toml.load("config.toml")["channel"]

intents = discord.Intents.default()
client = discord.Client(intents=intents)


def search_work_channel(work_channel_name):
    channels = client.get_all_channels()
    work_channel = None
    for channel in channels:
        if str(channel) == work_channel_name:
            work_channel = client.get_channel(channel.id)
            break
    return work_channel


async def send_reminder(scheduler, remind_offset, territory, text, target_ts, _):
    workchannel = search_work_channel(WORK_CHANNEL_NAME)
    print(f"Verteidigung {territory['system']} um {datetime.datetime.fromtimestamp(target_ts)}")
    print(text)
    pprint.pprint(create_territory_capture(scheduler, remind_offset, territory))
    await workchannel.send("Hello World")


async def create_territory_capture(scheduler, remind_offset, territory):
    target_ts = utils.get_target_ts(territory["date"], remind_time_offset=remind_offset)
    remind_ts = utils.get_remind_ts(target_ts, remind_offset)
    return scheduler.enterabs(remind_ts, 1, send_reminder,
                              (scheduler,
                               remind_offset,
                               territory,
                               "Text...",
                               target_ts,
                               datetime.datetime.fromtimestamp(target_ts)))


def create_territory_captures_after_start(scheduler, remind_offset, territories):
    reminders = []
    for territory in territories:
        reminders.append(create_territory_capture(scheduler, remind_offset, territory))
    pprint.pprint(reminders)


@client.event
async def on_ready():
    scheduler = sched.scheduler(time.time, time.sleep)
    create_territory_captures_after_start(scheduler,
                                          REMIND_OFFSET,
                                          toml.load("data.toml")["territories"])
    scheduler.run(blocking=True)


def main():
    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
    client.run(toml.load("config.toml")["dc_token"])


if __name__ == "__main__":
    main()

Display More

Grüße

Dennis

Hofei · April 15, 2024 at 9:38 PM

Teilerfolg, das Skript stürzt nicht ab, gibt jedoch dennoch gleich nach Start einer Meldung aus. Eine Nachricht an Discord kommt aber noch nicht an. Dann werde ich mal versuchen diese awaited Meldungen noch zu beheben.

Code

C:\Users\***\Nextcloud\P_Python\tabellenanzeige\test.py:57: RuntimeWarning: coroutine 'create_territory_capture' was never awaited
  create_territory_captures_after_start(scheduler,
RuntimeWarning: Enable tracemalloc to get the object allocation traceback

Bot · Vor einem Moment

Schau mal ob du hier fündig wirst:

Dennis89 · April 15, 2024 at 9:50 PM

Aus dem Bauch raus (habe das noch nie wirklich gebraucht):

Code

@client.event
async def on_ready():
    scheduler = sched.scheduler(time.time, time.sleep)
    await create_territory_captures_after_start(scheduler,
                                          REMIND_OFFSET,
                                          toml.load("data.toml")["territories"])
    scheduler.run(blocking=True)

Dennis89 · April 15, 2024 at 10:38 PM

Beim schauen, was der Code so macht, sind mir zwei, drei Sachen aufgefallen, falls es dich interessiert:

`search_work_channel' könnte man kompakter schreiben. Ich würde `channels` nicht extra als Name vergeben, sondern direkt über `client.get_all_channels()` iterieren. `work_channel` würde ich auch nicht mit `None` vorbelgen, weil `client.get_channel` gibt `None` zurück wenn die ID nicht gefunden wid. Aber eigentlich ist das auch egal, ich würde die `if`-Abfrage bei Erfolg mit return verlassen und ansonsten gibt die Funktion automatisch `None` zurück.

In `send_reminder` wird es zu einem `AttributError` kommen, falls `workchannel` tatsächlich mal `None` sein sollte.

Ich weis du magst list-comprehensions nicht sonderlich, ich finde es in `create_territory_captures_after_start` lesbarer.

Jetzt müsste man noch was dagegen tun, das `client` global verfügbar ist und dafür `data.toml` und `config.toml` als Konstanten definieren.

Würde dann so aussehen (für `client` fällt mir gerade nocht nichts ein):

Python

import asyncio
import sched
import time
from datetime import datetime
from pathlib import Path
from pprint import pprint

import discord
import toml
import utils

FILE_PATH = Path(__file__).parent
DATA_FILE = toml.load(FILE_PATH / "data.toml")
CONFIG_FILE = toml.load(FILE_PATH / "config.toml")

client = discord.Client(intents=discord.Intents.default())


def search_work_channel(work_channel_name):
    for channel in client.get_all_channels():
        if str(channel) == work_channel_name:
            return client.get_channel(channel.id)


async def send_reminder(scheduler, remind_offset, territory, text, target_ts, _):
    work_channel = search_work_channel(CONFIG_FILE["channel"])
    print(f"Verteidigung {territory['system']} um {datetime.fromtimestamp(target_ts)}")
    print(text)
    pprint(create_territory_capture(scheduler, remind_offset, territory))
    if work_channel is not None:
        await work_channel.send("Hello World")


async def create_territory_capture(scheduler, remind_offset, territory):
    target_ts = utils.get_target_ts(territory["date"], remind_time_offset=remind_offset)
    remind_ts = utils.get_remind_ts(target_ts, remind_offset)
    return scheduler.enterabs(
        remind_ts,
        1,
        send_reminder,
        (
            scheduler,
            remind_offset,
            territory,
            "Text...",
            target_ts,
            datetime.fromtimestamp(target_ts),
        ),
    )


async def create_territory_captures_after_start(scheduler, remind_offset, territories):
    pprint(
        [
            create_territory_capture(scheduler, remind_offset, territory)
            for territory in territories
        ]
    )


@client.event
async def on_ready():
    scheduler = sched.scheduler(time.time, time.sleep)
    await create_territory_captures_after_start(
        scheduler, DATA_FILE["remind_offset"], DATA_FILE["territories"]
    )
    scheduler.run(blocking=True)


def main():
    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
    client.run(CONFIG_FILE["dc_token"])


if __name__ == "__main__":
    main()

Display More

Grüße

Dennis

__blackjack__ · April 15, 2024 at 11:17 PM

In on_ready() wird Code aufgerufen der unendlich lange läuft aber nie ein await ausführt. Das darf man in async Funktionen nicht machen weil dann alles blockiert. Nicht-blockierend geht auch nicht so einfach weil das bei `sched` dann über einen Thread gelöst ist, und man darf nicht einfach so async Funktionen aus anderen Threads heraus aufrufen. Im Grunde das gleich Thema wie bei Rückruffunktionen in GUI-Rahmenwerken.

Lesestoff aus der asyncio-Dokumentation: Concurrency and Multithreading.

Bot · Vor einem Moment

Schau mal ob du hier fündig wirst:

Hofei · April 16, 2024 at 4:08 PM

Der Lesestoff beweist mir einmal mehr, dass ich viel zu wenig asyncio verstehe.

Durch deine Antwort __blackjack__ fühle ich mich bestätigt, dass asyncio (discord.py) und sched einfach wirklich nicht gut zusammen passen und ich mit meiner gezeigten Lösung aus #2 mit subprocess gut fahre. Somit werde ich mal beginnen dem Code aus #2 den Feinschliff zu verpassen.

Vielen Dank für eure Hilfe

noisefloor · April 17, 2024 at 2:26 PM

Quote from Hofei

Der Lesestoff beweist mir einmal mehr, dass ich viel zu wenig asyncio verstehe.

Zu deiner Ehrenrettung: Das Probleme hatte / habe ich auch latent. Also ich verstehe schon vom Prinzip, wie asyncio funktioniert - aber ich habe auch keine Anwendung dafür und damit keine Praxiserfahrung. Bei asyncio kommt IMHO noch dazu, dass man das auch nicht "mal einfach so" ausprobiert bzw. die "Hallo Welt" asyncio Bespiele mega-trivial sind und damit eine ziemlich große Lücke zu realen Anwendungen kommt.

Wobei halt zusätzliche Threads im asyncio Loop schon ein bisschen schwierig vorzustellen ist - das ist ja Nebenläufigkeit in der Nebenläufigkeit.

Gruß, noisefloor

__blackjack__ · April 17, 2024 at 2:49 PM

Hofei Naja, `subprocess` um aus Python Python zu starten für etwas was eigentlich *ein* Programm ist, ist keine gute Lösung. `asyncio` und Threads passen insoweit zusammen, das der Link ja beschreibt wie man von anderen Threads aus async-Coroutinen anstossen kann. Also genau das was hier gesucht ist.

`get_remaining_time()` wird nirgends aufgerufen. Da ist auch Code drin den es noch mal in `get_target_ts()` gibt. Wenn man die Funktion also nicht entfernt, sollte man den gemeinsamen Code in eine weitere Funktion auslagern.

`timestamp()` und `fromtimestamp()` wird zu oft benutzt. Wenn ich das richtig sehe sollte man da nicht immer sinnlos hin und her wandeln, denn eigentlich braucht man nur *einen* `timestamp()` aufruf und gar keinen `fromtimestamp()`, denn nur an einer einzigen Stelle wird tatsächlich der klassische Unix-Timestamp benötigt. Und dann wird die `get_remind_ts()` so trivial — eine einfache Subtraktion der beiden Argumente, dass man die Funktion weg lassen kann.

Thema Umwandlungen: Man sollte möglichst schnell, wenn Daten das Programm betreten in einen passenden Datentyp umwandeln. Also Beispielsweise `remind_offset` gleich nach dem man es aus der Konfiguration holt in ein `timedelta`-Objekt umwandeln, statt die nackte Zahl herum zu reichen und dann an mehr als einer Stelle in ein `timedelta`-Objekt umzuwandeln.

`get_target_ts()` ist ein komischer Zwischenschritt. Statt das aufzurufen was dann `get_target_datetime()` mit einem Argument mehr aufruft, würde man eher eine Funktion schreiben die dieses Argument erstellt. Das wäre ja auch genau die Funktion die man herausziehen würde wenn `get_remaining_time()` im Quelltext bleiben würde.

`get_target_datetime()` ist verwirrend. Da wird die lokale Zeit genommen, als UTC erklärt, was ja falsch ist, und Zeitanteile ersetzt und dann wird dieser falsche Wert wo das Datum lokal ist, aber als UTC deklariert wird in die mitteleuropäische Zeitzone umgewandelt. Sollte das nicht zufällig auch die lokale Zeitzone sein, wird es noch wirrer, weil dann *drei* Zeitzonen an diesem Spielchen beteiligt sind. Da sollte also mindestens mal `utcnow()` statt `now()` verwendet werden, damit man das auf maximal zwei beteiligte Zeitzonen begrenzt. Und man muss ich entscheiden an welcher Stelle man die Uhrzeit für das Gebiet setzt. Da das ansonsten mit der mitteleuropäischen verglichen wird, würde ich mal vermuten die Daten in der Konfigurationsdatei sollen auch für Mitteleuropa gelten und nicht für UTC‽

Die ``while``-Schleife in der Funktion ist ein bisschen umständlich formuliert. Das ist eigentlich eine kopfgesteuerte Schleife bei der man wunderbar eine Abbruchbedingung formulieren kann und deren Körper dann aus einer einzigen Zeile besteht.

Warum ``check=False`` bei `subprocess.run()`?

Bei `create_text()` steht ein Teil des Textes in den `strftime()`-Aufrufen statt in der Zeichenkette‽ `strftime()` ist auch unnötig lang. Man kann das in der Formatspezifikation direkt angeben, ohne den Methodenaufruf.

Die beiden TOML-Dateien sollten nur einmal geladen werden.

`get_role_id()` ist unsinnigerweise async. Da passiert doch gar nichts was das erfordern würde. Die Funktion sollte auch in *jedem* Fall explizit etwas zurück geben und nicht nur wenn die Rolle gefunden wurde. Beziehungsweise eine Ausnahme auslösen wenn die Rolle nicht gefunden wird.

`search_work_channel()` ist gegenüber `get_role_id()` unnötig kompliziert.

Statt das `Channel`-Objekt in eine Zeichenkette umzuwandeln sollte man genau wie bei `get_role_id()` auf den Namen für den Vergleich zugreifen. Und ich bin auch etwas verwirrt, was der `get_channel()`-Aufruf soll. Dem wird die ID von `channel` übergeben. Bekommt man da dann nicht genau das `Channel`-Objekt zurück was man bereits *hat*, oder was ist der Unterschied zwischen `channel` und dem Rückgabewert.

Man sollte `sched` mit `asyncio` zusammenbringen können wenn man `run()` vom Scheduler nicht-blockierrend aufruft, das warten selbst übernimmt mit `asyncio.sleep()` und in der Rückruffunktion vom Scheduler dann einen `Task` für das Versenden der Nachricht in der laufenden asyncio Ereignisschleife erzeugt.

Das fühlt sich so ein bisschen an als wenn man gegen `sched` programmiert. Die `asyncio`-Ereignisschleife hat eine `call_at()`-Methode — ist also eigentlich selbst so ein bisschen ein Scheduler. Da braucht es nur ein bisschen Code um den Zeitpunkt zu errechnen. Wobei ich mir sicher bin, dass das auch schon jemand gemacht hat und man da ein fertiges Modul für finden dürfte.

Achtung: Der Code enthält eine Fehlerquelle: Das `on_ready()`-Ereignis kann mehr als einmal ausgelöst werden. Das muss man also absichern gegen weitere Aufrufe. An der Stelle ein recht harter Grund da über mindestens eine eigene Klasse nachzudenken. Auch um das globale `client` loszuwerden. Aber auch für den Scheduler bietet sich eine Klasse an, wenn man sich anschaut wie viele Argumente da überall durchgereicht werden. Und das müssten eigentlich noch mehr sein, denn weder `DATA` noch `CONFIG` haben etwas auf Modulebene zu suchen.

Zwischenstand (ungetestet):

Python

#!/usr/bin/env python3
import asyncio
import sched
import time
from datetime import datetime as DateTime, timedelta as TimeDelta
from pprint import pprint

import discord
import pytz
import toml

CONFIG = toml.load("config.toml")
DATA = toml.load("data.toml")
TIMEZONE = pytz.timezone("Europe/Berlin")

WEEKDAY_NAME_TO_NUMBER = {
    "Montag": 0,
    "Dienstag": 1,
    "Mittwoch": 2,
    "Donnerstag": 3,
    "Freitag": 4,
    "Samstag": 5,
    "Sonntag": 6,
}

client = discord.Client(intents=discord.Intents.default())


def search_channel(channel_name):
    for channel in client.get_all_channels():
        if channel.name == channel_name:
            return channel

    raise ValueError(f"channel with name {channel_name!r} not found")


def get_role(context, role_name):
    for role in context.guild.roles:
        if role.name == role_name:
            return role

    raise ValueError(f"role with name {role_name!r} not found")


async def send_reminder(text):
    channel = search_channel(CONFIG["channel"])
    role = get_role(channel, CONFIG["role"])
    await channel.send(f"{role.mention}: {text}")


def get_current_datetime():
    return DateTime.utcnow().replace(tzinfo=pytz.utc).astimezone(TIMEZONE)


def get_target_datetime(day_and_time_text, current_datetime, remind_timedelta):
    weekday_name, time_text = day_and_time_text.split()
    hour, minute = map(int, time_text.split(":"))
    target_datetime = get_current_datetime().replace(
        hour=hour, minute=minute, second=0, microsecond=0
    )
    weekday_number = WEEKDAY_NAME_TO_NUMBER[weekday_name]
    one_day = TimeDelta(days=1)
    while (
        target_datetime.weekday() != weekday_number
        and target_datetime - remind_timedelta < current_datetime
    ):
        target_datetime += one_day

    return target_datetime


def create_text(territory, target_datetime):
    return (
        f"**{DATA['ueberschrift']} {territory['system']} am {target_datetime:%d. %B}**\n"
        f"{DATA['text'][0]} {territory['system']} ist um {target_datetime:%H:%M} Uhr\n"
        f"{DATA['text'][1]} {CONFIG['rule_link']}"
    )


def send_reminder_callback(
    scheduler, async_tasks, remind_timedelta, territory, target_datetime
):
    task = asyncio.get_running_loop().create_task(
        send_reminder(create_text(territory, target_datetime))
    )
    async_tasks.add(task)
    task.add_done_callback(async_tasks.discard)
    pprint(
        create_territory_capture(
            scheduler, async_tasks, remind_timedelta, territory
        )
    )


def create_territory_capture(
    scheduler, async_tasks, remind_timedelta, territory
):
    target_datetime = get_target_datetime(
        territory["date"], get_current_datetime(), remind_timedelta
    )
    return scheduler.enterabs(
        (target_datetime - remind_timedelta).timestamp(),
        1,
        send_reminder_callback,
        (scheduler, async_tasks, remind_timedelta, territory, target_datetime),
    )


def create_territory_captures(
    scheduler, async_tasks, remind_timedelta, territories
):
    pprint(
        [
            create_territory_capture(
                scheduler, async_tasks, remind_timedelta, territory
            )
            for territory in territories
        ]
    )


@client.event
async def on_ready():
    #
    # FIXME There is no guarantee that this is called only once, so it must be
    #       guarded against subsequent calls.  After this is moved into a class.
    #
    scheduler = sched.scheduler(time.time, None)
    async_tasks = set()
    create_territory_captures(
        scheduler,
        async_tasks,
        TimeDelta(minutes=DATA["remind_offset"]),
        DATA["territories"],
    )
    while True:
        await asyncio.sleep(scheduler.run(blocking=False))


if __name__ == "__main__":
    client.run(CONFIG["dc_token"])

Display More

Bot · Vor einem Moment

Schau mal ob du hier fündig wirst:

Hofei · April 17, 2024 at 7:35 PM

Hallo und vielen Dank für die Mühe mit den ausführlichen Verbesserungshinweisen und auch vorgelegten Code. Diesen habe ich gleich einmal gestartet, folgende Ausgabe bekomme ich bei dem Start, trotz des Tracebacks stürzt das Skript aber nicht ab. Allerdings funktioniert es auch nicht, wie es soll. Zeitpunkte, die am selben Tag aber in der Vergangenheit liegen, lösen eine Benachrichtigung in Discord aus und der gewünschte Testzeitpunkt, den ich eigentlich erwarten würde, löst keine Benachrichtigung aus. Das wird da dran liegen, dass du die Zeitmechanik und die Zeitzonen geändert hast.

Code

[2024-04-17 15:58:34] [INFO    ] discord.client: logging in using static token
[2024-04-17 15:58:35] [INFO    ] discord.gateway: Shard ID None has connected to Gateway (Session ID: 22ea001c71caa1f5b275f8d0bdeb799a).
[Event(time=1713347940.0, priority=1, action=<function send_reminder_callback at 0x03483A00>, argument=(<sched.scheduler object at 0x034C1B08>, set(), datetime.timedelta(seconds=7200), {'system': 'Testsystem', 'kategorie': 1, 'ressource': 'Testxyz', 'date': 'Mittwoch 13:59', 'other_data': 'Quantenteilchen, Forschungsverstärker', 'priority': 1}, datetime.datetime(2024, 4, 17, 13, 59, tzinfo=<DstTzInfo 'Europe/Berlin' CEST+2:00:00 DST>)), kwargs={}),
 Event(time=1713333600.0, priority=1, action=<function send_reminder_callback at 0x03483A00>, argument=(<sched.scheduler object at 0x034C1B08>, set(), datetime.timedelta(seconds=7200), {'system': 'Otima', 'kategorie': 1, 'ressource': 'Parstahl, Iso2', 'date': 'Mittwoch 10:00', 'other_data': 'Quantenteilchen, Forschungsverstärker', 'priority': 0}, datetime.datetime(2024, 4, 17, 10, 0, tzinfo=<DstTzInfo 'Europe/Berlin' CEST+2:00:00 DST>)), kwargs={}),
 Event(time=1713434400.0, priority=1, action=<function send_reminder_callback at 0x03483A00>, argument=(<sched.scheduler object at 0x034C1B08>, set(), datetime.timedelta(seconds=7200), {'system': 'Aonad', 'kategorie': 1, 'ressource': 'Tritanium, Iso2', 'date': 'Sonntag 14:00', 'other_data': 'Quantenteilchen, Gasabbauverstärker', 'priority': 0}, datetime.datetime(2024, 4, 18, 14, 0, tzinfo=<DstTzInfo 'Europe/Berlin' CEST+2:00:00 DST>)), kwargs={}),
 Event(time=1713423600.0, priority=1, action=<function send_reminder_callback at 0x03483A00>, argument=(<sched.scheduler object at 0x034C1B08>, set(), datetime.timedelta(seconds=7200), {'system': 'Ruhe', 'kategorie': 1, 'ressource': 'Iso 1 + 2', 'date': 'Freitag 11:00', 'other_data': 'Quantenteilchen, Ablenkungsverstärker', 'priority': 0}, datetime.datetime(2024, 4, 18, 11, 0, tzinfo=<DstTzInfo 'Europe/Berlin' CEST+2:00:00 DST>)), kwargs={}),
 Event(time=1713416400.0, priority=1, action=<function send_reminder_callback at 0x03483A00>, argument=(<sched.scheduler object at 0x034C1B08>, set(), datetime.timedelta(seconds=7200), {'system': 'Comst', 'kategorie': 1, 'ressource': 'Iso 1 + 2', 'date': 'Freitag 9:00', 'other_data': 'Quantenteilchen, Treffsicherheitsverstärker', 'priority': 0}, datetime.datetime(2024, 4, 18, 9, 0, tzinfo=<DstTzInfo 'Europe/Berlin' CEST+2:00:00 DST>)), kwargs={}),
 Event(time=1713427200.0, priority=1, action=<function send_reminder_callback at 0x03483A00>, argument=(<sched.scheduler object at 0x034C1B08>, set(), datetime.timedelta(seconds=7200), {'system': 'Burran', 'kategorie': 2, 'ressource': 'Erz*3, Iso3', 'date': 'Donnerstag 12:00', 'other_data': 'Surraxteilchen, Offizierverstärker, Monaveenteile', 'priority': 0}, datetime.datetime(2024, 4, 18, 12, 0, tzinfo=<DstTzInfo 'Europe/Berlin' CEST+2:00:00 DST>)), kwargs={}),
 Event(time=1713340800.0, priority=1, action=<function send_reminder_callback at 0x03483A00>, argument=(<sched.scheduler object at 0x034C1B08>, set(), datetime.timedelta(seconds=7200), {'system': 'Thaylen', 'kategorie': 1, 'ressource': 'Dilithium, Iso2', 'date': 'Mittwoch 12:00', 'other_data': 'Quantenteilchen, Armadakampfverstärker, Kinetische Waffenverstärker', 'priority': 1}, datetime.datetime(2024, 4, 17, 12, 0, tzinfo=<DstTzInfo 'Europe/Berlin' CEST+2:00:00 DST>)), kwargs={}),
 Event(time=1713340800.0, priority=1, action=<function send_reminder_callback at 0x03483A00>, argument=(<sched.scheduler object at 0x034C1B08>, set(), datetime.timedelta(seconds=7200), {'system': 'Roshar', 'kategorie': 2, 'ressource': 'Erz*4, Iso3', 'date': 'Mittwoch 12:00', 'other_data': 'Quantenteilchen, Forschungsverstärker, Monaveen Konstruktionsstätte', 'priority': 1}, datetime.datetime(2024, 4, 17, 12, 0, tzinfo=<DstTzInfo 'Europe/Berlin' CEST+2:00:00 DST>)), kwargs={})]
Event(time=1713333600.0, priority=1, action=<function send_reminder_callback at 0x03483A00>, argument=(<sched.scheduler object at 0x034C1B08>, {<Task pending name='Task-11' coro=<send_reminder() running at C:\Users\***\Nextcloud\P_Python\stfc_gebietsassistent\standalone_test.py:45> cb=[set.discard()]>}, datetime.timedelta(seconds=7200), {'system': 'Otima', 'kategorie': 1, 'ressource': 'Parstahl, Iso2', 'date': 'Mittwoch 10:00', 'other_data': 'Quantenteilchen, Forschungsverstärker', 'priority': 0}, datetime.datetime(2024, 4, 17, 10, 0, tzinfo=<DstTzInfo 'Europe/Berlin' CEST+2:00:00 DST>)), kwargs={})
[2024-04-17 15:58:37] [ERROR   ] discord.client: Ignoring exception in on_ready
Traceback (most recent call last):
  File "C:\Users\***\Nextcloud\P_Python\stfc_gebietsassistent\venv\lib\site-packages\discord\client.py", line 441, in _run_event
    await coro(*args, **kwargs)
  File "C:\Users\***\Nextcloud\P_Python\stfc_gebietsassistent\standalone_test.py", line 137, in on_ready
    await asyncio.sleep(scheduler.run(blocking=False))
  File "C:\Users\***\AppData\Local\Programs\Python\Python38-32\lib\sched.py", line 152, in run
    delayfunc(0)   # Let other threads run
TypeError: 'NoneType' object is not callable

Display More

Das ich auf alle Absatzblöcke eingehe und versuche bei mir zu ändern, bzw. deine Vorlage anzupassen, dass sie meinen Wünschen entspricht, dafür fehlt mir heute die Zeit. Fußball UCL ist ja heute .... Damit werde ich dann morgen beginnen.

Jedoch möchte ich noch gleich folgendes beantworten:

Ja, die Zeitangaben in der Toml Datei sind UTC, da sie so auch aus der entnommenen Quelle vorlegen und dann kann ich das 1:1 übernehmen und muss das auch nicht halbjährlich ändern.

Quote from __blackjack__

`get_remaining_time()` wird nirgends aufgerufen. Da ist auch Code drin den es noch mal in `get_target_ts()` gibt. Wenn man die Funktion also nicht entfernt, sollte man den gemeinsamen Code in eine weitere Funktion auslagern.

Das liegt daran, dass alles was ich in utils.py ausgelagert habe von einem weiteren unabhängigen Skript verwendet wird. Die Funktion wird also benötigt, dass ich jedoch den redundanten Codeteil auslagern kann ist ein richtiger und sinnvoller Tipp. Zudem erwähnten weiteren Skript habt ihr sogar auch schonmal Hilfestellungen gegeben, und zwar hier. Auch werden noch weitere, bisher noch nicht existierende Skripte folgen.

Quote from noisefloor

Bei asyncio kommt IMHO noch dazu, dass man das auch nicht "mal einfach so" ausprobiert bzw. die "Hallo Welt" asyncio Bespiele mega-trivial sind und damit eine ziemlich große Lücke zu realen Anwendungen kommt.

Ja genau das ist eines der Probleme, mit denen ich zu kämpfen habe

Python

import asyncio

async def my_async_function(n):
    await asyncio.sleep(1)
    print("Async function executed!", n)

async def main():
    task1 = asyncio.create_task(my_async_function(1))
    task2 = asyncio.create_task(my_async_function(2))
    await task1
    await task2

asyncio.run(main())

Display More

Bei sowas seh ich den Sinn nicht und wenn ich sowas sehe:

Code

import asyncio
 
async def fn():
     
    print("one")
    await asyncio.sleep(1)
    await fn2()
    print('four')
    await asyncio.sleep(1)
    print('five')
    await asyncio.sleep(1)
 
async def fn2():
    await asyncio.sleep(1)
    print("two")
    await asyncio.sleep(1)
    print("three")
asyncio.run(fn())

Display More

erkenne ich keinen Unterschied/Vorteil zu dem hier

Python

from time import sleep


def fn():
    print("one")
    sleep(1)
    fn2()
    print('four')
    sleep(1)
    print('five')
    sleep(1)


def fn2():
    sleep(1)
    print("two")
    sleep(1)
    print("three")


fn()

Display More

Quote from noisefloor

Zu deiner Ehrenrettung: Das Probleme hatte / habe ich auch latent

"Witzigerweise" habe ich gestern mit Dennis89 per Privat Nachricht über dich und asyncio geschrieben, dass du wohl einer hier bist, der damit am besten umgehen kann und dass ich dich mal fragen will, ob du nicht eine kleine Erweiterung zu PyTuDe machen willst und ein deutsches Tutorial zu asyncio machen willst. Hatte aber auch im Zuge gleich erwähnt, dass ich erstmal das Kontrolllesen von PyTuDe abschließen möchte. Das wird auf alle Fälle wieder fortgesetzt, will nur erst den Discord Erinnerungsbot zuverlässig in Betrieb haben.

noisefloor · April 17, 2024 at 8:16 PM

Quote from Hofei

"Witzigerweise" habe ich gestern mit Dennis89 per Privat Nachricht über dich und asyncio geschrieben, dass du wohl einer hier bist, der damit am besten umgehen kann

Danke für die Fehleinschätzung Nee, ich habe mich zwar früh (Python 3.4. und 3.5) mit asyncio beschäftigt und glaube wie gesagt auch, dass ich das Konzept etc. verstanden habe - aber meine Praxiserfahrung an realen Programmen liegt bei Null. Wenn mal was machen müsste würde ich wahrscheinlich auch erst Mal schauen, ob das nicht mit Trio besser lösbare wäre, weil das IMHO die bessere Doku und schönere API hat.

Quote from Hofei

und ein deutsches Tutorial zu asyncio machen willst.

Da habe ich nicht genug Wissen für. Außerdem schreibe ich seit einiger Zeit einem kompakten Schnelleinstieg / -überblick Tutorial für Django. Das kann ich besser als asyncio.

Gruß, noisefloor

__blackjack__ · April 17, 2024 at 8:47 PM

Hofei Die Ausnahme ist leicht behoben: das zweite Argument von `scheduler` ist `None` weil ich dachte das wird nicht mehr aufgerufen wenn man das mit dem Warten selbst erledigt. Da einfach wieder `time.sleep()` rein, dann ist die Ausnahme weg. In `run()` wird ein ``time.sleep(0)`` aufgerufen, als Hack um den Thread ”aufzugeben”, damit ein anderer Thread dran kommen kann.

Bot · Vor einem Moment

Schau mal ob du hier fündig wirst:

Hofei · April 19, 2024 at 9:53 PM

Wie du schon sagtest, die Ausnahme ist behoben. Danke. Dafür überschlägt sich die Ausgabe jetzt mit soetwas:

Code

<Task pending name='Task-140' coro=<send_reminder() running at C:\Users\***\Nextcloud\P_Python\stfc_gebietsassistent\standalone_test.py:45> cb=[set.discard()]>, <Task pending name='Task-508' coro=<send_reminder() running at C:\Users\***\Nextcloud\P_Python\stfc_gebietsassistent\standalone_test.py:45> cb=[set.discard()]>, <Task pending name='Task-141' coro=<send_reminder() running at C:\Users\***\Nextcloud\P_Python\stfc_gebietsassistent\standalone_test.py:45> cb=[set.discard()]>, <Task pending name='Task-509' coro=<send_reminder() running at C:\Users\***\Nextcloud\P_Python\stfc_gebietsassistent\standalone_test.py:45> cb=[set.discard()]>, <Task pending name='Task-142' coro=<send_reminder() running at C:\Users\***\Nextcloud\P_Python\stfc_gebietsassistent\standalone_test.py:45> cb=[set.discard()]>, <Task pending name='Task-510' coro=<send_reminder() running at C:\Users\***\Nextcloud\P_Python\stfc_gebietsassistent\standalone_test.py:45> cb=[set.discard()]>, <Task pending name='Task-143' coro=<send_reminder() running at C:\Users\***\Nextcloud\P_Python\stfc_gebietsassistent\standalone_test.py:45> cb=[set.discard()]>, <Task pending name='Task-511' coro=<send_reminder() running at C:\Users\***\Nextcloud\P_Python\stfc_gebietsassistent\standalone_test.py:45> cb=[set.discard()]>, <Task pending name='Task-144' coro=<send_reminder() running at C:\Users\***\Nextcloud\P_Python\stfc_gebietsassistent\standalone_test.py:45> cb=[set.discard()]>, <Task pending name='Task-512' coro=<send_reminder() running at C:\Users\***\Nextcloud\P_Python\stfc_gebietsassistent\standalone_test.py:45> cb=[set.discard()]>, <Task pending name='Task-145' coro=<send_reminder() running at C:\Users\***\Nextcloud\P_Python\stfc_gebietsassistent\standalone_test.py:45> 
...gekürzt, das geht ewig so weiter ...

Kann das mit deinem Hinweis in def on_ready() zusammen hängen?

Quote

Code

#
# FIXME There is no guarantee that this is called only once, so it must be
#       guarded against subsequent calls.  After this is moved into a class.
#

Denke ich fahre mit der Subprocess Variante doch gar nicht so schlecht, ich werde jetzt dort mal deine angebrachten Verbesserungsvorschläge einarbeiten und hier dann nochmals präsentieren. Bei der Kombination seh ich mich nicht in der Lage die Probleme selbst zu beheben und ich möchte ja doch die Möglichkeit behalten, Probleme und Wartungen am Skript vornehmen zu können.

Participate now!