google tasks, terminal, and geek tool

Over the course of the past few years, I’ve used many different todo list managers. I’ve tried OmniFocus (too expensive, especially for both the desktop and iPhone versions), EasyTask (which is very nice, and has a good iPhone client too), Things, Remember the Milk, and a few more. The closest I’ve come to an app that I really like is The Hit List, which I got in a mac bundle years ago. That app has been in beta for, like, 3 years with a very unresponsive developer. In fact it’s User’s discussion list is more a place for people to muse on whether or not a v1.0 of the app will ever actually appear. (Current rumor is that it showed up briefly in Apple’s OS X AppStore.)

My relationship to task managers, and my occasional interest in GTD that has fueled that relationship, have always felt way overly complicated. I do need reminders of the things I need to do, but invariably my lists sit in programs I rarely open, and do nothing to actually enhance my productivity. I also messed with most of those programs when I was using iCal and Apple Mail, and several of them worked well enough with those programs. More recently, I’ve felt completely ambivalent over the whole GTD approach, with contexts, and projects, and mixed temporalities. I find that I do the best with simple lists of things to do. For a little while I used the command line Todo.txt client that still allowed for tagging/contexts/projects/etc., and displayed that on my desktop with Geek Tool. Fun, geeky, and as complicated or easy as one might like. Not at all integrated with email.

On the topic of productivity for academics, I’ve consolidated my calendars and email in gmail out of shear convenience. I like the workflow of gmail– especially now with priority messages. I can simply archive messages with a single keystroke when it’s time to clean out the inbox and the like. I’ve used Google Tasks in concert with gmail before, and find it attractive for its simplicity. If I want project lists, I can simply start a new list. I also like that it’s integrated with my calendar, etc. That said, I do like having my list displayed on my desktop with Geek Tool, something that was impossible to do without an API for Google Tasks. To my surprise and delight, after many years of being pestered for it, Google finally released an API for Tasks a few days ago. So, yesterday I hacked together some code to interact with Tasks from the command line and to display my lists on my desktop using Geek Tool. The latter is slightly complicated because of the move to OAuth for authentication, but I got it working nonetheless. As it stands now, the cli script only allows listing tasks, adding tasks (and new lists), and clearing completed tasks. I’ll add updating and deleting individual tasks, but it’s slightly more complicated given the way tasks are ID’d in the API.

As with other applications that require authentication to interact with google services, your Tasks app needs to be authorized to make requests. So, for initial set-up there are two things you must do.

