discord interactions.py

Discord -Interaktionen

Eine Wrapper für die Discord -Interaktionen -API, die sich nicht auf Websockets beruht und daher in einer staatenlosen Webhook -Umgebung verwendet werden kann.

Darüber hinaus ermöglicht es eine strenge Trennung zwischen der Struktur Ihrer Befehle und den Daten, die beim Auslösen empfangen werden.

Installation

Benötigt Python 3.8+

Neueste Veröffentlichung von PYPI mit PIP :

pip install discord-interactions.py

Neueste Commit von Github mit PIP und Git :

pip install git+https://github.com/LiBa001/discord-interactions.py

Notiz

Wenn Sie direkt von Github installiert werden, müssen Sie Git auf Ihrem Computer installieren lassen.

Wenn dies nicht funktioniert, können Sie es versuchen:

python -m pip install ...

Oder wenn Sie unter Windows sind:

py -m pip install ...

Verwendung mit Flask

Diese Bibliothek ist speziell so konzipiert, dass sie nahtlos mit dem Flask -Mikroframework funktioniert.

Verwenden von API-ähnlichen Datenklassen

Das API-ähnliche Beispiel bei der Flask-Erweiterung ist Folgendes:

 from discord_interactions . flask_ext import Interactions
from discord_interactions import (
    ApplicationCommand ,
    ApplicationCommandOption ,
    ApplicationCommandOptionType ,
    Interaction ,
    InteractionResponse ,
    InteractionResponseType ,
    InteractionApplicationCommandCallbackData ,
)
from flask import Flask
import os

app = Flask ( __name__ )
interactions = Interactions ( app , os . getenv ( "CLIENT_PUBLIC_KEY" ))

echo_cmd = ApplicationCommand ( "echo" , "what goes around comes around" )
echo_cmd . add_option (
    ApplicationCommandOption (
        type = ApplicationCommandOptionType . STRING ,
        name = "message" ,
        description = "This will be echoed." ,
        required = True ,
    )
)


@ interactions . command ( echo_cmd )
def _echo ( interaction : Interaction ):
    msg = interaction . data . options [ 0 ]. value  # "message" option content

    return InteractionResponse (
        type = InteractionResponseType . CHANNEL_MESSAGE_WITH_SOURCE ,
        data = InteractionApplicationCommandCallbackData ( content = msg ),
    )

Hier verwenden wir die rudimentären ApplicationCommand , Interaction und InteractionResponse , die sich in ihrer Struktur im Grunde genommen genaue Gegenstücke der ursprünglichen API -Modelle befinden.

Machen wir es ein bisschen einfacher:

 @ interactions . command ( echo_cmd )
def _echo ( interaction : Interaction ):
    # different way of getting an option
    msg = interaction . data . get_option ( "message" ). value

    return msg

Jetzt müssen wir uns nicht mehr mit InteractionResponse befassen, sondern den Antwortinhalt nur als Zeichenfolge zurückgeben. Der Antworttyp ist dann standardmäßig zu InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE . Sie können auch einfach keine zurückgeben, wenn Sie keine Antwort senden möchten. Sie können auch einfach einen Booleschen Wert als zweiter Wert zurückgeben, um anzuzeigen, ob der Befehlsaufruf in Discord angezeigt werden sollte (dh der Teil des Antworttyps _WITH_SOURCE ). Außerdem erhalten wir die Option über die get_option -Helfermethode.

Der Objekt-Command Mapper

Diese Bibliothek bietet jedoch eine weitere Abstraktionsschicht. Inspiriert vom Konzept von Datenbankormen verfügt es über einen Objekt-Command Mapper (OCM), mit dem Sie eine Klasse für jeden Befehl definieren können, der dann sowohl als generische strukturelle Beschreibung des Befehls (wie ApplicationCommand ) als auch als Container für die tatsächlichen Daten dient, die empfangen werden, wenn der Befehl aufgerufen wird (wie Interaction ).

Das einfachste mögliche Beispiel sieht also so aus:

 from discord_interactions . flask_ext import Interactions
from discord_interactions . ocm import Command , Option
from flask import Flask
import os

app = Flask ( __name__ )
interactions = Interactions ( app , os . getenv ( "CLIENT_PUBLIC_KEY" ))


class _Echo ( Command ):
    """ what goes around comes around """

    message : str = Option ( "This will be echoed." , required = True )


@ interactions . command
def _echo ( cmd : _Echo ):
    return cmd . message

Follow -up -Nachrichten

Wenn Sie nach der ersten Antwort Nachrichten senden möchten, müssen Sie Follow -up -Nachrichten erstellen. Zu diesem Zweck können Sie den Dekorateur after_command verwenden, der eine Funktion registriert, die nach der Rückgabe der tatsächlichen Befehlsfunktion aufgerufen werden soll. Die Funktion muss genau einen Parameter, den AfterCommandContext , aufnehmen, der die verschiedenen Dinge enthält, wie die Interaction und die anfängliche InteractionResponse .

 interactions = Interactions ( app , PUBLIC_KEY )

@ interactions . command ( "delay" )
def delay ( _ : Interaction ):
    return "starting countdown" , True  # this message is ephemeral


@ delay . after_command
def after_delay ( ctx : AfterCommandContext ):
    delay_time = ctx . interaction . data . options [ 0 ]. value
    time . sleep ( delay_time )
    ctx . send ( f" { delay_time } seconds have passed" )

Nachrichtenkomponenten

Sie können auch Rückrufe für Nachrichtenkomponenten wie Schaltflächen registrieren. Komponenten werden von ihrem custom_id registriert und identifiziert.

 @ interactions . component ( "my_button" )
def my_button_handler ( ctx : ComponentContext ):
    return f" { ctx . interaction . user . username } clicked the button" 

Weitere Beispiele

Weitere Beispiele für die verschiedenen Funktionen finden Sie in Beispielen.

Wenn Sie wissen möchten, wie Sie Ihren Discord -Bot mit Slash -Befehlen funktionieren und alles einrichten können, sehen Sie sich dieses Beispielprojekt an. Es hostet das Programm in einer serverlosen Umgebung über Google Cloud Run und bietet auch einen Demo -Bot, sodass Sie Slash -Befehle in Ihrem Discord -Server ausprobieren können. Probieren Sie es aus, um mehr zu erfahren!