Obtenez l'objet et le corps de Gmail avec Python et l'API Gmail
introduction
Utilisez Python et l'API Gmail pour obtenir le sujet et le corps de l'e-mail cible stockés dans votre boîte de réception et l'enregistrer dans un fichier.
Conditions préalables
-Créer un projet Google Cloud Platform et activer l'API Gmail. -Obtenir des informations d'authentification pour l'utilisation de l'API Gmail. Les articles suivants seront utiles. https://qiita.com/muuuuuwa/items/822c6cffedb9b3c27e21
Environnement d'exécution
Python 3.9 Bibliothèques requises ・ Google-api-python-client ・ Google-auth-httplib2 ・ Google-auth-oauthlib
Code source
Le code utilisé cette fois-ci peut être téléchargé depuis GitHub. https://github.com/kirinnsan/backup-gmail J'ai également téléchargé le Dockerfile, donc si vous pouvez utiliser Docker, vous n'avez pas besoin d'installer la bibliothèque avec pip install.
Authentification
Placez les informations d'identification créées dans le même répertoire avec le nom de fichier client_id.json. Le flux d'authentification est implémenté dans la classe InstalledAppFlow, où l'utilisateur ouvre l'URL d'authentification spécifiée, obtient le code d'authentification et le colle sur la console ** run_console ** et s'authentifie à l'aide du serveur Web ** run_local_server. Il existe deux types de méthodes **.
Cette fois, l'authentification est effectuée à l'aide de la méthode run_console.
Si la première authentification réussit, un token.pickle contenant le jeton d'accès et le jeton de mise à jour sera créé dans le répertoire. Après cela, l'authentification sera effectuée en utilisant ceci.
auth.py
import pickle
import os.path
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request
from google.auth.exceptions import GoogleAuthError
def authenticate(scope):
creds = None
# The file token.pickle stores the user's access and refresh tokens, and is
# created automatically when the authorization flow completes for the first
# time.
if os.path.exists('token.pickle'):
with open('token.pickle', 'rb') as token:
creds = pickle.load(token)
# If there are no (valid) credentials available, let the user log in.
if not creds or not creds.valid:
try:
if creds and creds.expired and creds.refresh_token:
creds.refresh(Request())
else:
flow = InstalledAppFlow.from_client_secrets_file(
'client_id.json', scope)
creds = flow.run_console()
except GoogleAuthError as err:
print(f'action=authenticate error={err}')
raise
# Save the credentials for the next run
with open('token.pickle', 'wb') as token:
pickle.dump(creds, token)
return creds
Récupérer des e-mails à l'aide de l'API Google
Il utilise l'API Gmail pour implémenter une méthode pour obtenir une liste d'e-mails dans la boîte de réception et une méthode pour obtenir l'objet et le corps de l'e-mail cible. Vous pouvez spécifier le nombre maximum d'éléments à récupérer et les conditions de recherche dans la liste de diffusion.
client.py
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
import util
class ApiClient(object):
def __init__(self, credential):
self.service = build('gmail', 'v1', credentials=credential)
def get_mail_list(self, limit, query):
# Call the Gmail API
try:
results = self.service.users().messages().list(
userId='me', maxResults=limit, q=query).execute()
except HttpError as err:
print(f'action=get_mail_list error={err}')
raise
messages = results.get('messages', [])
return messages
def get_subject_message(self, id):
# Call the Gmail API
try:
res = self.service.users().messages().get(userId='me', id=id).execute()
except HttpError as err:
print(f'action=get_message error={err}')
raise
result = {}
subject = [d.get('value') for d in res['payload']['headers'] if d.get('name') == 'Subject'][0]
result['subject'] = subject
# Such as text/plain
if 'data' in res['payload']['body']:
b64_message = res['payload']['body']['data']
# Such as text/html
elif res['payload']['parts'] is not None:
b64_message = res['payload']['parts'][0]['body']['data']
message = util.base64_decode(b64_message)
result['message'] = message
return result
Ce qui suit est le processus de décodage du corps encodé en base64 et le processus d'enregistrement du message récupéré. Le fichier sera enregistré dans le répertoire spécifié sous la forme ** mail subject.txt **.
util.py
import base64
import os
def base64_decode(b64_message):
message = base64.urlsafe_b64decode(
b64_message + '=' * (-len(b64_message) % 4)).decode(encoding='utf-8')
return message
def save_file(base_dir, result):
os.makedirs(base_dir, exist_ok=True)
file_name = base_dir + '/' + result['subject'] + '.txt'
with open(file_name, mode='w') as f:
f.write(result['message'])
Traitement principal
Voici le code source de la partie exécution. En tant que flux de traitement,
- Authentification
- Obtenez une liste d'e-mails en fonction du nombre maximal d'éléments et des conditions de recherche
- Obtenez le sujet et le corps de l'e-mail cible à partir de l'ID de chaque e-mail
- Enregistrer dans un fichier sous la forme ** Subject.txt ** Sera.
main.py
from __future__ import print_function
import auth
from client import ApiClient
import util
# If modifying these scopes, delete the file token.pickle.
SCOPES = ['https://www.googleapis.com/auth/gmail.readonly']
# Number of emails retrieved
MAIL_COUNTS = 5
# Search criteria
SEARCH_CRITERIA = {
'from': "[email protected]",
'to': "",
'subject': "Sujet du courriel"
}
BASE_DIR = 'mail_box'
def build_search_criteria(query_dict):
query_string = ''
for key, value in query_dict.items():
if value:
query_string += key + ':' + value + ' '
return query_string
def main():
creds = auth.authenticate(SCOPES)
query = build_search_criteria(SEARCH_CRITERIA)
client = ApiClient(creds)
messages = client.get_mail_list(MAIL_COUNTS, query)
if not messages:
print('No message list.')
else:
for message in messages:
message_id = message['id']
# get subject and message
result = client.get_subject_message(message_id)
# save file
util.save_file(BASE_DIR, result)
if __name__ == '__main__':
main()
Cette fois, le nombre maximum d'acquisitions est de 5, le destinataire est ** [email protected] **, et le sujet est ** l'objet du courrier **. Lorsque vous spécifiez le destinataire, définissez-le sous la forme ** de: [email protected] ** ou ** de: Hanako **. Pour le sujet, définissez-le sous la forme de ** sujet: sujet **. La page officielle suivante décrit les conditions et l'utilisation qui peuvent être utilisées avec Gmail. https://support.google.com/mail/answer/7190
Le courrier récupéré est enregistré dans le répertoire mail_box.
Exécutez l'application.
python3 main.py
Une fois exécuté, vous serez invité à ouvrir l'URL d'authentification à partir de la console comme indiqué ci-dessous, alors ouvrez l'URL.
Lorsque vous ouvrez l'URL, l'écran suivant apparaît: Cliquez sur Détails → Aller à la page non sécurisée.
Cliquez sur Autoriser.
Cliquez sur Autoriser.
Le code sera affiché, copiez-le et collez-le dans la partie Entrez le code d'autorisation de la console.
Si l'authentification réussit, un traitement ultérieur est effectué et le courrier est enregistré.
finalement
La référence officielle a un exemple de l'application lors de l'utilisation de Python, vous pouvez donc également vous y référer. https://developers.google.com/gmail/api/quickstart/python
J'ai pu spécifier les conditions de recherche et enregistrer l'e-mail cible. Cette fois, je n'ai enregistré que le titre et le corps du mail reçu, mais comme il existe diverses autres API dans l'API Gmail, il semble que diverses choses puissent être faites selon la méthode.
Recommended Posts