Sunday, 15 March 2015

Raspberry Pi Powered Coffee Need Predictor Using Python and API Data

I like coffee.  A lot.  Too much perhaps.  Hence a Geek project that includes coffee is extremely exciting for me!

In a queue in a coffee shop a couple of weeks ago, the Barista recognised my colleague and asked him if he wanted "his usual" coffee.  After commenting on how cool this was we continued to discuss what if a new Barista had started?  How could the coffee shop use technology to provide the same great service?  So we discussed:

  • Perhaps the coffee shop could allow you to register your photo and your preferred coffee online and then use facial recognition as you join the queue to spot you and tell the Barista what your preference is.

...but them, as Geek conversations go, we evolved this to be:

  • Facial recognition plus access to personal API data.  This API data will tell the coffee shop how tired you're likely to be and thus they can recommend the coffee you need rather than the coffee you prefer.

For some reasons the person serving behind the counter wasn't up for this as an idea so I decided to build it myself...

So overall this is based upon the premise that caffeine is a stimulant and the more tired you are the more caffeine you need.  Sounds plausible to me.

First to think about what information is readily available about how tired I might be.  Based upon the Geek work I've done recently I have:

  • Fitbit data based upon the FitBit API.  This will tell me how many steps I did the day before, how many floors I climbed and how well I slept the previous night.
  • Strava data from my Garmin Forerunner that I've accessed using the Strava API.
  • General exercise data I've logged using my "Jerks" system.

The big idea was that I could write a Python script on my Raspberry Pi to:

  1. Gather data from these sources.
  2. Compare the results against pre-defined thresholds.
  3. Accumulate coffee points if the thresholds are breached.
  4. Map the resulting number of points to a coffee (more points is a coffee with more caffeine) and email the result to myself.

There's a full code listing at the bottom but here's a quick summary of the key points.

Fitbit Data
Using Python Fitbit (see my last post on this which tells you how to authenticate and access the API using Python objects).

To get steps and floors I created a Fitbit object and then did:
fitbit_activities = authd_client._COLLECTION_RESOURCE('activities',date=MyDate)

Where MyDate is yesterdays date in the format YYYY-MM-DD.  This is formed using the GetADate() function (see full code listing below for this).  GetADate() takes a parameter to define if it's todays date, yesterdays etc. and then does a date subtraction to provide the required date.

The response is a JSON structure from which you can extract the step count and the number of floors.  JSON parsing is a bit hit 'n' miss for me but through trial and error I found out:
Steps = fitbit_activities['summary']['steps'])
Floors = fitbit_activities['summary']['floors']

This can then be compared with thresholds to see if a "coffee point" is accumulated.  Specifically:
  • More than 10,000 means a coffee point is accumulated.
  • More than 25 floors means a coffee point is accumulated.
(With the floor and steps thresholds being nicely defined as constants).

I got the sleep data by doing:
fitbit_sleep = authd_client._COLLECTION_RESOURCE('sleep')

