discord interactions.py

Interacciones de discordia

Un envoltorio para la API de interacciones de discordia que no depende de WebSockets y, por lo tanto, puede usarse en un entorno webhook sin estado.

Además, permite una separación estricta entre la estructura de sus comandos y los datos que se reciben al activarlo.

Instalación

Requiere Python 3.8+

Última versión de Pypi usando PIP :

pip install discord-interactions.py

Último compromiso de Github usando PIP y GIT :

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

Nota

La instalación directamente desde GitHub requiere que haya instalado GIT en su computadora.

Si esto no funciona, puede intentar:

python -m pip install ...

O si estás en Windows:

py -m pip install ...

Usar con Flask

Esta biblioteca está específicamente diseñada para funcionar sin problemas con el frasco microframework.

Uso de clases de datos similares a la API

El ejemplo más similar a la API con la extensión del frasco es este:

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

Aquí, utilizamos el ApplicationCommand rudimentario, las clases de Interaction e InteractionResponse , que están en su estructura básicamente contrapartes exactas de los modelos API originales.

Hagamos un poco más simple:

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

    return msg

Ahora, ya no necesitamos lidiar con InteractionResponse , sino solo devolver el contenido de respuesta como una cadena. El tipo de respuesta luego es predeterminado a InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE . También podría no devolver ninguno, si no desea enviar una respuesta. También puede simplemente devolver un booleano como segundo valor, lo que indica si la llamada de comando debe mostrarse o no en Discord (es decir, la parte _WITH_SOURCE del tipo de respuesta). También obtenemos la opción a través del método get_option Helper.

El mapeador de mocos de objetos

Sin embargo, esta biblioteca proporciona otra capa de abstracción. Inspirado en el concepto de ORMS de la base de datos, tiene un mapeador de comando de objetos (OCM) que le permite definir una clase para cada comando que luego servirá como una descripción estructural genérica del comando (como ApplicationCommand ) y un contenedor para los datos reales que se reciben cuando el comando se llama (como Interaction ).

Entonces, el ejemplo más simple posible se ve así:

 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

Mensajes de seguimiento

Si desea enviar mensajes después de la respuesta inicial, debe crear mensajes de seguimiento. Para este propósito, puede usar el decorador after_command , que registra una función que se llamará después de que la función de comando real haya regresado. La función debe tomar exactamente un parámetro, el AfterCommandContext , que contiene varias cosas, como la Interaction y InteractionResponse inicial.

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

Componentes de mensaje

También puede registrar devoluciones de llamada para componentes de mensajes, como botones. Los componentes están registrados e identificados por su custom_id .

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

Más ejemplos

Para obtener más ejemplos de las diferentes características, eche un vistazo a los ejemplos.

Si desea saber cómo hacer que su Bot Discord funcione con los comandos de corte y cómo establecer todo, eche un vistazo a este proyecto de ejemplo. Aloja el programa en un entorno sin servidor a través de Google Cloud Run y ​​también proporciona un bot de demostración, por lo que puede probar los comandos de corte en su servidor Discord. ¡Compruébalo para obtener más información!