twitter/cmdline.py

   1 # encoding: utf-8
   2 """
   3 USAGE:
   4
   5  twitter [action] [options]
   6
   7
   8 ACTIONS:
   9  authorize      authorize the command-line tool to interact with Twitter
  10  follow         follow a user
  11  friends        get latest tweets from your friends (default action)
  12  help           print this help text that you are currently reading
  13  leave          stop following a user
  14  list           get list of a user's lists; give a list name to get
  15                     tweets from that list
  16  mylist         get list of your lists; give a list name to get tweets
  17                     from that list
  18  pyprompt       start a Python prompt for interacting with the twitter
  19                     object directly
  20  replies        get latest replies to you
  21  search         search twitter (Beware: octothorpe, escape it)
  22  set            set your twitter status
  23  shell          login to the twitter shell
  24  rate           get your current rate limit status (remaining API reqs)
  25
  26
  27 OPTIONS:
  28
  29  -r --refresh               run this command forever, polling every once
  30                             in a while (default: every 5 minutes)
  31  -R --refresh-rate <rate>   set the refresh rate (in seconds)
  32  -f --format <format>       specify the output format for status updates
  33  -c --config <filename>     read username and password from given config
  34                             file (default ~/.twitter)
  35  -l --length <count>        specify number of status updates shown
  36                             (default: 20, max: 200)
  37  -t --timestamp             show time before status lines
  38  -d --datestamp             show date before status lines
  39     --no-ssl                use less-secure HTTP instead of HTTPS
  40     --oauth <filename>      filename to read/store oauth credentials to
  41
  42 FORMATS for the --format option
  43
  44  default         one line per status
  45  verbose         multiple lines per status, more verbose status info
  46  json            raw json data from the api on each line
  47  urls            nothing but URLs
  48  ansi            ansi colour (rainbow mode)
  49
  50
  51 CONFIG FILES
  52
  53  The config file should be placed in your home directory and be named .twitter.
  54  It must contain a [twitter] header, and all the desired options you wish to
  55  set, like so:
  56
  57 [twitter]
  58 format: <desired_default_format_for_output>
  59 prompt: <twitter_shell_prompt e.g. '[cyan]twitter[R]> '>
  60
  61  OAuth authentication tokens are stored in the file .twitter_oauth in your
  62  home directory.
  63 """
  64
  65 from __future__ import print_function
  66
  67 try:
  68     input = __builtins__.raw_input
  69 except (AttributeError, KeyError):
  70     pass
  71
  72
  73 CONSUMER_KEY = 'uS6hO2sV6tDKIOeVjhnFnQ'
  74 CONSUMER_SECRET = 'MEYTOS97VvlHX7K1rwHPEqVpTSqZ71HtvoK4sVuYk'
  75
  76 from getopt import gnu_getopt as getopt, GetoptError
  77 from getpass import getpass
  78 import json
  79 import locale
  80 import os.path
  81 import re
  82 import string
  83 import sys
  84 import time
  85
  86 try:
  87     from ConfigParser import SafeConfigParser
  88 except ImportError:
  89     from configparser import ConfigParser as SafeConfigParser
  90 import datetime
  91 try:
  92     from urllib.parse import quote
  93 except ImportError:
  94     from urllib2 import quote
  95 try:
  96     import HTMLParser
  97 except ImportError:
  98     import html.parser as HTMLParser
  99
 100 import webbrowser
 101
 102 from .api import Twitter, TwitterError
 103 from .oauth import OAuth, write_token_file, read_token_file
 104 from .oauth_dance import oauth_dance
 105 from . import ansi
 106 from .util import smrt_input, printNicely, align_text
 107
 108 OPTIONS = {
 109     'action': 'friends',
 110     'refresh': False,
 111     'refresh_rate': 600,
 112     'format': 'default',
 113     'prompt': '[cyan]twitter[R]> ',
 114     'config_filename': os.environ.get('HOME',
 115                                       os.environ.get('USERPROFILE', ''))
 116                        + os.sep + '.twitter',
 117     'oauth_filename': os.environ.get('HOME',
 118                                      os.environ.get('USERPROFILE', ''))
 119                       + os.sep + '.twitter_oauth',
 120     'length': 20,
 121     'timestamp': False,
 122     'datestamp': False,
 123     'extra_args': [],
 124     'secure': True,
 125     'invert_split': False,
 126     'force-ansi': False,
 127 }
 128
 129 gHtmlParser = HTMLParser.HTMLParser()
 130 hashtagRe = re.compile(r'(?P<hashtag>#\S+)')
 131 profileRe = re.compile(r'(?P<profile>\@\S+)')
 132 ansiFormatter = ansi.AnsiCmd(False)
 133
 134 def parse_args(args, options):
 135     long_opts = ['help', 'format=', 'refresh', 'oauth=',
 136                  'refresh-rate=', 'config=', 'length=', 'timestamp',
 137                  'datestamp', 'no-ssl', 'force-ansi']
 138     short_opts = "e:p:f:h?rR:c:l:td"
 139     opts, extra_args = getopt(args, short_opts, long_opts)
 140     if extra_args and hasattr(extra_args[0], 'decode'):
 141         extra_args = [arg.decode(locale.getpreferredencoding())
 142                       for arg in extra_args]
 143
 144     for opt, arg in opts:
 145         if opt in ('-f', '--format'):
 146             options['format'] = arg
 147         elif opt in ('-r', '--refresh'):
 148             options['refresh'] = True
 149         elif opt in ('-R', '--refresh-rate'):
 150             options['refresh_rate'] = int(arg)
 151         elif opt in ('-l', '--length'):
 152             options["length"] = int(arg)
 153         elif opt in ('-t', '--timestamp'):
 154             options["timestamp"] = True
 155         elif opt in ('-d', '--datestamp'):
 156             options["datestamp"] = True
 157         elif opt in ('-?', '-h', '--help'):
 158             options['action'] = 'help'
 159         elif opt in ('-c', '--config'):
 160             options['config_filename'] = arg
 161         elif opt == '--no-ssl':
 162             options['secure'] = False
 163         elif opt == '--oauth':
 164             options['oauth_filename'] = arg
 165         elif opt == '--force-ansi':
 166             options['force-ansi'] = True
 167
 168     if extra_args and not ('action' in options and options['action'] == 'help'):
 169         options['action'] = extra_args[0]
 170     options['extra_args'] = extra_args[1:]
 171
 172 def get_time_string(status, options, format="%a %b %d %H:%M:%S +0000 %Y"):
 173     timestamp = options["timestamp"]
 174     datestamp = options["datestamp"]
 175     t = time.strptime(status['created_at'], format)
 176     i_hate_timezones = time.timezone
 177     if time.daylight:
 178         i_hate_timezones = time.altzone
 179     dt = datetime.datetime(*t[:-3]) - datetime.timedelta(
 180         seconds=i_hate_timezones)
 181     t = dt.timetuple()
 182     if timestamp and datestamp:
 183         return time.strftime("%Y-%m-%d %H:%M:%S ", t)
 184     elif timestamp:
 185         return time.strftime("%H:%M:%S ", t)
 186     elif datestamp:
 187         return time.strftime("%Y-%m-%d ", t)
 188     return ""
 189
 190 def reRepl(m):
 191     ansiTypes = {
 192         'clear':   ansiFormatter.cmdReset(),
 193         'hashtag': ansiFormatter.cmdBold(),
 194         'profile': ansiFormatter.cmdUnderline(),
 195         }
 196
 197     s = None
 198     try:
 199         mkey = m.lastgroup
 200         if m.group(mkey):
 201             s = '%s%s%s' % (ansiTypes[mkey], m.group(mkey), ansiTypes['clear'])
 202     except IndexError:
 203         pass
 204     return s
 205
 206 def replaceInStatus(status):
 207     txt = gHtmlParser.unescape(status)
 208     txt = re.sub(hashtagRe, reRepl, txt)
 209     txt = re.sub(profileRe, reRepl, txt)
 210     return txt
 211 def correctRTStatus(status):
 212     if 'retweeted_status' in status:
 213         return ("RT @" + status['retweeted_status']['user']['screen_name']
 214                 + " " + status['retweeted_status']['text'])
 215     else:
 216         return status['text']
 217
 218 class StatusFormatter(object):
 219     def __call__(self, status, options):
 220         return ("%s@%s %s" % (
 221             get_time_string(status, options),
 222             status['user']['screen_name'],
 223             gHtmlParser.unescape(correctRTStatus(status))))
 224
 225 class AnsiStatusFormatter(object):
 226     def __init__(self):
 227         self._colourMap = ansi.ColourMap()
 228
 229     def __call__(self, status, options):
 230         colour = self._colourMap.colourFor(status['user']['screen_name'])
 231         return ("%s%s% 16s%s %s " % (
 232             get_time_string(status, options),
 233             ansiFormatter.cmdColour(colour), status['user']['screen_name'],
 234             ansiFormatter.cmdReset(),
 235             align_text(replaceInStatus(correctRTStatus(status)))))
 236
 237 class VerboseStatusFormatter(object):
 238     def __call__(self, status, options):
 239         return ("-- %s (%s) on %s\n%s\n" % (
 240             status['user']['screen_name'],
 241             status['user']['location'],
 242             status['created_at'],
 243             gHtmlParser.unescape(correctRTStatus(status))))
 244
 245 class JSONStatusFormatter(object):
 246     def __call__(self, status, options):
 247         status['text'] = gHtmlParser.unescape(status['text'])
 248         return json.dumps(status)
 249
 250 class URLStatusFormatter(object):
 251     urlmatch = re.compile(r'https?://\S+')
 252     def __call__(self, status, options):
 253         urls = self.urlmatch.findall(correctRTStatus(status))
 254         return '\n'.join(urls) if urls else ""
 255
 256
 257 class ListsFormatter(object):
 258     def __call__(self, list):
 259         if list['description']:
 260             list_str = "%-30s (%s)" % (list['name'], list['description'])
 261         else:
 262             list_str = "%-30s" % (list['name'])
 263         return "%s\n" % list_str
 264
 265 class ListsVerboseFormatter(object):
 266     def __call__(self, list):
 267         list_str = "%-30s\n description: %s\n members: %s\n mode:%s\n" % (
 268             list['name'], list['description'],
 269             list['member_count'], list['mode'])
 270         return list_str
 271
 272 class AnsiListsFormatter(object):
 273     def __init__(self):
 274         self._colourMap = ansi.ColourMap()
 275
 276     def __call__(self, list):
 277         colour = self._colourMap.colourFor(list['name'])
 278         return ("%s%-15s%s %s" % (
 279             ansiFormatter.cmdColour(colour), list['name'],
 280             ansiFormatter.cmdReset(), list['description']))
 281
 282
 283 class AdminFormatter(object):
 284     def __call__(self, action, user):
 285         user_str = "%s (%s)" % (user['screen_name'], user['name'])
 286         if action == "follow":
 287             return "You are now following %s.\n" % (user_str)
 288         else:
 289             return "You are no longer following %s.\n" % (user_str)
 290
 291 class VerboseAdminFormatter(object):
 292     def __call__(self, action, user):
 293         return("-- %s: %s (%s): %s" % (
 294             "Following" if action == "follow" else "Leaving",
 295             user['screen_name'],
 296             user['name'],
 297             user['url']))
 298
 299 class SearchFormatter(object):
 300     def __call__(self, result, options):
 301         return("%s%s %s" % (
 302             get_time_string(result, options, "%a, %d %b %Y %H:%M:%S +0000"),
 303             result['from_user'], result['text']))
 304
 305 class VerboseSearchFormatter(SearchFormatter):
 306     pass  # Default to the regular one
 307
 308 class URLSearchFormatter(object):
 309     urlmatch = re.compile(r'https?://\S+')
 310     def __call__(self, result, options):
 311         urls = self.urlmatch.findall(result['text'])
 312         return '\n'.join(urls) if urls else ""
 313
 314 class AnsiSearchFormatter(object):
 315     def __init__(self):
 316         self._colourMap = ansi.ColourMap()
 317
 318     def __call__(self, result, options):
 319         colour = self._colourMap.colourFor(result['from_user'])
 320         return ("%s%s%s%s %s" % (
 321             get_time_string(result, options, "%a, %d %b %Y %H:%M:%S +0000"),
 322             ansiFormatter.cmdColour(colour), result['from_user'],
 323             ansiFormatter.cmdReset(), result['text']))
 324
 325 _term_encoding = None
 326 def get_term_encoding():
 327     global _term_encoding
 328     if not _term_encoding:
 329         lang = os.getenv('LANG', 'unknown.UTF-8').split('.')
 330         if lang[1:]:
 331             _term_encoding = lang[1]
 332         else:
 333             _term_encoding = 'UTF-8'
 334     return _term_encoding
 335
 336 formatters = {}
 337 status_formatters = {
 338     'default': StatusFormatter,
 339     'verbose': VerboseStatusFormatter,
 340     'json': JSONStatusFormatter,
 341     'urls': URLStatusFormatter,
 342     'ansi': AnsiStatusFormatter
 343 }
 344 formatters['status'] = status_formatters
 345
 346 admin_formatters = {
 347     'default': AdminFormatter,
 348     'verbose': VerboseAdminFormatter,
 349     'urls': AdminFormatter,
 350     'ansi': AdminFormatter
 351 }
 352 formatters['admin'] = admin_formatters
 353
 354 search_formatters = {
 355     'default': SearchFormatter,
 356     'verbose': VerboseSearchFormatter,
 357     'urls': URLSearchFormatter,
 358     'ansi': AnsiSearchFormatter
 359 }
 360 formatters['search'] = search_formatters
 361
 362 lists_formatters = {
 363     'default': ListsFormatter,
 364     'verbose': ListsVerboseFormatter,
 365     'urls': None,
 366     'ansi': AnsiListsFormatter
 367 }
 368 formatters['lists'] = lists_formatters
 369
 370 def get_formatter(action_type, options):
 371     formatters_dict = formatters.get(action_type)
 372     if not formatters_dict:
 373         raise TwitterError(
 374             "There was an error finding a class of formatters for your type (%s)"
 375             % (action_type))
 376     f = formatters_dict.get(options['format'])
 377     if not f:
 378         raise TwitterError(
 379             "Unknown formatter '%s' for status actions" % (options['format']))
 380     return f()
 381
 382 class Action(object):
 383
 384     def ask(self, subject='perform this action', careful=False):
 385         '''
 386         Requests from the user using `raw_input` if `subject` should be
 387         performed. When `careful`, the default answer is NO, otherwise YES.
 388         Returns the user answer in the form `True` or `False`.
 389         '''
 390         sample = '(y/N)'
 391         if not careful:
 392             sample = '(Y/n)'
 393
 394         prompt = 'You really want to %s %s? ' % (subject, sample)
 395         try:
 396             answer = input(prompt).lower()
 397             if careful:
 398                 return answer in ('yes', 'y')
 399             else:
 400                 return answer not in ('no', 'n')
 401         except EOFError:
 402             print(file=sys.stderr)  # Put Newline since Enter was never pressed
 403             # TODO:
 404                 #   Figure out why on OS X the raw_input keeps raising
 405                 #   EOFError and is never able to reset and get more input
 406                 #   Hint: Look at how IPython implements their console
 407             default = True
 408             if careful:
 409                 default = False
 410             return default
 411
 412     def __call__(self, twitter, options):
 413         action = actions.get(options['action'], NoSuchAction)()
 414         try:
 415             doAction = lambda: action(twitter, options)
 416             if options['refresh'] and isinstance(action, StatusAction):
 417                 while True:
 418                     doAction()
 419                     sys.stdout.flush()
 420                     time.sleep(options['refresh_rate'])
 421             else:
 422                 doAction()
 423         except KeyboardInterrupt:
 424             print('\n[Keyboard Interrupt]', file=sys.stderr)
 425             pass
 426
 427 class NoSuchActionError(Exception):
 428     pass
 429
 430 class NoSuchAction(Action):
 431     def __call__(self, twitter, options):
 432         raise NoSuchActionError("No such action: %s" % (options['action']))
 433
 434 class StatusAction(Action):
 435     def __call__(self, twitter, options):
 436         statuses = self.getStatuses(twitter, options)
 437         sf = get_formatter('status', options)
 438         for status in statuses:
 439             statusStr = sf(status, options)
 440             if statusStr.strip():
 441                 printNicely(statusStr)
 442
 443 class SearchAction(Action):
 444     def __call__(self, twitter, options):
 445         # We need to be pointing at search.twitter.com to work, and it is less
 446         # tangly to do it here than in the main()
 447         twitter.domain = "search.twitter.com"
 448         twitter.uriparts = ()
 449         # We need to bypass the TwitterCall parameter encoding, so we
 450         # don't encode the plus sign, so we have to encode it ourselves
 451         query_string = "+".join(
 452             [quote(term)
 453              for term in options['extra_args']])
 454
 455         results = twitter.search(q=query_string)['results']
 456         f = get_formatter('search', options)
 457         for result in results:
 458             resultStr = f(result, options)
 459             if resultStr.strip():
 460                 printNicely(resultStr)
 461
 462 class AdminAction(Action):
 463     def __call__(self, twitter, options):
 464         if not (options['extra_args'] and options['extra_args'][0]):
 465             raise TwitterError("You need to specify a user (screen name)")
 466         af = get_formatter('admin', options)
 467         try:
 468             user = self.getUser(twitter, options['extra_args'][0])
 469         except TwitterError as e:
 470             print("There was a problem following or leaving the specified user.")
 471             print("You may be trying to follow a user you are already following;")
 472             print("Leaving a user you are not currently following;")
 473             print("Or the user may not exist.")
 474             print("Sorry.")
 475             print()
 476             print(e)
 477         else:
 478             printNicely(af(options['action'], user))
 479
 480 class ListsAction(StatusAction):
 481     def getStatuses(self, twitter, options):
 482         if not options['extra_args']:
 483             raise TwitterError("Please provide a user to query for lists")
 484
 485         screen_name = options['extra_args'][0]
 486
 487         if not options['extra_args'][1:]:
 488             lists = twitter.lists.list(screen_name=screen_name)
 489             if not lists:
 490                 printNicely("This user has no lists.")
 491             for list in lists:
 492                 lf = get_formatter('lists', options)
 493                 printNicely(lf(list))
 494             return []
 495         else:
 496             return list(reversed(twitter.lists.statuses(
 497                 owner_screen_name=screen_name,
 498                 slug=options['extra_args'][1])))
 499
 500
 501 class MyListsAction(ListsAction):
 502     def getStatuses(self, twitter, options):
 503         screen_name = twitter.account.verify_credentials()['screen_name']
 504         options['extra_args'].insert(0, screen_name)
 505         return ListsAction.getStatuses(self, twitter, options)
 506
 507
 508 class FriendsAction(StatusAction):
 509     def getStatuses(self, twitter, options):
 510         return list(reversed(
 511             twitter.statuses.home_timeline(count=options["length"])))
 512
 513 class RepliesAction(StatusAction):
 514     def getStatuses(self, twitter, options):
 515         return list(reversed(
 516             twitter.statuses.mentions_timeline(count=options["length"])))
 517
 518 class FollowAction(AdminAction):
 519     def getUser(self, twitter, user):
 520         return twitter.friendships.create(screen_name=user)
 521
 522 class LeaveAction(AdminAction):
 523     def getUser(self, twitter, user):
 524         return twitter.friendships.destroy(screen_name=user)
 525
 526 class SetStatusAction(Action):
 527     def __call__(self, twitter, options):
 528         statusTxt = (" ".join(options['extra_args'])
 529                      if options['extra_args']
 530                      else str(input("message: ")))
 531         replies = []
 532         ptr = re.compile("@[\w_]+")
 533         while statusTxt:
 534             s = ptr.match(statusTxt)
 535             if s and s.start() == 0:
 536                 replies.append(statusTxt[s.start():s.end()])
 537                 statusTxt = statusTxt[s.end() + 1:]
 538             else:
 539                 break
 540         replies = " ".join(replies)
 541         if len(replies) >= 140:
 542             # just go back
 543             statusTxt = replies
 544             replies = ""
 545
 546         splitted = []
 547         while statusTxt:
 548             limit = 140 - len(replies)
 549             if len(statusTxt) > limit:
 550                 end = str.rfind(statusTxt, ' ', 0, limit)
 551             else:
 552                 end = limit
 553             splitted.append(" ".join((replies, statusTxt[:end])))
 554             statusTxt = statusTxt[end:]
 555
 556         if options['invert_split']:
 557             splitted.reverse()
 558         for status in splitted:
 559             twitter.statuses.update(status=status)
 560
 561 class TwitterShell(Action):
 562
 563     def render_prompt(self, prompt):
 564         '''Parses the `prompt` string and returns the rendered version'''
 565         prompt = prompt.strip("'").replace("\\'", "'")
 566         for colour in ansi.COLOURS_NAMED:
 567             if '[%s]' % (colour) in prompt:
 568                 prompt = prompt.replace(
 569                     '[%s]' % (colour), ansiFormatter.cmdColourNamed(colour))
 570         prompt = prompt.replace('[R]', ansiFormatter.cmdReset())
 571         return prompt
 572
 573     def __call__(self, twitter, options):
 574         prompt = self.render_prompt(options.get('prompt', 'twitter> '))
 575         while True:
 576             options['action'] = ""
 577             try:
 578                 args = input(prompt).split()
 579                 parse_args(args, options)
 580                 if not options['action']:
 581                     continue
 582                 elif options['action'] == 'exit':
 583                     raise SystemExit(0)
 584                 elif options['action'] == 'shell':
 585                     print('Sorry Xzibit does not work here!', file=sys.stderr)
 586                     continue
 587                 elif options['action'] == 'help':
 588                     print('''\ntwitter> `action`\n
 589                           The Shell Accepts all the command line actions along with:
 590
 591                           exit    Leave the twitter shell (^D may also be used)
 592
 593                           Full CMD Line help is appended below for your convinience.''', file=sys.stderr)
 594                 Action()(twitter, options)
 595                 options['action'] = ''
 596             except NoSuchActionError as e:
 597                 print(e, file=sys.stderr)
 598             except KeyboardInterrupt:
 599                 print('\n[Keyboard Interrupt]', file=sys.stderr)
 600             except EOFError:
 601                 print(file=sys.stderr)
 602                 leaving = self.ask(subject='Leave')
 603                 if not leaving:
 604                     print('Excellent!', file=sys.stderr)
 605                 else:
 606                     raise SystemExit(0)
 607
 608 class PythonPromptAction(Action):
 609     def __call__(self, twitter, options):
 610         try:
 611             while True:
 612                 smrt_input(globals(), locals())
 613         except EOFError:
 614             pass
 615
 616 class HelpAction(Action):
 617     def __call__(self, twitter, options):
 618         print(__doc__)
 619
 620 class DoNothingAction(Action):
 621     def __call__(self, twitter, options):
 622         pass
 623
 624 class RateLimitStatus(Action):
 625     def __call__(self, twitter, options):
 626         rate = twitter.application.rate_limit_status()
 627         print("Remaining API requests: %s / %s (hourly limit)" % (
 628             rate['remaining_hits'], rate['hourly_limit']))
 629         print("Next reset in %ss (%s)" % (
 630             int(rate['reset_time_in_seconds'] - time.time()),
 631             time.asctime(time.localtime(rate['reset_time_in_seconds']))))
 632
 633 actions = {
 634     'authorize' : DoNothingAction,
 635     'follow'    : FollowAction,
 636     'friends'   : FriendsAction,
 637     'list'      : ListsAction,
 638     'mylist'    : MyListsAction,
 639     'help'      : HelpAction,
 640     'leave'     : LeaveAction,
 641     'pyprompt'  : PythonPromptAction,
 642     'replies'   : RepliesAction,
 643     'search'    : SearchAction,
 644     'set'       : SetStatusAction,
 645     'shell'     : TwitterShell,
 646     'rate'      : RateLimitStatus,
 647 }
 648
 649 def loadConfig(filename):
 650     options = dict(OPTIONS)
 651     if os.path.exists(filename):
 652         cp = SafeConfigParser()
 653         cp.read([filename])
 654         for option in ('format', 'prompt'):
 655             if cp.has_option('twitter', option):
 656                 options[option] = cp.get('twitter', option)
 657         # process booleans
 658         for option in ('invert_split',):
 659             if cp.has_option('twitter', option):
 660                 options[option] = cp.getboolean('twitter', option)
 661     return options
 662
 663 def main(args=sys.argv[1:]):
 664     arg_options = {}
 665     try:
 666         parse_args(args, arg_options)
 667     except GetoptError as e:
 668         print("I can't do that, %s." % (e), file=sys.stderr)
 669         print(file=sys.stderr)
 670         raise SystemExit(1)
 671
 672     config_path = os.path.expanduser(
 673         arg_options.get('config_filename') or OPTIONS.get('config_filename'))
 674     config_options = loadConfig(config_path)
 675
 676     # Apply the various options in order, the most important applied last.
 677     # Defaults first, then what's read from config file, then command-line
 678     # arguments.
 679     options = dict(OPTIONS)
 680     for d in config_options, arg_options:
 681         for k, v in list(d.items()):
 682             if v: options[k] = v
 683
 684     if options['refresh'] and options['action'] not in ('friends', 'replies'):
 685         print("You can only refresh the friends or replies actions.",
 686               file=sys.stderr)
 687         print("Use 'twitter -h' for help.", file=sys.stderr)
 688         return 1
 689
 690     oauth_filename = os.path.expanduser(options['oauth_filename'])
 691
 692     if options['action'] == 'authorize' or not os.path.exists(oauth_filename):
 693         oauth_dance(
 694             "the Command-Line Tool", CONSUMER_KEY, CONSUMER_SECRET,
 695             options['oauth_filename'])
 696
 697     global ansiFormatter
 698     ansiFormatter = ansi.AnsiCmd(options["force-ansi"])
 699
 700     oauth_token, oauth_token_secret = read_token_file(oauth_filename)
 701
 702     twitter = Twitter(
 703         auth=OAuth(
 704             oauth_token, oauth_token_secret, CONSUMER_KEY, CONSUMER_SECRET),
 705         secure=options['secure'],
 706         api_version='1.1',
 707         domain='api.twitter.com')
 708
 709     try:
 710         Action()(twitter, options)
 711     except NoSuchActionError as e:
 712         print(e, file=sys.stderr)
 713         raise SystemExit(1)
 714     except TwitterError as e:
 715         print(str(e), file=sys.stderr)
 716         print("Use 'twitter -h' for help.", file=sys.stderr)
 717         raise SystemExit(1)