Brouillon de Gmail en Python

3. Créer un script Python

En tant que flux, Obtenez un jeton d'accès selon le flux d'authentification OAuth ↓ Créer des données pour les e-mails à envoyer ↓ Appuyez sur l'API Gmail pour créer un brouillon

C'est comme ça.

1. Obtenez un jeton d'accès

La fonction minimale requise pour obtenir un jeton d'accès est la suivante. Référence → [API Authentication and Calling (Google Cloud Guide)](https://cloud.google.com/bigquery/docs/authentication/end-user-installed?hl=ja#authenticating-and-calling-the- api)

from google_auth_oauthlib.flow import InstalledAppFlow
#Définir la portée de l'API(Définition de l'API à utiliser)
SCOPES = ["https://www.googleapis.com/auth/gmail.modify"]

def get_credential():
    launch_browser = True
    flow = InstalledAppFlow.from_client_secrets_file("client_id.json", SCOPES)
    flow.run_local_server()
    cred = flow.credentials
    return cred

ʻInstalledAppFlow.from_client_secrets_filecontient le fichier JSON supprimé de GCP et les informations de l'API que vous souhaitez utiliser, créez uneinstance de flux, et faites run_local_server ()`, le navigateur démarrera et l'écran d'autorisation familier apparaîtra.

Maintenant, appuyez sur Autoriser et vous obtiendrez un jeton d'accès.

À propos, jusqu'à présent, l'écran d'autorisation apparaît à chaque fois que le programme est exécuté, il semble donc pratique et pratique de sauvegarder le jeton d'accès sous forme de cornichon.

2. Créez un brouillon de l'e-mail

from email.mime.text import MIMEText
import base64

def create_message(sender, to, subject, message_text):
    enc = "utf-8"
    message = MIMEText(message_text.encode(enc), _charset=enc)
    message["to"] = to
    message["from"] = sender
    message["subject"] = subject
    encode_message = base64.urlsafe_b64encode(message.as_bytes())
    return {"raw": encode_message.decode()}

C'est dans la documentation de l'API Gmail Création de brouillons de messages, mais dans le cas de la documentation, la dernière ligne de la fonction create_message Mais

return {'raw': base64.urlsafe_b64encode(message.as_string())}

Il est devenu. Cependant, base64.urlsafe_b64encode () doit inclure des octets au lieu de chaînes en entrée, donc

encode_message = base64.urlsafe_b64encode(message.as_bytes())

Étant donné que le type str est requis dans le processus de modification et de sauvegarde dans le brouillon ultérieurement

return {"raw": encode_message.decode()}

Et décoder.

3. Enregistrez les données de messagerie créées par l'API Gmail en tant que brouillon

Ajoutez les données du courrier que vous avez créé précédemment au brouillon.

def create_draft(service, user_id, message_body):
    message = {'message':message_body}
    draft = service.users().drafts().create(userId=user_id, body=message).execute()
    return draft

Le service utilisé ici est comme un chef-d'œuvre lors de l'utilisation de l'API Gmail, et il est répertorié dans Référence de l'API Gmail. C'est l'instance qui contient la fonction. Ceci est fait avec le code suivant.

from googleapiclient.discovery import build

service = build("gmail", "v1", credentials=creds, cache_discovery=False)

Si vous combinez ce qui précède en un seul programme, il ressemblera à ce qui suit.

from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build

import base64
from email.mime.text import MIMEText

SCOPES = ["https://www.googleapis.com/auth/gmail.compose",]


def get_credential():
    launch_browser = True
    flow = InstalledAppFlow.from_client_secrets_file("client_id.json", SCOPES)
    flow.run_local_server()
    cred = flow.credentials
    return cred


def create_message(sender, to, subject, message_text):
    enc = "utf-8"
    message = MIMEText(message_text.encode(enc), _charset=enc)
    message["to"] = to
    message["from"] = sender
    message["subject"] = subject
    encode_message = base64.urlsafe_b64encode(message.as_bytes())
    return {"raw": encode_message.decode()}


def create_draft(service, user_id, message_body):
    message = {'message':message_body}
    draft = service.users().drafts().create(userId=user_id, body=message).execute()
    return draft


def main(sender, to, subject, message_text):
    creds = get_credential()
    service = build("gmail", "v1", credentials=creds, cache_discovery=False)
    message = create_message(sender, to, subject, message_text)
    create_draft(service, "me", message)


if __name__ == "__main__":

    sender = "Adresse de l'expéditeur de l'e-mail"
    to = "Adresse de destination"
    subject = "matière"
    message_text = "Texte"

    main(sender=sender, to=to, subject=subject, message_text=message_text)

Cela ajoutera le brouillon à Gmail. Tu l'as fait! (･ ∀ ･)

référence

・ L'article qui a été le plus utile https://qiita.com/muuuuuwa/items/822c6cffedb9b3c27e21

-Documentation sur la classe Flow et la classe InstalledAppFlow google_auth_oauthlib.flow module

・ Documents de googleapiclient.discovery.build https://googleapis.github.io/google-api-python-client/docs/epy/googleapiclient.discovery-module.html#build