discord interactions.py

Interações com discórdia

Um invólucro para a API de interações Discord que não depende de Websockets e, portanto, pode ser usada em um ambiente de webhook sem estado.

Além disso, permite uma separação estrita entre a estrutura de seus comandos e os dados recebidos ao desencadeá -los.

Instalação

Requer Python 3.8+

Última lançamento da Pypi usando PIP :

pip install discord-interactions.py

Última comprometimento do Github usando PIP e Git :

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

Observação

A instalação diretamente do GitHub exige que você instale o GIT no seu computador.

Se isso não funcionar, você pode tentar:

python -m pip install ...

Ou se você estiver no Windows:

py -m pip install ...

Use com frasco

Esta biblioteca foi projetada especificamente para funcionar perfeitamente com o Flask Microframework.

Usando classes de dados semelhantes a API

O exemplo mais semelhante à API com a extensão do frasco é a seguinte:

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

Aqui, usamos as classes Rudimentares ApplicationCommand , Interaction e InteractionResponse , que estão em sua estrutura basicamente contrapartes exatas dos modelos originais da API.

Vamos torná -lo um pouco mais simples:

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

    return msg

Agora, não precisamos mais lidar com InteractionResponse , mas apenas retorne o conteúdo da resposta como uma string. O tipo de resposta, em seguida, padroniza para InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE . Você também pode simplesmente retornar nenhum, se não quiser enviar uma resposta. Você também pode simplesmente retornar um booleano como um segundo valor, indicando se a chamada de comando deve ou não ser exibida no Discord (ou seja, a parte _WITH_SOURCE do tipo de resposta). Também obtemos a opção através do método get_option Helper.

O mapeador de comando de objetos

Esta biblioteca fornece outra camada de abstração, no entanto. Inspirado no conceito de ORMS de banco de dados, ele possui um mapeador de comando de objetos (OCM) que permite definir uma classe para cada comando que servirá como uma descrição estrutural genérica do comando (como ApplicationCommand ) e um contêiner para os dados reais recebidos quando o comando é chamado (como Interaction ).

Então, o exemplo mais simples possível se parece com o seguinte:

 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

Mensagens de acompanhamento

Se você deseja enviar mensagens após a resposta inicial, é necessário criar mensagens de acompanhamento. Para esse fim, você pode usar o Decorador after_command , que registra uma função a ser chamada após o retorno da função de comando real. A função precisa tomar exatamente um parâmetro, o AfterCommandContext , que contém as várias coisas, como a Interaction e 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" )

Componentes de mensagem

Você também pode registrar retornos de chamada para componentes de mensagens, como botões. Os componentes são registrados e identificados pelo seu custom_id .

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

Mais exemplos

Para mais exemplos dos diferentes recursos, dê uma olhada nos exemplos.

Se você quiser saber como fazer com que seu Bot Discord funcione com comandos Slash e como configurar tudo, dê uma olhada neste projeto de exemplo. Ele hospeda o programa em um ambiente sem servidor via Google Cloud Run e também fornece um bot de demonstração, para que você possa experimentar comandos Slash no seu servidor Discord. Confira para saber mais!