1. Register your new application with google’s API Console by activating the Google Task API, and providing the requested information for a new app. This process will give you a ClientID, a ClientSecret Key, and an Application Developer Key that are necessary to authenticate the application.
2. Download and install the google API python developer’s library. I first installed using easy_install, but it didn’t work. So, you should use download the tar package, unzip it, open the terminal, change directory to the unzipped folder, and execute the command sudo python setup.py install.
3. Authenticating the application the first time you run the script below from a new place (for example, the first time you run it from the command line, there will be a dialogue to approve access to your Tasks data. Paste the link provided into your browser, accept the access to your Tasks, then paste the provided key back into the terminal when asked for it.

The script below for using Tasks executes the authentication, and then interacts with Tasks based on arguments you pass via the command line. It stores secret codes in the Mac OS X keychain via the keyring module. The other dependencies are either from the Standard Python Library, or included in the google API library. Here’s the script:

#!/usr/bin/env python
# encoding: utf-8
"""
myTasks.py

Created by Chad Black on 2011-05-15.

Authentication adapted almost completely from Google's example at
https://code.google.com/apis/tasks/v1/using.html#authentication.

I just added keychain storage.
"""

import gflags
import httplib2
import keyring
import sys


from apiclient.discovery import build
from oauth2client.file import Storage
from oauth2client.client import OAuth2WebServerFlow
from oauth2client.tools import run

FLAGS = gflags.FLAGS

# Set up a Flow object to be used if we need to authenticate. This
# sample uses OAuth 2.0, and we set up the OAuth2WebServerFlow with
# the information it needs to authenticate. Note that it is called
# the Web Server Flow, but it can also handle the flow for native
# applications
# The client_id and client_secret are copied from the API Access tab on
# the Google APIs Console
FLOW = OAuth2WebServerFlow(
    client_id='653996198112.apps.googleusercontent.com',
    client_secret=keyring.get_password('tasksClient', 'YOUR USERNAME'),
    scope='https://www.googleapis.com/auth/tasks',
    user_agent='myTasks/v1')

# To disable the local server feature, uncomment the following line:
FLAGS.auth_local_webserver = False

# If the Credentials don't exist or are invalid, run through the native client
# flow. The Storage object will ensure that if successful the good
# Credentials will get written back to a file.
storage = Storage('tasks.dat')
credentials = storage.get()
if credentials is None or credentials.invalid == True:
  credentials = run(FLOW, storage)

# Create an httplib2.Http object to handle our HTTP requests and authorize it
# with our good Credentials.
http = httplib2.Http()
http = credentials.authorize(http)

# Build a service object for interacting with the API. Visit
# the Google APIs Console
# to get a developerKey for your own application.
service = build(serviceName='tasks', version='v1', http=http,
       developerKey=keyring.get_password('googleDevKey', 'YOUR USERNAME'))


def main(*argv):
 
# Display all tasks in all lists.	
# ex.: tasks ls

	if sys.argv[1] == 'ls':
		tasklists = service.tasklists().list().execute()
		for tasklist in tasklists['items']:
			print tasklist['title']
			listID=tasklist['id']
			tasks = service.tasks().list(tasklist=listID).execute()
			for task in tasks['items']:
				dueDate=''
				if 'due' in task: 
					fullDueDate=str(task['due'])
					dueDate=fullDueDate[:10] 
				print '    '+task['title']+' : '+dueDate
			print


# To add a task, the command is 'n'. Then, pass three arguments-- listName, newTask, dueDate.
# ex: tasks n listName "This is my task." 2011-01-01

	if sys.argv[1] == 'n':
		listName = sys.argv[2]
		task = {
		 	'title': sys.argv[3], 
		 	'due': sys.argv[4]+'T12:00:00.000Z',
			}					
		tasklists = service.tasklists().list().execute()
		listID = None
		for tasklist in tasklists['items']:
			if listName == tasklist['title']:
				listID=tasklist['id']
				break
		if listID == None:
			tasklist = {
		  	'title': listName,
		  	}
			result = service.tasklists().insert(body=tasklist).execute()
			listID = result['id']				
		newTask = service.tasks().insert(tasklist=listID, body=task).execute()

# clear completed tasks from all lists
# tasks c
	if sys.argv[1] == 'c':
		tasklists = service.tasklists().list().execute()
		for tasklist in tasklists['items']:
			listID = tasklist['id']
			
			service.tasks().clear(tasklist=listID, body='').execute()


if __name__ == '__main__':
	main()	

I link this script to a bash alias called tasks. To do that, add this line to your .profile or .bash_profile file:

alias tasks='python /Path/to/your/script/myTasks.py'

To check your tasks from the terminal, simply enter:

$ tasks ls

To add a task to a list, enter:

$ tasks n listName "New task title/description" dueDate

If you enter a list name that doesn’t exist, that list will be created. Due dates have to be in this form: YYYY-MM-DD. To clear completed tasks from your lists (which appear here as normal tasks), enter:

$ tasks c

The API returns JSON objects, which are converted to dictionaries in python, for both lists and tasks, each of which have unique IDs. These ID strings are awkward, but required to, for example, place a task in a specific list. The script matches IDs by searching dictionaries for matching list names. This is harder to do with individual tasks, which are also dictionaries. I could do some regex matching of part of the string of a task title, or simply match titles by entering the whole title of the task for deletion or updating. But that seems to me a bit of a pain on the user end. So, I think I might append sequential numbers to the dictionary of task items, and use that for ID matching.

At any rate, displaying a list of tasks on the desktop with Geek Tool is complicated in this situation because of the need for first time authentication. If you simply try to run the bash command python /path/to/script/myTasks.py from Geek Tool, google with ask for authentication. That’s a problem, because Geek Tool’s output is simply stout. It doesn’t allow for interaction. To get around this, I used an automator workflow to run the command and write to a text file I call geekTask.txt. I have Geek Tool run the workflow every couple of hours with the bash command

automator /path/to/workflow/geekTasks.workflow

Then, a few minutes later, in a separate Geek Tool box, I run the command

head -n 300 /path/to/textfile/geekTask.txt

That outputs the first 300 lines from the text file, and I have my todo lists displayed on my desktop. It’s a bit hackish, but works nonetheless.

What I like about this workflow, is I can use Tasks when I’m in gmail, while working in the terminal, on my iPhone, etc., and yet the resulting lists aren’t overly complicated with contexts, projects, and the other GTD cruft that ends up getting in the way of me actually getting things done.

UPDATE:/
I’ve added the ability to mark messages as completed or delete them from a specified list, and posted it here. Also, as is clear in the comments below, keyring is a python package in my script used to store your secret keys in your OS operating system. It’s also optional.

About ctb

Associate Professor of Early Latin America Department of History University of Tennessee-Knoxville

‹ new and improved twitter cli, now with more twitter sauce

Fulbright-Hays 2011 competition cancelled ›

Tagged with: command line, GeekTool, Google Tasks, python
Posted in programming