docs: def pull(options):
      """
      pull all remote programs to a local directory
  
      """
      configuration = config.get_default()
      app_url = configuration['app_url']
  
      if options.deployment != None:
          deployment_name = options.deployment
      else:
          deployment_name = configuration['deployment_name']
  
      client_id = configuration['client_id']
      client_secret = configuration['client_secret']
  
      token_manager = auth.TokenManager(client_id=client_id,
                                        client_secret=client_secret,
                                        app_url=app_url)
  
      if options.all == True:
          account_id = None
  
      else:
          account_id = accounts.get_logged_in_account_id(token_manager=token_manager,
                                                         app_url=app_url)
  
      programs_details = programs.get_programs(deployment_name,
                                               token_manager=token_manager,
                                               created_by=account_id,
                                               app_url=app_url)
  
      if not os.path.exists(options.directory):
          os.mkdir(options.directory)
  
      account_ids = set()
      for program in programs_details:
          account_ids.add(program['createdBy'])
  
      accounts_details = accounts.get_accounts(account_ids,
                                               token_manager=token_manager,
                                               app_url=app_url)
  
      account_lookup = {}
      for account in accounts_details['accounts']:
          account_lookup[account['id']] = account
  
      decision = None
      for program in programs_details:
          program_name = program['name']
          juttle_filename = '%s.juttle' % escape_filename(program_name)
  
          if options.per_user_directory:
              username = account_lookup[program['createdBy']]['username']
              userdir = os.path.join(options.directory, username)
  
              if not os.path.exists(userdir):
                  os.mkdir(userdir)
  
              juttle_filepath = os.path.join(userdir, juttle_filename)
  
          else:
              juttle_filepath = os.path.join(options.directory, juttle_filename)
  
          if os.path.exists(juttle_filepath) and decision != 'A':
              program_code = None
              with codecs.open(juttle_filepath, 'r', encoding='UTF-8') as program_file:
                  program_code = program_file.read()
  
              local_last_edited = int(os.stat(juttle_filepath).st_mtime)
              remote_last_edited = dates.iso8601_to_epoch(program['lastEdited'])
  
              if local_last_edited != remote_last_edited:
                  info('Juttle changed since last pull for "%s"' % program_name)
                  decision = console.prompt('Would you like to '
                                            '(O - Override,'
                                            ' S - Skip,'
                                            ' R - Review Changes,'
                                            ' A - override All)?')
  
                  if decision == 'R':
                      info('Following is what would change if we overrode using your copy:')
                      info('*'*80)
                      for line in difflib.ndiff(program['code'].split('\n'),
                                                program_code.split('\n')):
                          info(line)
                      info('*'*80)
                      decision = console.prompt('Would you like to '
                                                '(O - Override,'
                                                ' S - Skip)?')
  
                  if decision == 'S':
                      # jump to the next file
                      continue
  
                  elif decision == 'O':
                      pass
  
                  elif decision == 'A':
                      pass
  
                  else:
                      raise JutException('Unexpected option "%s"' % decision)
  
          info('importing program "%s" to %s' % (program['name'], juttle_filepath))
          with codecs.open(juttle_filepath, 'w', encoding='UTF-8') as program_file:
              program_file.write(program['code'])
  
          # update creation time to match the lastEdited field
          epoch = dates.iso8601_to_epoch(program['lastEdited'])
          os.utime(juttle_filepath, (epoch, epoch))