GMail Clean

from itertools import count
import streamlit as st
import datetime
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build

# 1) OAuth2 scope to read your mail
# SCOPES = ['https://www.googleapis.com/auth/gmail.readonly']
SCOPES = ['https://mail.google.com/']

CLIENT_SECRET = "client_secret.json"

Select start_date and end_date.

min_date = datetime.date(1997, 1, 1)

col1, col2 = st.columns(2)
with col1:
    start_date = st.date_input("Start date", max_value="today", min_value=min_date, value=datetime.date(2006, 12, 1))
with col2:
    end_date = st.date_input("End date", max_value="today", min_value=min_date, value=datetime.date(2006, 12, 31))

Calculate time interval between start_date and end_date

if start_date and end_date:

    # If ``end_date`` is less than ``start_date`` then swap dates.
    if end_date < start_date:
        start_date, end_date = end_date, start_date

    time_interval = end_date - start_date
    st.write(f"Time interval: {time_interval.days} days")

Google Cloud authentication

def authenticate():
    # If you have a token.json from a previous run, it’ll be used.
    creds = None
    try:
        creds = Credentials.from_authorized_user_file('token.json', SCOPES)
    except FileNotFoundError:
        pass

    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file(
                CLIENT_SECRET, SCOPES)
            creds = flow.run_local_server(port=0)
        # Save for next time
        with open('token.json', 'w') as token:
            token.write(creds.to_json())

    return build('gmail', 'v1', credentials=creds)

Counts messages matching the Gmail search after start_date and before end_date. Dates are in YYYY/MM/DD format.

def count_messages_in_interval(service, start_date, end_date, user_id='me'):
    query = f'after:{start_date} before:{end_date}'
    message_ids = []
    request = service.users().messages().list(userId=user_id, q=query)
    while request is not None:
        response = request.execute()
        messages = response.get('messages', [])
        message_ids.extend([msg['id'] for msg in messages])
        # Fetch next page, if any
        request = service.users().messages().list_next(request, response)
    return message_ids


def delete_messages(service, message_ids):
    # Gmail API allows deleting up to 1000 emails at once (batch delete)
    batch_size = 1000
    st.write(f"Deleting {len(message_ids)} emails.")
    for i in range(0, len(message_ids), batch_size):
        ids = message_ids[i:i+batch_size]

        # Delete batch of emails
        service.users().messages().batchDelete(
            userId='me',
            body={'ids': ids}
        ).execute()
        st.info(f"Deleted {len(ids)} emails.")

main

svc = authenticate()

message_ids = []

if "message_ids" in st.session_state:
    message_ids = st.session_state.message_ids

if st.button("Count", use_container_width=True):
    message_ids = count_messages_in_interval(svc, start_date, end_date)
    st.session_state.message_ids = message_ids
    st.info(f'You have {len(message_ids)} messages between the dates specified.')

if st.sidebar.button("Delete", type="primary", disabled=len(message_ids)==0):
    delete_messages(svc, message_ids)
    st.success("Deletion process completed.")