text: #!/usr/bin/env python
  
  import argparse
  import copy
  import dateutil.parser
  import dateutil.tz
  import datetime
  import json
  import logging
  import time
  import urllib
  import urllib2
  import threading
  
  NEXT_ACTION_LABEL = u'next_action'
  NOT_STARTED_LABEL = u'not_started'
  args = None
  
  class TraversalState2(object):
    def __init__(self, not_started_label_id):
      self.remove_labels = []
      self.add_labels = []
      self.found_not_started = False
      self.not_started_label_id = not_started_label_id
    def clone(self):
      t = TraversalState2(self.not_started_label_id)
      t.found_not_started = self.found_not_started
      return t
      
  class TraversalState(object):
    """Simple class to contain the state of the item tree traversal."""
    def __init__(self, next_action_label_id):
      self.remove_labels = []
      self.add_labels = []
      self.found_next_action = False
      self.next_action_label_id = next_action_label_id
  
    def clone(self):
      """Perform a simple clone of this state object.
  
      For parallel traversals it's necessary to produce copies so that every
      traversal to a lower node has the same found_next_action status.
      """
      t = TraversalState(self.next_action_label_id)
      t.found_next_action = self.found_next_action
      return t
  
    def merge(self, other):
      """Merge clones back together.
  
      After parallel traversals, merge the results back into the parent state.
      """
      if other.found_next_action:
        self.found_next_action = True
      self.remove_labels += other.remove_labels
      self.add_labels += other.add_labels
  
  
  class Item(object):
    def __init__(self, initial_data):
      self.parent = None
      self.children = []
      self.checked = initial_data['checked'] == 1
      self.content = initial_data['content']
      self.indent = initial_data['indent']
      self.item_id = initial_data['id']
      self.labels = initial_data['labels']
      self.priority = initial_data['priority']
      self.date_string = initial_data['date_string']
      self.due_date = initial_data['due_date']
      if 'due_date_utc' in initial_data and initial_data['due_date_utc'] != None:
        p = dateutil.parser.parser()
        self.due_date_utc = p.parse(initial_data['due_date_utc'])
      else:
        # Arbitrary time in the future to always sort last
        self.due_date_utc = datetime.datetime(2100, 1, 1, tzinfo=dateutil.tz.tzutc())
  
    def GetItemMods2(self, state):
      # for not_started
      if state.not_started_label_id in self.labels:
        t1 = datetime.datetime.utcnow().replace(tzinfo=None)
        t2 = self.due_date_utc.replace(tzinfo=None)
        tDiff = t2 - t1
        if tDiff.total_seconds() < 86400:
          logging.info('time for one item: %d', tDiff.total_seconds())
          state.remove_labels.append(self)
      for item in self.children:
        item.GetItemMods2(state)
        
    def GetItemMods(self, state):
      if self.IsSequential():
        self._SequentialItemMods(state)
      elif self.IsParallel():
        self._ParallelItemMods(state)
      if not state.found_next_action and not self.checked:
        state.found_next_action = True
        if args.use_priority and self.priority != 4:
          state.add_labels.append(self)
        elif not args.use_priority and not state.next_action_label_id in self.labels:
          state.add_labels.append(self)
      else:
        if args.use_priority and self.priority == 4:
          state.remove_labels.append(self)
        elif not args.use_priority and state.next_action_label_id in self.labels:
          state.remove_labels.append(self)
  
    def SortChildren(self):
      # Sorting by priority and date seemed like a good idea at some point, but
      # that has proven wrong. Don't sort.
      pass
  
    def GetLabelRemovalMods(self, state):
      if args.use_priority:
        return
      if state.next_action_label_id in self.labels:
        state.remove_labels.append(self)
      for item in self.children:
        item.GetLabelRemovalMods(state)
  
    def _SequentialItemMods(self, state):
      """
      Iterate over every child, walking down the tree.
      If none of our children are the next action, check if we are.
      """
      for item in self.children:
        item.GetItemMods(state)
  
    def _ParallelItemMods(self, state):
      """
      Iterate over every child, walking down the tree.
      If none of our children are the next action, check if we are.
      Clone the state each time we descend down to a child.
      """
      frozen_state = state.clone()
      for item in self.children:
        temp_state = frozen_state.clone()
        item.GetItemMods(temp_state)
        state.merge(temp_state)
  
    def IsSequential(self):
      return not self.content.endswith('.')
      '''return self.content.endswith('--')'''
  
    def IsParallel(self):
      return self.content.endswith('.')
  
  class Project(object):
    def __init__(self, initial_data):
      self.unsorted_items = dict()
      self.children = []
      self.indent = 0
      self.is_archived = initial_data['is_archived'] == 1
      self.is_deleted = initial_data['is_deleted'] == 1
      self.name = initial_data['name']
      # Project should act like an item, so it should have content.
      self.content = initial_data['name']
      self.project_id = initial_data['id']
  
    def UpdateChangedData(self, changed_data):
      self.name = changed_data['name']
  
    def IsSequential(self):
      return self.name.endswith('--')
      '''return self.content.endswith('--')'''
      '''return not self.content.endswith('=')'''
  
    def IsParallel(self):
      return self.name.endswith('.')
      '''return self.content.endswith('=')'''
  
    SortChildren = Item.__dict__['SortChildren']
  
    def GetItemMods(self, state):
      if self.IsSequential():
        for item in self.children:
          item.GetItemMods(state)
      elif self.IsParallel():
        frozen_state = state.clone()
        for item in self.children:
          temp_state = frozen_state.clone()
          item.GetItemMods(temp_state)
          state.merge(temp_state)
      else: # Remove all next_action labels in this project.
        for item in self.children:
          item.GetLabelRemovalMods(state)
  
    def GetItemMods2(self, state):
      for item in self.children:
        item.GetItemMods2(state)
        
      
    def AddItem(self, item):
      '''Collect unsorted child items
  
      All child items for all projects are bundled up into an 'Items' list in the
      v5 api. They must be normalized and then sorted to make use of them.'''
      self.unsorted_items[item['id']] = item
  
    def DelItem(self, item):
      '''Delete unsorted child items'''
      del self.unsorted_items[item['id']]
  
  
    def BuildItemTree(self):
      '''Build a tree of items build off the unsorted list
  
      Sort the unsorted children first so that indentation levels mean something.
      '''
      self.children = []
      sortfunc = lambda item: item['item_order']
      sorted_items = sorted(self.unsorted_items.values(), key=sortfunc)
      parent_item = self
      previous_item = self
      for item_dict in sorted_items:
        item = Item(item_dict)
        if item.indent > previous_item.indent:
          logging.debug('pushing "%s" on the parent stack beneath "%s"',
              previous_item.content, parent_item.content)
          parent_item = previous_item
        # walk up the tree until we reach our parent
        while item.indent <= parent_item.indent:
          logging.debug('walking up the tree from "%s" to "%s"',
              parent_item.content, parent_item.parent.content)
          parent_item = parent_item.parent
  
        logging.debug('adding item "%s" with parent "%s"', item.content,
            parent_item.content)
        parent_item.children.append(item)
        item.parent = parent_item
        previous_item = item
      #self.SortChildren()
  
  
  class TodoistData(object):
    '''Construct an object based on a full Todoist /Get request's data'''
    def __init__(self, initial_data):
      self._not_started_id = None
      self._next_action_id = None
      self._SetLabelData(initial_data)
      self._projects = dict()
      self._seq_no = initial_data['seq_no']
      for project in initial_data['Projects']:
        if project['is_deleted'] == 0:
          self._projects[project['id']] = Project(project)
      for item in initial_data['Items']:
        self._projects[item['project_id']].AddItem(item)
      for project in self._projects.itervalues():
        project.BuildItemTree()
  
    def _SetLabelData(self, label_data):
      if args.use_priority:
        return
      if 'Labels' not in label_data:
        logging.debug("Label data not found, wasn't updated.")
        return
      # Store label data - we need this to set the next_action label.
      for label in label_data['Labels']:
        if label['name'] == NEXT_ACTION_LABEL:
          self._next_action_id = label['id']
          logging.info('Found next_action label, id: %s', label['id'])
        if label['name'] == NOT_STARTED_LABEL:
          self._not_started_id = label['id']
      if self._next_action_id == None:
          logging.warning('Failed to find next_action label, need to create it.')
  
    def GetSyncState(self):
      return {'seq_no': self._seq_no}
  
    def UpdateChangedData(self, changed_data):
      if 'seq_no' in changed_data:
        self._seq_no = changed_data['seq_no']
      if 'TempIdMapping' in changed_data:
        if self._next_action_id in changed_data['TempIdMapping']:
          logging.info('Discovered temp->real next_action mapping ID')
          self._next_action_id = changed_data['TempIdMapping'][self._next_action_id]
      if 'Projects' in changed_data:
        for project in changed_data['Projects']:
  	# delete missing projects
          if project['is_deleted'] == 1:
            logging.info('forgetting deleted project %s' % project['name'])
            del self._projects[project['project_id']]
          if project['id'] in self._projects:
            self._projects[project['id']].UpdateChangedData(project)
          else :
            logging.info('found new project: %s' % project['name'])
            self._projects[project['id']] = Project(project)
      if 'Items' in changed_data:
        for item in changed_data['Items']:
          if item['is_deleted'] == 1:
            logging.info('removing deleted item %d from project %d' % (item['id'], item['project_id']))
            self._projects[item['project_id']].DelItem(item)
          else:
            self._projects[item['project_id']].AddItem(item)
      for project in self._projects.itervalues():
        project.BuildItemTree()
        
    def GetProjectMods(self):
      mods = []
  
      for project in self._projects.itervalues():
        state = TraversalState2(self._not_started_id)
        project.GetItemMods2(state)
        for item in state.remove_labels:
          #logging.info('********************************************')
          #logging.info('%s',item.content)
          m = self.MakeNewMod(item)
          mods.append(m)
          item.labels.remove(self._not_started_id)
          item.date_string = ''
          item.due_date = None
          item.due_date_utc = None
          m['args']['labels'] = item.labels
          m['args']['date_string'] = item.date_string
          m['args']['due_date'] = item.due_date
          m['args']['due_date_utc'] = item.due_date_utc
      '''
      # We need to create the next_action label
      if self._next_action_id == None and not args.use_priority:
        self._next_action_id = '$%d' % int(time.time())
        mods.append({'type': 'label_register',
                     'timestamp': int(time.time()),
                     'temp_id': self._next_action_id,
                     'args': {
                       'name': NEXT_ACTION_LABEL
                      }})
        # Exit early so that we can receive the real ID for the label.
        # Otherwise we end up applying the label two different times, once with
        # the temporary ID and once with the real one.
        # This makes adding the label take an extra round through the sync
        # process, but that's fine since this only happens on the first ever run.
        logging.info("Adding next_action label")
        return mods
      for project in self._projects.itervalues():
        state = TraversalState(self._next_action_id)
        project.GetItemMods(state)
        if len(state.add_labels) > 0 or len(state.remove_labels) > 0:
          logging.info("For project %s, the following mods:", project.name)
        for item in state.add_labels:
          # Intentionally add the next_action label to the item.
          # This prevents us from applying the label twice since the sync
          # interface does not return our changes back to us on GetAndSync.
          # Apply these changes to both the item in the tree and the unsorted
          # data.
          # I really don't like this aspect of the API - return me a full copy of
          # changed items please.
          #
          # Also... OMFG. "Priority 1" in the UI is actually priority 4 via the API.
          # Lowest priority = 1 here, but that is the word for highest priority
          # on the website.
          m = self.MakeNewMod(item)
          mods.append(m)
          if args.use_priority:
            item.priority = 4
            project.unsorted_items[item.item_id]['priority'] = 4
            m['args']['priority'] = item.priority
          else:
            item.labels.append(self._next_action_id)
            m['args']['labels'] = item.labels
          logging.info("add next_action to: %s", item.content)
        for item in state.remove_labels:
          m = self.MakeNewMod(item)
          mods.append(m)
          if args.use_priority:
            item.priority = 1
            project.unsorted_items[item.item_id]['priority'] = 1
            m['args']['priority'] = item.priority
          else:
            item.labels.remove(self._next_action_id)
            m['args']['labels'] = item.labels
          logging.info("remove next_action from: %s", item.content)'''
      return mods
  
    @staticmethod
    def MakeNewMod(item):
      return {'type': 'item_update',
              'timestamp': int(time.time()),
              'args': {
                'id': item.item_id,
                }
              }
  
  
  
  
  def GetResponse(api_token):
    values = {'api_token': api_token, 'seq_no': '0'}
    data = urllib.urlencode(values)
    req = urllib2.Request('https://api.todoist.com/TodoistSync/v5.3/get', data)
    return urllib2.urlopen(req)
  
  def DoSyncAndGetUpdated(api_token, items_to_sync, sync_state):
    values = {'api_token': api_token,
              'items_to_sync': json.dumps(items_to_sync)}
    for key, value in sync_state.iteritems():
      values[key] = json.dumps(value)
    logging.debug("posting %s", values)
    data = urllib.urlencode(values)
    req = urllib2.Request('https://api.todoist.com/TodoistSync/v5.3/syncAndGetUpdated', data)
    return urllib2.urlopen(req)
  
  def main():
    parser = argparse.ArgumentParser(description='Add NextAction labels to Todoist.')
    parser.add_argument('--api_token', required=True, help='Your API key')
    parser.add_argument('--use_priority', required=False,
        action="store_true", help='Use priority 1 rather than a label to indicate the next actions.')
    global args
    args = parser.parse_args()
    logging.basicConfig(level=logging.DEBUG)
    response = GetResponse(args.api_token)
    initial_data = response.read()
    logging.debug("Got initial data: %s", initial_data)
    initial_data = json.loads(initial_data)
    a = TodoistData(initial_data)
    while True:
      try:   
        mods = a.GetProjectMods()
        if len(mods) == 0:
          time.sleep(5)
        else:
          logging.info("* Modifications necessary - skipping sleep cycle.")
        logging.info("** Beginning sync")
        sync_state = a.GetSyncState()
        changed_data = DoSyncAndGetUpdated(args.api_token,mods, sync_state).read()
        logging.debug("Got sync data %s", changed_data)
        changed_data = json.loads(changed_data)
        logging.info("* Updating model after receiving sync data")
        a.UpdateChangedData(changed_data)
        logging.info("* Finished updating model")
        logging.info("** Finished sync")
      except:
        print "Network error, try again.."
  
  if __name__ == '__main__':
    main()
  