calendars.py

import datetime
import dateutil.parser
import pickle
import os.path
from googleapiclient.discovery import build
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request
from math import ceil
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
import matplotlib.ticker as ticker
import math

blacklist = [
    # Fill
]

now = datetime.datetime.utcnow().isoformat() + 'Z'

def days_ago(days):
    today = datetime.date.today()
    span = today - datetime.timedelta(days=days)
    return span.strftime('%Y-%m-%dT%H:%M:%SZ')

def authenticate():
    creds = None
    if os.path.exists('token.pickle'):
        with open('token.pickle', 'rb') as token:
            creds = pickle.load(token)
    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(
                'credentials.json', SCOPES)
            creds = flow.run_local_server()
        # Save the credentials for the next run
        with open('token.pickle', 'wb') as token:
            pickle.dump(creds, token)

    return build('calendar', 'v3', credentials=creds)

def confirmed(event, user):
    try:
        return next(c for c in event["attendees"] if c["email"] == user)["responseStatus"] == "accepted"
    except:
        return False

def get_all_results(service, user, days):
    events = []

    events_result = service.events().list(
        calendarId=user, timeMin=days_ago(days), timeMax=now,
        singleEvents=True, orderBy='startTime', showHiddenInvitations=True
    ).execute()
    if events_result.get('items'):
        events = events + events_result.get('items')

    while events_result.get('nextPageToken', False):
        events_result = service.events().list(
            calendarId=user, timeMin=days_ago(days), timeMax=now,
            singleEvents=True, orderBy='startTime', showHiddenInvitations=True,
            pageToken=events_result.get('nextPageToken')
        ).execute()
        if events_result.get('items'):
            events = events + events_result.get('items')

    return events

def find_events(service, user, days):
    events = get_all_results(service, user, days)
    evts = [e for e in events if e.get("attendees") and e["start"].get("dateTime")]
    return [e for e in evts if confirmed(e, user) and get_length(e) < 1440 and e.get("summary") not in blacklist]

def get_length(event):
    dateTimeDifference = dateutil.parser.parse(event["end"]["dateTime"]) - dateutil.parser.parse(event["start"]["dateTime"])
    return dateTimeDifference.total_seconds() / 60

def is_alone(event):
    return len(event["attendees"]) == 1

def is_internal(event):
    attendees = event["attendees"]
    return all("algolia" in a["email"] for a in attendees)

def create_df(service, user, days):
    events = find_events(service, user, days)
    data = []
    for e in events:
        row = {}
        row["start"] = e["start"]["dateTime"]
        if is_internal(e): row["type"] = "internal"
        else: row["type"] = "external"
        row["duration"] = get_length(e)
        data.append(row)
    df = pd.DataFrame.from_dict(data)
    df["start"] = pd.to_datetime(df["start"])
    return df.set_index("start")

def plot_df(df, sample):
    plt.plot(df[df.type=="internal"].resample(sample).sum(), label="internal")
    plt.plot(df[df.type=="external"].resample(sample).sum(), label="external")
    plt.ylabel('some numbers')
    ax = plt.gca()
    ax.xaxis.set_major_formatter(mdates.DateFormatter('%b %d'))
    ax.yaxis.set_major_formatter(ticker.FuncFormatter(lambda x, pos: math.ceil(x/60)))
    plt.legend()
    plt.show()