discord interactions.py

Interactions de discorde

Un wrapper pour l'API Discord Interactions qui ne s'appuie pas sur WebSockets et peut donc être utilisé dans un environnement WebHook sans état.

En outre, il permet une séparation stricte entre la structure de vos commandes et les données reçues lors du déclenchement.

Installation

Nécessite Python 3.8+

Dernière version de PYPI à l'aide de PIP :

pip install discord-interactions.py

Dernier engagement de GitHub à l'aide de PIP et GIT :

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

Note

L'installation directement à partir de GitHub vous oblige à installer Git sur votre ordinateur.

Si cela ne fonctionne pas, vous pouvez essayer:

python -m pip install ...

Ou si vous êtes sous Windows:

py -m pip install ...

Utiliser avec Flask

Cette bibliothèque est spécialement conçue pour fonctionner de manière transparente avec le Flask Microframework.

Utilisation de classes de données de type API

L'exemple le plus en forme d'API avec l'extension du flacon est le suivant:

 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 ),
    )

Ici, nous utilisons les classes Rudimentary ApplicationCommand , Interaction and InteractionResponse , qui sont dans leur structure essentiellement des homologues exacts des modèles API originaux.

Rendons-le un peu plus simple:

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

    return msg

Maintenant, nous n'avons plus besoin de gérer InteractionResponse , mais renvoie à la place le contenu de réponse en tant que chaîne. Le type de réponse est ensuite par défaut à InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE . Vous pouvez également en retourner aucun, si vous ne voulez pas envoyer de réponse. Vous pouvez également renvoyer un booléen comme une deuxième valeur, indiquant si l'appel de commande doit être affiché ou non dans Discord (c'est-à-dire la partie _WITH_SOURCE du type de réponse). Nous obtenons également l'option via la méthode get_option HELPER.

Le mappeur d'objet

Cette bibliothèque fournit cependant une autre couche d'abstraction. Inspiré par le concept d'ORMS de base de données, il dispose d'un mappeur d'objet-command (OCM) qui vous permet de définir une classe pour chaque commande qui servira ensuite à la fois une description structurelle générique de la commande (comme ApplicationCommand ) et un conteneur pour les données réelles reçues lorsque la commande est appelée (comme Interaction ).

Ainsi, l'exemple le plus simple possible ressemble à ceci:

 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

Messages de suivi

Si vous souhaitez envoyer des messages après la réponse initiale, vous devez créer des messages de suivi. À cette fin, vous pouvez utiliser le décorateur after_command , qui enregistre une fonction à appeler une fois la fonction de commande réelle. La fonction doit prendre exactement un paramètre, le AfterCommandContext , qui contient les plusieurs choses, comme l' Interaction et InteractionResponse initiale.

 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" )

Composants de message

Vous pouvez également enregistrer des rappels pour les composants de message, tels que les boutons. Les composants sont enregistrés et identifiés par leur custom_id .

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

Plus d'exemples

Pour plus d'exemples des différentes fonctionnalités, jetez un œil aux exemples.

Si vous voulez savoir comment faire fonctionner votre bot Discord avec des commandes de slash et comment tout configurer, jetez un œil à cet exemple de projet. Il héberge le programme dans un environnement sans serveur via Google Cloud Run et fournit également un bot de démonstration, afin que vous puissiez essayer des commandes de slash dans votre serveur Discord. Vérifiez-le pour en savoir plus!