(No date specified as I wanted today's sleep value).  The specific value wanted can then be extracted from the JSON using:
Sleep = fitbit_sleep['summary']['totalMinutesAsleep']

Then the threshold comparison can be done again:
  • Less than 420 minutes (7 hours) means a point accumulated.
As an aside, the sleep element of the API looks epic.  More investigation is required but it looks like a record is logged for every minute that the Fitbit thinks you're asleep.  More Geek investigation is required I think...

Strava Data
Strava data is easy to access using a direct API plus an access token you get when you register as a developer.  (See here for a refresher on this).

The semi-tricky bit was specifying a date parameter to avoid extracting all data from the API and having to parse it yourself to pick out all action since the day before.  With the Strava API you can specify "before" and "after" parameters in Unix time to limit what is provided by the API.  To do this I:
  1. Used the GetADate function described above to get yesterday's date.
  2. Turned this into Unix time using a function I wrote called ConvertToUnix()
You can then get the API date using methods from the built-in urllib2 module:
StravaText = urllib2.urlopen('https://www.strava.com/api/v3/activities?access_token=' + StravaToken + '&after=' + TheUnixTime).read()

A coffee point is accumulated simply by virtue of having done one or more Strava activities since yesterday.  These can be counted by simply doing:
StravaCount = StravaText.count('tcx')

Where the string 'tcx' appears once and once only for each Strava activity (it's the filename I uploaded from Garmin with the exercise data in it).

Jerks Data
For the Jerks system I created, I log data in a mysql database on my Raspberry Pi.  Hence accessing data is simply a question of running an SQL query.  First create a database object:
db = MySQLdb.connect(dbHost,dbDatabase,dbUsername,dbPassword)
curs=db.cursor()

Then get yesterdays date (same method as above) and form the query:
JerksQuery =  'SELECT * FROM ' + dbMainTable + ' WHERE tdate = "' + MyDate + '";'
Then counting how many Jerks activities I did is a simple case of assessing curs.rowcount.  More than 5 Jerks (my average for the last couple of weeks) means a coffee point is accumulated.

Coffee Point to Coffee Translation
So that just leaves mapping the number of coffee points accumulated to an actual coffee.  This is done in the ChooseACoffee() function and this is the "complex" logic:
  • 0 points means a nice cup of tea.
  • 1 point means a small coffee.
  • 2 points means a medium coffee.
  • 3 points means a large coffee.
  • 4 points means a large coffee and a single espresso.
  • 5 points means a large coffee and a double espresso.
With the coffee in question (Latte, Americano or Cappuccino) selected by creating a random integer from 1 to 3 using the randint function.

Finishing it Off
So having chosen the coffee the script then writes a HTML email (re-using code from my Jerks summary project) then sends it (again re-using the Jerks summary code).

The resulting email is sent automatically as the script is run using a cron job and looks like this:


Improvements
There's much room for improvement here:
  • The overall algorithm is far too simplistic.  For example, if I had 5 minutes sleep or 6 hours 59 minutes sleep this still only equates to 1 coffee point.  Equally a Strava (which could be pretty hard) is given the same weighting as a jerk (which could be relatively easy). 
  • The data structures I use are really lame.  I use multiple lists rather then using a single data structure.  I need to investigate this more.  Comments please on this.
  • The email is a bit boring.  I experimented with adding images to the HTML content of the email but it didn't work.  I think I need to use MIME multipart structures for this but didn't get round to doing it.
  • There's loads of code there; far too much.  I need to streamline it a bit.  Perhaps write it in Java...

The Code
It's all below.  Of course I've blanked out all the keys and passwords!  You'll need to get these yourself.  Happy drinking?

#V1 = First attempt
import fitbit
from datetime import date, datetime, timedelta
from time import time, mktime
import smtplib
import MySQLdb
import urllib2
from random import randint

#MIME multipart stuff
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.MIMEImage import MIMEImage

#Date manipulation related constants
DateToday = 'DateToday'
DateYesterday = 'DateYesterday'
DateFirstDayOfWeek = 'DateFirstDayOfWeek'
DateFirstDayOfMonth = 'DateFirstDayOfMonth'
DateFirstDayOfYear = 'DateFirstDayOfYear'

#Constants - For Fitbit API
CLIENT_KEY = 'lovelovemedo'
CLIENT_SECRET = 'youknowiloveyou'
USER_KEY = 'illalwaysbetrue'
#USER_KEY = 'sopleasepleaseplease'
USER_SECRET = 'lovemedo'

#Constants - Fitbit thresholds
StepThreshold = 10000   #Daily target
FloorThreshold = 25     #Rough average for when I'm not running
SleepThreshold = 420    #7 hours sleep

#Constants - For Strava
StravaToken = 'itsbeenaharddaysnight'
StravaThreshold = 0

#Constants - For Jerks
dbMainTable = 'iamtheeggman'
dbHost = 'theyaretheeggmen'
dbDatabase = 'iamthewalrus'
dbUsername = 'googoogajoob'
dbPassword = 'googoogajoob'

#Constants - Jerks thresholds
JerksThreshold = 5

#Email Constants  
smtpserver = 'in.the.town.where.i.was.born'
AUTHREQUIRED = 1 # if you need to use SMTP AUTH set to 1
smtpuser = 'lived.a.man.who.sailed.to.sa'  # for SMTP AUTH, set SMTP username here
smtppass = 'andhetoldmeofhislife'  # for SMTP AUTH, set SMTP password here
RECIPIENTS = 'in.a.yellow.submarine'
SENDER = 'we.all.live.in.a.yellow.submarine'

##########################################################
#Choose what coffee to drink.  Takes a points count as an input
#and decides what coffee to drink.  Randomises to choose a different coffee type
def ChooseACoffee(CoffPoints):
  #First choose a coffee type
  CoffeeVar = randint(1,3)
  if (CoffeeVar == 1):
    CoffeeType = 'Latte'
  elif (CoffeeVar == 2):
    CoffeeType = 'Cappucino'
  elif (CoffeeVar == 3):
    CoffeeType = 'Americano'

  #Now choose a size based upon the points value sent as a parameter
  if (CoffPoints == 0):
    CoffeeString = 'You need a nice cup of tea.'
  elif (CoffPoints == 1):
    CoffeeString = 'You need a small ' + CoffeeType + '.'
  elif (CoffPoints == 2):
    CoffeeString = 'You need a medium ' + CoffeeType + '.'
  elif (CoffPoints == 3):
    CoffeeString = 'You need a large ' + CoffeeType + '.'
  elif (CoffPoints == 4):
    CoffeeString = 'You need a large ' + CoffeeType + ' and a single espresso.'
  elif (CoffPoints == 5):
    CoffeeString = 'You need a large ' + CoffeeType + ' and a double espresso.'

  return CoffeeString

#Gets a initial timestampt for emails
def GetDateTime():
  #Get the time, format it and return it
  now = datetime.now()
  return str(now.date()) + ' ' + str(now.strftime("%H:%M:%S"))

#Send an email
def SendEmail(TheSubject,TheMessage):
  #Form the message
  #msg = "To:%s\nFrom:%s\nSubject: %s\n\n%s" % (RECIPIENTS, SENDER, TheSubject, TheMessage)
  
  #Start forming the MIME Multipart message
  msg = MIMEMultipart('alternative')
  msg['Subject'] = TheSubject
  msg['From'] = SENDER
  msg['To'] = RECIPIENTS

  # Record the MIME types of both parts - text/plain and text/html.
  #part1 = MIMEText(text, 'plain')
  part2 = MIMEText(TheMessage, 'html')
  
  # Attach parts into message container.
  # According to RFC 2046, the last part of a multipart message, in this case
  # the HTML message, is best and preferred.
  #msg.attach(part1)
  msg.attach(part2)
  
  #print msg

  #Do the stuff to send the message  
  server = smtplib.SMTP(smtpserver,587)
  server.ehlo()
  #server.starttls() 
  server.ehlo()
  server.login(smtpuser,smtppass)
  server.set_debuglevel(1)
  server.sendmail(SENDER, [RECIPIENTS], msg.as_string())
  server.quit()

#Creates a string with a HTML table and a heading based upon parameters sent
#(EmailSubject,ActualsList,ThresholdList,PointsList)
def CreateHTMLTable(InTitle,CatList,AcList,ThreshList,PtList):
  try:
    #Start with the heading
    OutString = '<H1>' + InTitle + '</H1>\r\n'
    
    #Start the table
    OutString = OutString + '<table border="1">\n\r'
    #See if there is anything to write
    for i in range(0,len(AcList)):
      #Add the table opening tag

      #Add the list elements as table rows
      OutString = OutString + '<tr>\r\n'
      #Add the table elements
      OutString = OutString + '<td>' + CatList[i] + '</td>\r\n'
      OutString = OutString + '<td>' + AcList[i] + '</td>\r\n'
      OutString = OutString + '<td>' + ThreshList[i] + '</td>\r\n'
      OutString = OutString + '<td>' + PtList[i] + '</td>\r\n'

      #Close the table row
      OutString = OutString + '</tr>\r\n'    

    #Close the table tag      
    OutString = OutString + '</table>\r\n'
    
    #Return the result
    return OutString
  except:
    return 'Error creating table'
#Returns dates in different formats for different uses based upon the parameter passed
#Returns a date based upon the parameter supplied
def GetADate(DateType):
  #try:
    if (DateType == DateToday):    #Just get and return todays date
      #Get the time, format it and return it
      now = datetime.now()
      return now.strftime("%Y-%m-%d")
    elif (DateType == DateYesterday):
      now = datetime.now()
      TheDateYesterday = now - timedelta(days=1)
      return TheDateYesterday.strftime("%Y-%m-%d")
    elif (DateType == DateFirstDayOfWeek):   #The first day of the current week.  Sunday is 0. Monday is 1 etc.  We want to know how many days from Monday it is
      #Find what day of the week it is
      now = datetime.now()
      DayOfWeek = int(now.strftime("%w"))   #Get the number of the day of the week
      print 'Day of week ->>' + str(DayOfWeek)
      #See what to subtract.  Sunday is a special case
      if (DayOfWeek == 0):
        DayDelta = 6         #Monday was always 6 days ago on a Sunday!
      else:
        DayDelta = DayOfWeek - 1
      print 'Day delta ->>' + str(DayDelta)
      DateOfMonday = now - timedelta(days=DayDelta)
      print 'Monday was ->>' + str(DateOfMonday)
      return DateOfMonday.strftime("%Y-%m-%d")
    elif (DateType == DateFirstDayOfMonth):
      now = datetime.now()
      DayOfMonth =  int(now.strftime("%d"))
      DayDelta = DayOfMonth - 1
      FirstDateOfMonth = now - timedelta(days=DayDelta)
      return FirstDateOfMonth.strftime("%Y-%m-%d")
    elif (DateType == DateFirstDayOfYear):
      now = datetime.now()
      DayOfYear =  int(now.strftime("%j"))
      DayDelta = DayOfYear - 1
      FirstDateOfYear = now - timedelta(days=DayDelta)
      return FirstDateOfYear.strftime("%Y-%m-%d")

#Returns a Unix time based upon the date sent
def ConvertToUnix(InDate):
  #What we'll be sent is a text string in the format yyyy-mm-dd.  Need to change it to a proper date variable
  DateVal = datetime.strptime(InDate,"%Y-%m-%d")
  
  #Now turn into Unix time
  UnixTime = mktime(DateVal.timetuple())
  return int(UnixTime)

#################################################################################################
#Main body of code

#Start a list that we'll use to track all the data
CategoryList = []     #Contains a string showing the category
ActualsList = []      #Contains a string showing actuals
ThresholdList = []    #Contains a string showing thresholds
PointsList = []       #Contains a string showing resulting points

#Add the headings for the resulting table
CategoryList.append('Activity')
ActualsList.append('Value')
ThresholdList.append('Threshold')
PointsList.append('Coffee Points')

#First we do Fitbit
#Create an object to access the Fitbit API
authd_client = fitbit.Fitbit(CLIENT_KEY, CLIENT_SECRET, resource_owner_key=USER_KEY, resource_owner_secret=USER_SECRET)

#Get yesterdays activities - First get a date in format yyyy-mm-dd
#Now access the activities component of the API
MyDate = GetADate(DateYesterday)
fitbit_activities = authd_client._COLLECTION_RESOURCE('activities',date=MyDate)
print 'Activities:'
print fitbit_activities
print '~~~~~~~~~~~~~~~~~~~~'
print 'Steps: ' + str(fitbit_activities['summary']['steps'])
print 'Floors: ' + str(fitbit_activities['summary']['floors'])

#Add the various items to the lists.  Start with Steps
CategoryList.append('Fitbit Steps')
ActualsList.append(str(fitbit_activities['summary']['steps']))
ThresholdList.append(str(StepThreshold))
if (fitbit_activities['summary']['steps'] > StepThreshold):
  PointsList.append('1')
  CoffeePoints = 1
else:
  PointsList.append('0')
  CoffeePoints = 0

#Add the various items to the lists.  Do Floors
CategoryList.append('Fitbit Floors')
ActualsList.append(str(fitbit_activities['summary']['floors']))
ThresholdList.append(str(FloorThreshold))
if (fitbit_activities['summary']['floors'] > FloorThreshold):
  PointsList.append('1')
  CoffeePoints = CoffeePoints + 1
else:
  PointsList.append('0')

#Now for sleep
fitbit_sleep = authd_client._COLLECTION_RESOURCE('sleep')    #No date as it's today's data we want
print '~~~~~~~~~~~~~~~~~~~~~'
print 'Sleep: ' + str(fitbit_sleep['summary']['totalMinutesAsleep'])

#Add the various items to the lists.  Now do sleep
CategoryList.append('Fitbit sleep')
ActualsList.append(str(fitbit_sleep['summary']['totalMinutesAsleep']))
ThresholdList.append(str(SleepThreshold))
if (fitbit_sleep['summary']['totalMinutesAsleep'] < SleepThreshold):
  PointsList.append('1')
  CoffeePoints = CoffeePoints + 1
else:
  PointsList.append('0')

#Second we do Strava
#We want to see if we've done any Strava since first thing yesterday.  So after 00:00:00 yesterday.
#First we get yesterdays date, then we turn into Unix timestamp which can be used as Strava API "after" parameter
MyDate = GetADate(DateYesterday)
TheUnixTime = str(ConvertToUnix(MyDate))

#Access the Strava API using a URL
StravaText = urllib2.urlopen('https://www.strava.com/api/v3/activities?access_token=' + StravaToken + '&after=' + TheUnixTime).read()
print StravaText
#See what we got
StravaCount = StravaText.count('tcx')
if (StravaCount > StravaThreshold):
  print 'You did a Strava!'
else:
  print 'You did no Strava :-('

#Add to the output lists
CategoryList.append('Stravas')
ActualsList.append(str(StravaCount))
ThresholdList.append(str(StravaThreshold))
if (StravaCount > StravaThreshold):
  PointsList.append('1')
  CoffeePoints = CoffeePoints + 1
else:
  PointsList.append('0')

#Now we do Jerks - First connect to the database
db = MySQLdb.connect(dbHost,dbDatabase,dbUsername,dbPassword)
curs=db.cursor()

#Get yesterdays date for the SQL query
MyDate = GetADate(DateYesterday)
JerksQuery =  'SELECT * FROM ' + dbMainTable + ' WHERE tdate = "' + MyDate + '";'
print JerksQuery
curs.execute (JerksQuery)
print "Jerks count: " + str(curs.rowcount)

#Add to the output lists
CategoryList.append('Jerks count')
ActualsList.append(str(curs.rowcount))
ThresholdList.append(str(JerksThreshold))
if (curs.rowcount > JerksThreshold):
  PointsList.append('1')
  CoffeePoints = CoffeePoints + 1
else:
  PointsList.append('0')

for i in range(0,len(CategoryList)):
  print CategoryList[i] + '-' + ActualsList[i] + '-' + ThresholdList[i] + '-' + PointsList[i]

print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
print 'Total coffee points: ' + str(CoffeePoints)

#Get the email subject.  This is the coffee type inferred from the amountof coffee points
EmailSubject = ChooseACoffee(CoffeePoints)
print EmailSubject

#Start forming the HTML
EmailHTML = '<HTML>\r\n<HEAD></HEAD>\r\n<BODY>\r\n<H1>What Coffee do You Need?</H1>\r\n'

#Add the coffee image
#EmailHTML = EmailHTML + '<img src="/coffeecup.jpg" alt="coffee" width="256" height="256">'

#Add the table for the HTML
EmailHTML = EmailHTML + CreateHTMLTable(EmailSubject,CategoryList,ActualsList,ThresholdList,PointsList)

#End the HTML
EmailHTML = EmailHTML + '</BODY>\r\n</HTML>'

#Send the email
SendEmail(EmailSubject + ' ' + GetDateTime(),EmailHTML)