rainbowstream/rainbow.py

   1 import os
   2 import os.path
   3 import sys
   4 import signal
   5 import argparse
   6 import time
   7 import threading
   8 import requests
   9 import webbrowser
  10 import traceback
  11 import pkg_resources
  12 import socks
  13 import socket
  14
  15 from io import BytesIO
  16 from twitter.stream import TwitterStream, Timeout, HeartbeatTimeout, Hangup
  17 from twitter.api import *
  18 from twitter.oauth import OAuth, read_token_file
  19 from twitter.oauth_dance import oauth_dance
  20 from twitter.util import printNicely
  21
  22 from .draw import *
  23 from .colors import *
  24 from .config import *
  25 from .consumer import *
  26 from .interactive import *
  27 from .c_image import *
  28 from .py3patch import *
  29 from .emoji import *
  30 from .util import *
  31
  32 # Global values
  33 g = {}
  34
  35 # Lock for streams
  36 StreamLock = threading.Lock()
  37
  38
  39 def parse_arguments():
  40     """
  41     Parse the arguments
  42     """
  43     parser = argparse.ArgumentParser(description=__doc__ or "")
  44     parser.add_argument(
  45         '-to',
  46         '--timeout',
  47         help='Timeout for the stream (seconds).')
  48     parser.add_argument(
  49         '-tt',
  50         '--track-keywords',
  51         help='Search the stream for specific text.')
  52     parser.add_argument(
  53         '-fil',
  54         '--filter',
  55         help='Filter specific screen_name.')
  56     parser.add_argument(
  57         '-ig',
  58         '--ignore',
  59         help='Ignore specific screen_name.')
  60     parser.add_argument(
  61         '-iot',
  62         '--image-on-term',
  63         action='store_true',
  64         help='Display all image on terminal.')
  65     parser.add_argument(
  66         '-ph',
  67         '--proxy-host',
  68         help='Use HTTP/SOCKS proxy for network connections.')
  69     parser.add_argument(
  70         '-pp',
  71         '--proxy-port',
  72         default=8080,
  73         help='HTTP/SOCKS proxy port (Default: 8080).')
  74     parser.add_argument(
  75         '-pt',
  76         '--proxy-type',
  77         default='SOCKS5',
  78         help='Proxy type (HTTP, SOCKS4, SOCKS5; Default: SOCKS5).')
  79     return parser.parse_args()
  80
  81
  82 def proxy_connect(args):
  83     """
  84     Connect to specified proxy
  85     """
  86     if args.proxy_host:
  87         # Setup proxy by monkeypatching the standard lib
  88         if args.proxy_type.lower() == "socks5" or not args.proxy_type:
  89             socks.set_default_proxy(
  90                 socks.SOCKS5, args.proxy_host,
  91                 int(args.proxy_port))
  92         elif args.proxy_type.lower() == "http":
  93             socks.set_default_proxy(
  94                 socks.HTTP, args.proxy_host,
  95                 int(args.proxy_port))
  96         elif args.proxy_type.lower() == "socks4":
  97             socks.set_default_proxy(
  98                 socks.SOCKS4, args.proxy_host,
  99                 int(args.proxy_port))
 100         else:
 101             printNicely(
 102                 magenta("Sorry, wrong proxy type specified! Aborting..."))
 103             sys.exit()
 104         socket.socket = socks.socksocket
 105
 106
 107 def authen():
 108     """
 109     Authenticate with Twitter OAuth
 110     """
 111     # When using rainbow stream you must authorize.
 112     twitter_credential = os.environ.get(
 113         'HOME',
 114         os.environ.get(
 115             'USERPROFILE',
 116             '')) + os.sep + '.rainbow_oauth'
 117     if not os.path.exists(twitter_credential):
 118         oauth_dance("Rainbow Stream",
 119                     CONSUMER_KEY,
 120                     CONSUMER_SECRET,
 121                     twitter_credential)
 122     oauth_token, oauth_token_secret = read_token_file(twitter_credential)
 123     return OAuth(
 124         oauth_token,
 125         oauth_token_secret,
 126         CONSUMER_KEY,
 127         CONSUMER_SECRET)
 128
 129
 130 def build_mute_dict(dict_data=False):
 131     """
 132     Build muting list
 133     """
 134     t = Twitter(auth=authen())
 135     # Init cursor
 136     next_cursor = -1
 137     screen_name_list = []
 138     name_list = []
 139     # Cursor loop
 140     while next_cursor != 0:
 141         list = t.mutes.users.list(
 142             screen_name=g['original_name'],
 143             cursor=next_cursor,
 144             skip_status=True,
 145             include_entities=False,
 146         )
 147         screen_name_list += ['@' + u['screen_name'] for u in list['users']]
 148         name_list += [u['name'] for u in list['users']]
 149         next_cursor = list['next_cursor']
 150     # Return dict or list
 151     if dict_data:
 152         return dict(zip(screen_name_list, name_list))
 153     else:
 154         return screen_name_list
 155
 156
 157 def debug_option():
 158     """
 159     Save traceback when run in debug mode
 160     """
 161     if g['debug']:
 162         g['traceback'].append(traceback.format_exc())
 163
 164
 165 def upgrade_center():
 166     """
 167     Check latest and notify to upgrade
 168     """
 169     try:
 170         current = pkg_resources.get_distribution("rainbowstream").version
 171         url = 'https://raw.githubusercontent.com/DTVD/rainbowstream/master/setup.py'
 172         readme = requests.get(url).text
 173         latest = readme.split("version = \'")[1].split("\'")[0]
 174         if current != latest:
 175             notice = light_magenta('RainbowStream latest version is ')
 176             notice += light_green(latest)
 177             notice += light_magenta(' while your current version is ')
 178             notice += light_yellow(current) + '\n'
 179             notice += light_magenta('You should upgrade with ')
 180             notice += light_green('pip install -U rainbowstream')
 181             printNicely(notice)
 182         else:
 183             notice = light_yellow('You are running latest version (')
 184             notice += light_green(current)
 185             notice += light_yellow(')')
 186             printNicely(notice)
 187     except:
 188         pass
 189
 190
 191 def init(args):
 192     """
 193     Init function
 194     """
 195     # Handle Ctrl C
 196     ctrl_c_handler = lambda signum, frame: quit()
 197     signal.signal(signal.SIGINT, ctrl_c_handler)
 198     # Upgrade notify
 199     upgrade_center()
 200     # Get name
 201     t = Twitter(auth=authen())
 202     credential = t.account.verify_credentials()
 203     screen_name = '@' + credential['screen_name']
 204     name = credential['name']
 205     if not get_config('PREFIX'):
 206         set_config('PREFIX', screen_name)
 207     c['original_name'] = g['original_name'] = screen_name[1:]
 208     g['listname'] = g['keyword'] = ''
 209     g['PREFIX'] = u2str(emojize(format_prefix()))
 210     g['full_name'] = name
 211     g['decorated_name'] = lambda x: color_func(
 212         c['DECORATED_NAME'])('[' + x + ']: ', rl=True)
 213     # Theme init
 214     files = os.listdir(os.path.dirname(__file__) + '/colorset')
 215     themes = [f.split('.')[0] for f in files if f.split('.')[-1] == 'json']
 216     g['themes'] = themes
 217     g['pause'] = False
 218     g['message_threads'] = {}
 219     # Startup cmd
 220     g['cmd'] = ''
 221     # Debug option default = True
 222     g['debug'] = True
 223     g['traceback'] = []
 224     # Events
 225     c['events'] = []
 226     # Semaphore init
 227     c['lock'] = False
 228     # Init tweet dict and message dict
 229     c['tweet_dict'] = []
 230     c['message_dict'] = []
 231     # Image on term
 232     c['IMAGE_ON_TERM'] = args.image_on_term
 233     set_config('IMAGE_ON_TERM', str(c['IMAGE_ON_TERM']))
 234     # Check type of ONLY_LIST and IGNORE_LIST
 235     if not isinstance(c['ONLY_LIST'], list):
 236         printNicely(red('ONLY_LIST is not a valid list value.'))
 237         c['ONLY_LIST'] = []
 238     if not isinstance(c['IGNORE_LIST'], list):
 239         printNicely(red('IGNORE_LIST is not a valid list value.'))
 240         c['IGNORE_LIST'] = []
 241     # Mute dict
 242     c['IGNORE_LIST'] += build_mute_dict()
 243
 244
 245 def trend():
 246     """
 247     Trend
 248     """
 249     t = Twitter(auth=authen())
 250     # Get country and town
 251     try:
 252         country = g['stuff'].split()[0]
 253     except:
 254         country = ''
 255     try:
 256         town = g['stuff'].split()[1]
 257     except:
 258         town = ''
 259     avail = t.trends.available()
 260     # World wide
 261     if not country:
 262         trends = t.trends.place(_id=1)[0]['trends']
 263         print_trends(trends)
 264     else:
 265         for location in avail:
 266             # Search for country and Town
 267             if town:
 268                 if location['countryCode'] == country \
 269                         and location['placeType']['name'] == 'Town' \
 270                         and location['name'] == town:
 271                     trends = t.trends.place(_id=location['woeid'])[0]['trends']
 272                     print_trends(trends)
 273             # Search for country only
 274             else:
 275                 if location['countryCode'] == country \
 276                         and location['placeType']['name'] == 'Country':
 277                     trends = t.trends.place(_id=location['woeid'])[0]['trends']
 278                     print_trends(trends)
 279
 280
 281 def home():
 282     """
 283     Home
 284     """
 285     t = Twitter(auth=authen())
 286     num = c['HOME_TWEET_NUM']
 287     if g['stuff'].isdigit():
 288         num = int(g['stuff'])
 289     for tweet in reversed(t.statuses.home_timeline(count=num)):
 290         draw(t=tweet)
 291     printNicely('')
 292
 293
 294 def notification():
 295     """
 296     Show notifications
 297     """
 298     if c['events']:
 299         for e in c['events']:
 300             print_event(e)
 301         printNicely('')
 302     else:
 303         printNicely(magenta('Nothing at this time.'))
 304
 305
 306 def mentions():
 307     """
 308     Mentions timeline
 309     """
 310     t = Twitter(auth=authen())
 311     num = c['HOME_TWEET_NUM']
 312     if g['stuff'].isdigit():
 313         num = int(g['stuff'])
 314     for tweet in reversed(t.statuses.mentions_timeline(count=num)):
 315         draw(t=tweet)
 316     printNicely('')
 317
 318
 319 def whois():
 320     """
 321     Show profile of a specific user
 322     """
 323     t = Twitter(auth=authen())
 324     screen_name = g['stuff'].split()[0]
 325     if screen_name.startswith('@'):
 326         try:
 327             user = t.users.show(
 328                 screen_name=screen_name[1:],
 329                 include_entities=False)
 330             show_profile(user)
 331         except:
 332             debug_option()
 333             printNicely(red('No user.'))
 334     else:
 335         printNicely(red('A name should begin with a \'@\''))
 336
 337
 338 def view():
 339     """
 340     Friend view
 341     """
 342     t = Twitter(auth=authen())
 343     user = g['stuff'].split()[0]
 344     if user[0] == '@':
 345         try:
 346             num = int(g['stuff'].split()[1])
 347         except:
 348             num = c['HOME_TWEET_NUM']
 349         for tweet in reversed(
 350                 t.statuses.user_timeline(count=num, screen_name=user[1:])):
 351             draw(t=tweet)
 352         printNicely('')
 353     else:
 354         printNicely(red('A name should begin with a \'@\''))
 355
 356
 357 def search():
 358     """
 359     Search
 360     """
 361     t = Twitter(auth=authen())
 362     # Setup query
 363     query = g['stuff'].strip()
 364     type = c['SEARCH_TYPE']
 365     if type not in ['mixed', 'recent', 'popular']:
 366         type = 'mixed'
 367     max_record = c['SEARCH_MAX_RECORD']
 368     count = min(max_record, 100)
 369     # Perform search
 370     rel = t.search.tweets(
 371         q=query,
 372         type=type,
 373         count=count
 374     )['statuses']
 375     # Return results
 376     if rel:
 377         printNicely('Newest tweets:')
 378         for i in reversed(xrange(count)):
 379             draw(t=rel[i], keyword=query)
 380         printNicely('')
 381     else:
 382         printNicely(magenta('I\'m afraid there is no result'))
 383
 384
 385 def tweet():
 386     """
 387     Tweet
 388     """
 389     t = Twitter(auth=authen())
 390     t.statuses.update(status=g['stuff'])
 391
 392
 393 def retweet():
 394     """
 395     ReTweet
 396     """
 397     t = Twitter(auth=authen())
 398     try:
 399         id = int(g['stuff'].split()[0])
 400     except:
 401         printNicely(red('Sorry I can\'t understand.'))
 402         return
 403     tid = c['tweet_dict'][id]
 404     t.statuses.retweet(id=tid, include_entities=False, trim_user=True)
 405
 406
 407 def quote():
 408     """
 409     Quote a tweet
 410     """
 411     # Get tweet
 412     t = Twitter(auth=authen())
 413     try:
 414         id = int(g['stuff'].split()[0])
 415     except:
 416         printNicely(red('Sorry I can\'t understand.'))
 417         return
 418     tid = c['tweet_dict'][id]
 419     tweet = t.statuses.show(id=tid)
 420     # Get formater
 421     formater = format_quote(tweet)
 422     if not formater:
 423         return
 424     # Get comment
 425     prefix = light_magenta('Compose your ', rl=True) + \
 426         light_green('#comment: ', rl=True)
 427     comment = raw_input(prefix)
 428     if comment:
 429         quote = comment.join(formater.split('#comment'))
 430         t.statuses.update(status=quote)
 431     else:
 432         printNicely(light_magenta('No text added.'))
 433
 434
 435 def allretweet():
 436     """
 437     List all retweet
 438     """
 439     t = Twitter(auth=authen())
 440     # Get rainbow id
 441     try:
 442         id = int(g['stuff'].split()[0])
 443     except:
 444         printNicely(red('Sorry I can\'t understand.'))
 445         return
 446     tid = c['tweet_dict'][id]
 447     # Get display num if exist
 448     try:
 449         num = int(g['stuff'].split()[1])
 450     except:
 451         num = c['RETWEETS_SHOW_NUM']
 452     # Get result and display
 453     rt_ary = t.statuses.retweets(id=tid, count=num)
 454     if not rt_ary:
 455         printNicely(magenta('This tweet has no retweet.'))
 456         return
 457     for tweet in reversed(rt_ary):
 458         draw(t=tweet)
 459     printNicely('')
 460
 461
 462 def conversation():
 463     """
 464     Conversation view
 465     """
 466     t = Twitter(auth=authen())
 467     try:
 468         id = int(g['stuff'].split()[0])
 469     except:
 470         printNicely(red('Sorry I can\'t understand.'))
 471         return
 472     tid = c['tweet_dict'][id]
 473     tweet = t.statuses.show(id=tid)
 474     limit = c['CONVERSATION_MAX']
 475     thread_ref = []
 476     thread_ref.append(tweet)
 477     prev_tid = tweet['in_reply_to_status_id']
 478     while prev_tid and limit:
 479         limit -= 1
 480         tweet = t.statuses.show(id=prev_tid)
 481         prev_tid = tweet['in_reply_to_status_id']
 482         thread_ref.append(tweet)
 483
 484     for tweet in reversed(thread_ref):
 485         draw(t=tweet)
 486     printNicely('')
 487
 488
 489 def reply():
 490     """
 491     Reply
 492     """
 493     t = Twitter(auth=authen())
 494     try:
 495         id = int(g['stuff'].split()[0])
 496     except:
 497         printNicely(red('Sorry I can\'t understand.'))
 498         return
 499     tid = c['tweet_dict'][id]
 500     user = t.statuses.show(id=tid)['user']['screen_name']
 501     status = ' '.join(g['stuff'].split()[1:])
 502     status = '@' + user + ' ' + str2u(status)
 503     t.statuses.update(status=status, in_reply_to_status_id=tid)
 504
 505
 506 def favorite():
 507     """
 508     Favorite
 509     """
 510     t = Twitter(auth=authen())
 511     try:
 512         id = int(g['stuff'].split()[0])
 513     except:
 514         printNicely(red('Sorry I can\'t understand.'))
 515         return
 516     tid = c['tweet_dict'][id]
 517     t.favorites.create(_id=tid, include_entities=False)
 518     printNicely(green('Favorited.'))
 519     draw(t.statuses.show(id=tid))
 520     printNicely('')
 521
 522
 523 def unfavorite():
 524     """
 525     Unfavorite
 526     """
 527     t = Twitter(auth=authen())
 528     try:
 529         id = int(g['stuff'].split()[0])
 530     except:
 531         printNicely(red('Sorry I can\'t understand.'))
 532         return
 533     tid = c['tweet_dict'][id]
 534     t.favorites.destroy(_id=tid)
 535     printNicely(green('Okay it\'s unfavorited.'))
 536     draw(t.statuses.show(id=tid))
 537     printNicely('')
 538
 539
 540 def share():
 541     """
 542     Copy url of a tweet to clipboard
 543     """
 544     t = Twitter(auth=authen())
 545     try:
 546         id = int(g['stuff'].split()[0])
 547         tid = c['tweet_dict'][id]
 548     except:
 549         printNicely(red('Tweet id is not valid.'))
 550         return
 551     tweet = t.statuses.show(id=tid)
 552     url = 'https://twitter.com/' + \
 553         tweet['user']['screen_name'] + '/status/' + str(tid)
 554     import platform
 555     if platform.system().lower() == 'darwin':
 556         os.system("echo '%s' | pbcopy" % url)
 557         printNicely(green('Copied tweet\'s url to clipboard.'))
 558     else:
 559         printNicely('Direct link: ' + yellow(url))
 560
 561
 562 def delete():
 563     """
 564     Delete
 565     """
 566     t = Twitter(auth=authen())
 567     try:
 568         id = int(g['stuff'].split()[0])
 569     except:
 570         printNicely(red('Sorry I can\'t understand.'))
 571         return
 572     tid = c['tweet_dict'][id]
 573     t.statuses.destroy(id=tid)
 574     printNicely(green('Okay it\'s gone.'))
 575
 576
 577 def show():
 578     """
 579     Show image
 580     """
 581     t = Twitter(auth=authen())
 582     try:
 583         target = g['stuff'].split()[0]
 584         if target != 'image':
 585             return
 586         id = int(g['stuff'].split()[1])
 587         tid = c['tweet_dict'][id]
 588         tweet = t.statuses.show(id=tid)
 589         media = tweet['entities']['media']
 590         for m in media:
 591             res = requests.get(m['media_url'])
 592             img = Image.open(BytesIO(res.content))
 593             img.show()
 594     except:
 595         debug_option()
 596         printNicely(red('Sorry I can\'t show this image.'))
 597
 598
 599 def urlopen():
 600     """
 601     Open url
 602     """
 603     t = Twitter(auth=authen())
 604     try:
 605         if not g['stuff'].isdigit():
 606             return
 607         tid = c['tweet_dict'][int(g['stuff'])]
 608         tweet = t.statuses.show(id=tid)
 609         link_prefix = ('http://', 'https://')
 610         link_ary = [u for u in tweet['text'].split()
 611                     if u.startswith(link_prefix)]
 612         if not link_ary:
 613             printNicely(light_magenta('No url here @.@!'))
 614             return
 615         for link in link_ary:
 616             webbrowser.open(link)
 617     except:
 618         debug_option()
 619         printNicely(red('Sorry I can\'t open url in this tweet.'))
 620
 621
 622 def inbox():
 623     """
 624     Inbox threads
 625     """
 626     t = Twitter(auth=authen())
 627     num = c['MESSAGES_DISPLAY']
 628     if g['stuff'].isdigit():
 629         num = g['stuff']
 630     # Get inbox messages
 631     cur_page = 1
 632     inbox = []
 633     while num > 20:
 634         inbox = inbox + t.direct_messages(
 635             count=20,
 636             page=cur_page,
 637             include_entities=False,
 638             skip_status=False
 639         )
 640         num -= 20
 641         cur_page += 1
 642     inbox = inbox + t.direct_messages(
 643         count=num,
 644         page=cur_page,
 645         include_entities=False,
 646         skip_status=False
 647     )
 648     # Get sent messages
 649     num = c['MESSAGES_DISPLAY']
 650     if g['stuff'].isdigit():
 651         num = g['stuff']
 652     cur_page = 1
 653     sent = []
 654     while num > 20:
 655         sent = sent + t.direct_messages.sent(
 656             count=20,
 657             page=cur_page,
 658             include_entities=False,
 659             skip_status=False
 660         )
 661         num -= 20
 662         cur_page += 1
 663     sent = sent + t.direct_messages.sent(
 664         count=num,
 665         page=cur_page,
 666         include_entities=False,
 667         skip_status=False
 668     )
 669
 670     d = {}
 671     uniq_inbox = list(set(
 672         [(m['sender_screen_name'], m['sender']['name']) for m in inbox]
 673     ))
 674     uniq_sent = list(set(
 675         [(m['recipient_screen_name'], m['recipient']['name']) for m in sent]
 676     ))
 677     for partner in uniq_inbox:
 678         inbox_ary = [m for m in inbox if m['sender_screen_name'] == partner[0]]
 679         sent_ary = [
 680             m for m in sent if m['recipient_screen_name'] == partner[0]]
 681         d[partner] = inbox_ary + sent_ary
 682     for partner in uniq_sent:
 683         if partner not in d:
 684             d[partner] = [
 685                 m for m in sent if m['recipient_screen_name'] == partner[0]]
 686     g['message_threads'] = print_threads(d)
 687
 688
 689 def thread():
 690     """
 691     View a thread of message
 692     """
 693     try:
 694         thread_id = int(g['stuff'])
 695         print_thread(
 696             g['message_threads'][thread_id],
 697             g['original_name'],
 698             g['full_name'])
 699     except Exception:
 700         debug_option()
 701         printNicely(red('No such thread.'))
 702
 703
 704 def message():
 705     """
 706     Send a direct message
 707     """
 708     t = Twitter(auth=authen())
 709     try:
 710         user = g['stuff'].split()[0]
 711         if user[0].startswith('@'):
 712             content = ' '.join(g['stuff'].split()[1:])
 713             t.direct_messages.new(
 714                 screen_name=user[1:],
 715                 text=content
 716             )
 717             printNicely(green('Message sent.'))
 718         else:
 719             printNicely(red('A name should begin with a \'@\''))
 720     except:
 721         debug_option()
 722         printNicely(red('Sorry I can\'t understand.'))
 723
 724
 725 def trash():
 726     """
 727     Remove message
 728     """
 729     t = Twitter(auth=authen())
 730     try:
 731         id = int(g['stuff'].split()[0])
 732     except:
 733         printNicely(red('Sorry I can\'t understand.'))
 734     mid = c['message_dict'][id]
 735     t.direct_messages.destroy(id=mid)
 736     printNicely(green('Message deleted.'))
 737
 738
 739 def ls():
 740     """
 741     List friends for followers
 742     """
 743     t = Twitter(auth=authen())
 744     # Get name
 745     try:
 746         name = g['stuff'].split()[1]
 747         if name.startswith('@'):
 748             name = name[1:]
 749         else:
 750             printNicely(red('A name should begin with a \'@\''))
 751             raise Exception('Invalid name')
 752     except:
 753         name = g['original_name']
 754     # Get list followers or friends
 755     try:
 756         target = g['stuff'].split()[0]
 757     except:
 758         printNicely(red('Omg some syntax is wrong.'))
 759     # Init cursor
 760     d = {'fl': 'followers', 'fr': 'friends'}
 761     next_cursor = -1
 762     rel = {}
 763     # Cursor loop
 764     while next_cursor != 0:
 765         list = getattr(t, d[target]).list(
 766             screen_name=name,
 767             cursor=next_cursor,
 768             skip_status=True,
 769             include_entities=False,
 770         )
 771         for u in list['users']:
 772             rel[u['name']] = '@' + u['screen_name']
 773         next_cursor = list['next_cursor']
 774     # Print out result
 775     printNicely('All: ' + str(len(rel)) + ' ' + d[target] + '.')
 776     for name in rel:
 777         user = '  ' + cycle_color(name)
 778         user += color_func(c['TWEET']['nick'])(' ' + rel[name] + ' ')
 779         printNicely(user)
 780
 781
 782 def follow():
 783     """
 784     Follow a user
 785     """
 786     t = Twitter(auth=authen())
 787     screen_name = g['stuff'].split()[0]
 788     if screen_name.startswith('@'):
 789         t.friendships.create(screen_name=screen_name[1:], follow=True)
 790         printNicely(green('You are following ' + screen_name + ' now!'))
 791     else:
 792         printNicely(red('A name should begin with a \'@\''))
 793
 794
 795 def unfollow():
 796     """
 797     Unfollow a user
 798     """
 799     t = Twitter(auth=authen())
 800     screen_name = g['stuff'].split()[0]
 801     if screen_name.startswith('@'):
 802         t.friendships.destroy(
 803             screen_name=screen_name[1:],
 804             include_entities=False)
 805         printNicely(green('Unfollow ' + screen_name + ' success!'))
 806     else:
 807         printNicely(red('A name should begin with a \'@\''))
 808
 809
 810 def mute():
 811     """
 812     Mute a user
 813     """
 814     t = Twitter(auth=authen())
 815     try:
 816         screen_name = g['stuff'].split()[0]
 817     except:
 818         printNicely(red('A name should be specified. '))
 819         return
 820     if screen_name.startswith('@'):
 821         try:
 822             rel = t.mutes.users.create(screen_name=screen_name[1:])
 823             if isinstance(rel, dict):
 824                 printNicely(green(screen_name + ' is muted.'))
 825                 c['IGNORE_LIST'] += [unc(screen_name)]
 826                 c['IGNORE_LIST'] = list(set(c['IGNORE_LIST']))
 827             else:
 828                 printNicely(red(rel))
 829         except:
 830             debug_option()
 831             printNicely(red('Something is wrong, can not mute now :('))
 832     else:
 833         printNicely(red('A name should begin with a \'@\''))
 834
 835
 836 def unmute():
 837     """
 838     Unmute a user
 839     """
 840     t = Twitter(auth=authen())
 841     try:
 842         screen_name = g['stuff'].split()[0]
 843     except:
 844         printNicely(red('A name should be specified. '))
 845         return
 846     if screen_name.startswith('@'):
 847         try:
 848             rel = t.mutes.users.destroy(screen_name=screen_name[1:])
 849             if isinstance(rel, dict):
 850                 printNicely(green(screen_name + ' is unmuted.'))
 851                 c['IGNORE_LIST'].remove(screen_name)
 852             else:
 853                 printNicely(red(rel))
 854         except:
 855             printNicely(red('Maybe you are not muting this person ?'))
 856     else:
 857         printNicely(red('A name should begin with a \'@\''))
 858
 859
 860 def muting():
 861     """
 862     List muting user
 863     """
 864     # Get dict of muting users
 865     md = build_mute_dict(dict_data=True)
 866     printNicely('All: ' + str(len(md)) + ' people.')
 867     for name in md:
 868         user = '  ' + cycle_color(md[name])
 869         user += color_func(c['TWEET']['nick'])(' ' + name + ' ')
 870         printNicely(user)
 871     # Update from Twitter
 872     c['IGNORE_LIST'] = [n for n in md]
 873
 874
 875 def block():
 876     """
 877     Block a user
 878     """
 879     t = Twitter(auth=authen())
 880     screen_name = g['stuff'].split()[0]
 881     if screen_name.startswith('@'):
 882         t.blocks.create(
 883             screen_name=screen_name[1:],
 884             include_entities=False,
 885             skip_status=True)
 886         printNicely(green('You blocked ' + screen_name + '.'))
 887     else:
 888         printNicely(red('A name should begin with a \'@\''))
 889
 890
 891 def unblock():
 892     """
 893     Unblock a user
 894     """
 895     t = Twitter(auth=authen())
 896     screen_name = g['stuff'].split()[0]
 897     if screen_name.startswith('@'):
 898         t.blocks.destroy(
 899             screen_name=screen_name[1:],
 900             include_entities=False,
 901             skip_status=True)
 902         printNicely(green('Unblock ' + screen_name + ' success!'))
 903     else:
 904         printNicely(red('A name should begin with a \'@\''))
 905
 906
 907 def report():
 908     """
 909     Report a user as a spam account
 910     """
 911     t = Twitter(auth=authen())
 912     screen_name = g['stuff'].split()[0]
 913     if screen_name.startswith('@'):
 914         t.users.report_spam(
 915             screen_name=screen_name[1:])
 916         printNicely(green('You reported ' + screen_name + '.'))
 917     else:
 918         printNicely(red('Sorry I can\'t understand.'))
 919
 920
 921 def get_slug():
 922     """
 923     Get slug
 924     """
 925     # Get list name
 926     list_name = raw_input(
 927         light_magenta('Give me the list\'s name ("@owner/list_name"): ', rl=True))
 928     # Get list name and owner
 929     try:
 930         owner, slug = list_name.split('/')
 931         if slug.startswith('@'):
 932             slug = slug[1:]
 933         return owner, slug
 934     except:
 935         printNicely(
 936             light_magenta('List name should follow "@owner/list_name" format.'))
 937         raise Exception('Wrong list name')
 938
 939
 940 def show_lists(t):
 941     """
 942     List list
 943     """
 944     rel = t.lists.list(screen_name=g['original_name'])
 945     if rel:
 946         print_list(rel)
 947     else:
 948         printNicely(light_magenta('You belong to no lists :)'))
 949
 950
 951 def list_home(t):
 952     """
 953     List home
 954     """
 955     owner, slug = get_slug()
 956     res = t.lists.statuses(
 957         slug=slug,
 958         owner_screen_name=owner,
 959         count=c['LIST_MAX'],
 960         include_entities=False)
 961     for tweet in reversed(res):
 962         draw(t=tweet)
 963     printNicely('')
 964
 965
 966 def list_members(t):
 967     """
 968     List members
 969     """
 970     owner, slug = get_slug()
 971     # Get members
 972     rel = {}
 973     next_cursor = -1
 974     while next_cursor != 0:
 975         m = t.lists.members(
 976             slug=slug,
 977             owner_screen_name=owner,
 978             cursor=next_cursor,
 979             include_entities=False)
 980         for u in m['users']:
 981             rel[u['name']] = '@' + u['screen_name']
 982         next_cursor = m['next_cursor']
 983     printNicely('All: ' + str(len(rel)) + ' members.')
 984     for name in rel:
 985         user = '  ' + cycle_color(name)
 986         user += color_func(c['TWEET']['nick'])(' ' + rel[name] + ' ')
 987         printNicely(user)
 988
 989
 990 def list_subscribers(t):
 991     """
 992     List subscribers
 993     """
 994     owner, slug = get_slug()
 995     # Get subscribers
 996     rel = {}
 997     next_cursor = -1
 998     while next_cursor != 0:
 999         m = t.lists.subscribers(
1000             slug=slug,
1001             owner_screen_name=owner,
1002             cursor=next_cursor,
1003             include_entities=False)
1004         for u in m['users']:
1005             rel[u['name']] = '@' + u['screen_name']
1006         next_cursor = m['next_cursor']
1007     printNicely('All: ' + str(len(rel)) + ' subscribers.')
1008     for name in rel:
1009         user = '  ' + cycle_color(name)
1010         user += color_func(c['TWEET']['nick'])(' ' + rel[name] + ' ')
1011         printNicely(user)
1012
1013
1014 def list_add(t):
1015     """
1016     Add specific user to a list
1017     """
1018     owner, slug = get_slug()
1019     # Add
1020     user_name = raw_input(
1021         light_magenta(
1022             'Give me name of the newbie: ',
1023             rl=True))
1024     if user_name.startswith('@'):
1025         user_name = user_name[1:]
1026     try:
1027         t.lists.members.create(
1028             slug=slug,
1029             owner_screen_name=owner,
1030             screen_name=user_name)
1031         printNicely(green('Added.'))
1032     except:
1033         debug_option()
1034         printNicely(light_magenta('I\'m sorry we can not add him/her.'))
1035
1036
1037 def list_remove(t):
1038     """
1039     Remove specific user from a list
1040     """
1041     owner, slug = get_slug()
1042     # Remove
1043     user_name = raw_input(
1044         light_magenta(
1045             'Give me name of the unlucky one: ',
1046             rl=True))
1047     if user_name.startswith('@'):
1048         user_name = user_name[1:]
1049     try:
1050         t.lists.members.destroy(
1051             slug=slug,
1052             owner_screen_name=owner,
1053             screen_name=user_name)
1054         printNicely(green('Gone.'))
1055     except:
1056         debug_option()
1057         printNicely(light_magenta('I\'m sorry we can not remove him/her.'))
1058
1059
1060 def list_subscribe(t):
1061     """
1062     Subscribe to a list
1063     """
1064     owner, slug = get_slug()
1065     # Subscribe
1066     try:
1067         t.lists.subscribers.create(
1068             slug=slug,
1069             owner_screen_name=owner)
1070         printNicely(green('Done.'))
1071     except:
1072         debug_option()
1073         printNicely(
1074             light_magenta('I\'m sorry you can not subscribe to this list.'))
1075
1076
1077 def list_unsubscribe(t):
1078     """
1079     Unsubscribe a list
1080     """
1081     owner, slug = get_slug()
1082     # Subscribe
1083     try:
1084         t.lists.subscribers.destroy(
1085             slug=slug,
1086             owner_screen_name=owner)
1087         printNicely(green('Done.'))
1088     except:
1089         debug_option()
1090         printNicely(
1091             light_magenta('I\'m sorry you can not unsubscribe to this list.'))
1092
1093
1094 def list_own(t):
1095     """
1096     List own
1097     """
1098     rel = []
1099     next_cursor = -1
1100     while next_cursor != 0:
1101         res = t.lists.ownerships(
1102             screen_name=g['original_name'],
1103             cursor=next_cursor)
1104         rel += res['lists']
1105         next_cursor = res['next_cursor']
1106     if rel:
1107         print_list(rel)
1108     else:
1109         printNicely(light_magenta('You own no lists :)'))
1110
1111
1112 def list_new(t):
1113     """
1114     Create a new list
1115     """
1116     name = raw_input(light_magenta('New list\'s name: ', rl=True))
1117     mode = raw_input(
1118         light_magenta(
1119             'New list\'s mode (public/private): ',
1120             rl=True))
1121     description = raw_input(
1122         light_magenta(
1123             'New list\'s description: ',
1124             rl=True))
1125     try:
1126         t.lists.create(
1127             name=name,
1128             mode=mode,
1129             description=description)
1130         printNicely(green(name + ' list is created.'))
1131     except:
1132         debug_option()
1133         printNicely(red('Oops something is wrong with Twitter :('))
1134
1135
1136 def list_update(t):
1137     """
1138     Update a list
1139     """
1140     slug = raw_input(
1141         light_magenta(
1142             'Your list that you want to update: ',
1143             rl=True))
1144     name = raw_input(
1145         light_magenta(
1146             'Update name (leave blank to unchange): ',
1147             rl=True))
1148     mode = raw_input(light_magenta('Update mode (public/private): ', rl=True))
1149     description = raw_input(light_magenta('Update description: ', rl=True))
1150     try:
1151         if name:
1152             t.lists.update(
1153                 slug='-'.join(slug.split()),
1154                 owner_screen_name=g['original_name'],
1155                 name=name,
1156                 mode=mode,
1157                 description=description)
1158         else:
1159             t.lists.update(
1160                 slug=slug,
1161                 owner_screen_name=g['original_name'],
1162                 mode=mode,
1163                 description=description)
1164         printNicely(green(slug + ' list is updated.'))
1165     except:
1166         debug_option()
1167         printNicely(red('Oops something is wrong with Twitter :('))
1168
1169
1170 def list_delete(t):
1171     """
1172     Delete a list
1173     """
1174     slug = raw_input(
1175         light_magenta(
1176             'Your list that you want to delete: ',
1177             rl=True))
1178     try:
1179         t.lists.destroy(
1180             slug='-'.join(slug.split()),
1181             owner_screen_name=g['original_name'])
1182         printNicely(green(slug + ' list is deleted.'))
1183     except:
1184         debug_option()
1185         printNicely(red('Oops something is wrong with Twitter :('))
1186
1187
1188 def twitterlist():
1189     """
1190     Twitter's list
1191     """
1192     t = Twitter(auth=authen())
1193     # List all lists or base on action
1194     try:
1195         g['list_action'] = g['stuff'].split()[0]
1196     except:
1197         show_lists(t)
1198         return
1199     # Sub-function
1200     action_ary = {
1201         'home': list_home,
1202         'all_mem': list_members,
1203         'all_sub': list_subscribers,
1204         'add': list_add,
1205         'rm': list_remove,
1206         'sub': list_subscribe,
1207         'unsub': list_unsubscribe,
1208         'own': list_own,
1209         'new': list_new,
1210         'update': list_update,
1211         'del': list_delete,
1212     }
1213     try:
1214         return action_ary[g['list_action']](t)
1215     except:
1216         printNicely(red('Please try again.'))
1217
1218
1219 def switch():
1220     """
1221     Switch stream
1222     """
1223     try:
1224         target = g['stuff'].split()[0]
1225         # Filter and ignore
1226         args = parse_arguments()
1227         try:
1228             if g['stuff'].split()[-1] == '-f':
1229                 guide = 'To ignore an option, just hit Enter key.'
1230                 printNicely(light_magenta(guide))
1231                 only = raw_input('Only nicks [Ex: @xxx,@yy]: ')
1232                 ignore = raw_input('Ignore nicks [Ex: @xxx,@yy]: ')
1233                 args.filter = filter(None, only.split(','))
1234                 args.ignore = filter(None, ignore.split(','))
1235         except:
1236             printNicely(red('Sorry, wrong format.'))
1237             return
1238         # Public stream
1239         if target == 'public':
1240             keyword = g['stuff'].split()[1]
1241             if keyword[0] == '#':
1242                 keyword = keyword[1:]
1243             # Kill old thread
1244             g['stream_stop'] = True
1245             args.track_keywords = keyword
1246             # Set the variable to tracked keyword
1247             # and reset the listname
1248             g['keyword'] = keyword
1249             g['listname'] = ''
1250             # Reset prefix
1251             g['PREFIX'] = u2str(emojize(format_prefix(keyword = g['keyword'])))
1252             # Start new thread
1253             th = threading.Thread(
1254                 target=stream,
1255                 args=(
1256                     c['PUBLIC_DOMAIN'],
1257                     args))
1258             th.daemon = True
1259             th.start()
1260         # Personal stream
1261         elif target == 'mine':
1262             # Kill old thread
1263             g['stream_stop'] = True
1264             # Reset the tracked keyword and listname
1265             g['keyword'] = g['listname'] = ''
1266             # Reset prefix
1267             g['PREFIX'] = u2str(emojize(format_prefix()))
1268             # Start new thread
1269             th = threading.Thread(
1270                 target=stream,
1271                 args=(
1272                     c['USER_DOMAIN'],
1273                     args,
1274                     g['original_name']))
1275             th.daemon = True
1276             th.start()
1277         # Stream base on list
1278         elif target == 'list':
1279             owner, slug = get_slug()
1280             # Force python 2 not redraw readline buffer
1281             listname = '/'.join([owner, slug])
1282             # Set the listname variable
1283             # and reset tracked keyword
1284             g['listname'] = listname
1285             g['keyword'] = ''
1286             g['PREFIX'] = g['cmd'] = u2str(emojize(format_prefix(listname = g['listname'])))
1287             printNicely(light_yellow('getting list members ...'))
1288             # Get members
1289             t = Twitter(auth=authen())
1290             members = []
1291             next_cursor = -1
1292             while next_cursor != 0:
1293                 m = t.lists.members(
1294                     slug=slug,
1295                     owner_screen_name=owner,
1296                     cursor=next_cursor,
1297                     include_entities=False)
1298                 for u in m['users']:
1299                     members.append('@' + u['screen_name'])
1300                 next_cursor = m['next_cursor']
1301             printNicely(light_yellow('... done.'))
1302             # Build thread filter array
1303             args.filter = members
1304             # Kill old thread
1305             g['stream_stop'] = True
1306             # Start new thread
1307             th = threading.Thread(
1308                 target=stream,
1309                 args=(
1310                     c['USER_DOMAIN'],
1311                     args,
1312                     slug))
1313             th.daemon = True
1314             th.start()
1315         printNicely('')
1316         if args.filter:
1317             printNicely(cyan('Include: ' + str(len(args.filter)) + ' people.'))
1318         if args.ignore:
1319             printNicely(red('Ignore: ' + str(len(args.ignore)) + ' people.'))
1320         printNicely('')
1321     except:
1322         debug_option()
1323         printNicely(red('Sorry I can\'t understand.'))
1324
1325
1326 def cal():
1327     """
1328     Unix's command `cal`
1329     """
1330     # Format
1331     rel = os.popen('cal').read().split('\n')
1332     month = rel.pop(0)
1333     date = rel.pop(0)
1334     show_calendar(month, date, rel)
1335
1336
1337 def theme():
1338     """
1339     List and change theme
1340     """
1341     if not g['stuff']:
1342         # List themes
1343         for theme in g['themes']:
1344             line = light_magenta(theme)
1345             if c['THEME'] == theme:
1346                 line = ' ' * 2 + light_yellow('* ') + line
1347             else:
1348                 line = ' ' * 4 + line
1349             printNicely(line)
1350     else:
1351         # Change theme
1352         try:
1353             # Load new theme
1354             c['THEME'] = reload_theme(g['stuff'], c['THEME'])
1355             # Redefine decorated_name
1356             g['decorated_name'] = lambda x: color_func(
1357                 c['DECORATED_NAME'])(
1358                 '[' + x + ']: ')
1359             printNicely(green('Theme changed.'))
1360         except:
1361             printNicely(red('No such theme exists.'))
1362
1363
1364 def config():
1365     """
1366     Browse and change config
1367     """
1368     all_config = get_all_config()
1369     g['stuff'] = g['stuff'].strip()
1370     # List all config
1371     if not g['stuff']:
1372         for k in all_config:
1373             line = ' ' * 2 + \
1374                 green(k) + ': ' + light_yellow(str(all_config[k]))
1375             printNicely(line)
1376         guide = 'Detailed explanation can be found at ' + \
1377             color_func(c['TWEET']['link'])(
1378                 'http://rainbowstream.readthedocs.org/en/latest/#config-explanation')
1379         printNicely(guide)
1380     # Print specific config
1381     elif len(g['stuff'].split()) == 1:
1382         if g['stuff'] in all_config:
1383             k = g['stuff']
1384             line = ' ' * 2 + \
1385                 green(k) + ': ' + light_yellow(str(all_config[k]))
1386             printNicely(line)
1387         else:
1388             printNicely(red('No such config key.'))
1389     # Print specific config's default value
1390     elif len(g['stuff'].split()) == 2 and g['stuff'].split()[-1] == 'default':
1391         key = g['stuff'].split()[0]
1392         try:
1393             value = get_default_config(key)
1394             line = ' ' * 2 + green(key) + ': ' + light_magenta(value)
1395             printNicely(line)
1396         except:
1397             debug_option()
1398             printNicely(red('Just can not get the default.'))
1399     # Delete specific config key in config file
1400     elif len(g['stuff'].split()) == 2 and g['stuff'].split()[-1] == 'drop':
1401         key = g['stuff'].split()[0]
1402         try:
1403             delete_config(key)
1404             printNicely(green('Config key is dropped.'))
1405         except:
1406             debug_option()
1407             printNicely(red('Just can not drop the key.'))
1408     # Set specific config
1409     elif len(g['stuff'].split()) == 3 and g['stuff'].split()[1] == '=':
1410         key = g['stuff'].split()[0]
1411         value = g['stuff'].split()[-1]
1412         if key == 'THEME' and not validate_theme(value):
1413             printNicely(red('Invalid theme\'s value.'))
1414             return
1415         try:
1416             set_config(key, value)
1417             # Keys that needs to be apply immediately
1418             if key == 'THEME':
1419                 c['THEME'] = reload_theme(value, c['THEME'])
1420                 g['decorated_name'] = lambda x: color_func(
1421                     c['DECORATED_NAME'])('[' + x + ']: ')
1422             elif key == 'PREFIX':
1423                 g['PREFIX'] = u2str(emojize(format_prefix(listname = g['listname'], keyword = g['keyword'])))
1424             reload_config()
1425             printNicely(green('Updated successfully.'))
1426         except:
1427             debug_option()
1428             printNicely(red('Just can not set the key.'))
1429     else:
1430         printNicely(light_magenta('Sorry I can\'s understand.'))
1431
1432
1433 def help_discover():
1434     """
1435     Discover the world
1436     """
1437     s = ' ' * 2
1438     # Discover the world
1439     usage = '\n'
1440     usage += s + grey(u'\u266A' + ' Discover the world \n')
1441     usage += s * 2 + light_green('trend') + ' will show global trending topics. ' + \
1442         'You can try ' + light_green('trend US') + ' or ' + \
1443         light_green('trend JP Tokyo') + '.\n'
1444     usage += s * 2 + light_green('home') + ' will show your timeline. ' + \
1445         light_green('home 7') + ' will show 7 tweets.\n'
1446     usage += s * 2 + \
1447         light_green('notification') + ' will show your recent notification.\n'
1448     usage += s * 2 + light_green('mentions') + ' will show mentions timeline. ' + \
1449         light_green('mentions 7') + ' will show 7 mention tweets.\n'
1450     usage += s * 2 + light_green('whois @mdo') + ' will show profile  of ' + \
1451         magenta('@mdo') + '.\n'
1452     usage += s * 2 + light_green('view @mdo') + \
1453         ' will show ' + magenta('@mdo') + '\'s home.\n'
1454     usage += s * 2 + light_green('s AKB48') + ' will search for "' + \
1455         light_yellow('AKB48') + '" and return 5 newest tweet. ' + \
1456         'Search can be performed with or without hashtag.\n'
1457     printNicely(usage)
1458
1459
1460 def help_tweets():
1461     """
1462     Tweets
1463     """
1464     s = ' ' * 2
1465     # Tweet
1466     usage = '\n'
1467     usage += s + grey(u'\u266A' + ' Tweets \n')
1468     usage += s * 2 + light_green('t oops ') + \
1469         'will tweet "' + light_yellow('oops') + '" immediately.\n'
1470     usage += s * 2 + \
1471         light_green('rt 12 ') + ' will retweet to tweet with ' + \
1472         light_yellow('[id=12]') + '.\n'
1473     usage += s * 2 + \
1474         light_green('quote 12 ') + ' will quote the tweet with ' + \
1475         light_yellow('[id=12]') + '. If no extra text is added, ' + \
1476         'the quote will be canceled.\n'
1477     usage += s * 2 + \
1478         light_green('allrt 12 20 ') + ' will list 20 newest retweet of the tweet with ' + \
1479         light_yellow('[id=12]') + '.\n'
1480     usage += s * 2 + light_green('conversation 12') + ' will show the chain of ' + \
1481         'replies prior to the tweet with ' + light_yellow('[id=12]') + '.\n'
1482     usage += s * 2 + light_green('rep 12 oops') + ' will reply "' + \
1483         light_yellow('oops') + '" to tweet with ' + \
1484         light_yellow('[id=12]') + '.\n'
1485     usage += s * 2 + \
1486         light_green('fav 12 ') + ' will favorite the tweet with ' + \
1487         light_yellow('[id=12]') + '.\n'
1488     usage += s * 2 + \
1489         light_green('ufav 12 ') + ' will unfavorite tweet with ' + \
1490         light_yellow('[id=12]') + '.\n'
1491     usage += s * 2 + \
1492         light_green('share 12 ') + ' will get the direct link of the tweet with ' + \
1493         light_yellow('[id=12]') + '.\n'
1494     usage += s * 2 + \
1495         light_green('del 12 ') + ' will delete tweet with ' + \
1496         light_yellow('[id=12]') + '.\n'
1497     usage += s * 2 + light_green('show image 12') + ' will show image in tweet with ' + \
1498         light_yellow('[id=12]') + ' in your OS\'s image viewer.\n'
1499     usage += s * 2 + light_green('open 12') + ' will open url in tweet with ' + \
1500         light_yellow('[id=12]') + ' in your OS\'s default browser.\n'
1501     printNicely(usage)
1502
1503
1504 def help_messages():
1505     """
1506     Messages
1507     """
1508     s = ' ' * 2
1509     # Direct message
1510     usage = '\n'
1511     usage += s + grey(u'\u266A' + ' Direct messages \n')
1512     usage += s * 2 + light_green('inbox') + ' will show inbox messages. ' + \
1513         light_green('inbox 7') + ' will show newest 7 messages.\n'
1514     usage += s * 2 + light_green('thread 2') + ' will show full thread with ' + \
1515         light_yellow('[thread_id=2]') + '.\n'
1516     usage += s * 2 + light_green('mes @dtvd88 hi') + ' will send a "hi" messege to ' + \
1517         magenta('@dtvd88') + '.\n'
1518     usage += s * 2 + light_green('trash 5') + ' will remove message with ' + \
1519         light_yellow('[message_id=5]') + '.\n'
1520     printNicely(usage)
1521
1522
1523 def help_friends_and_followers():
1524     """
1525     Friends and Followers
1526     """
1527     s = ' ' * 2
1528     # Follower and following
1529     usage = '\n'
1530     usage += s + grey(u'\u266A' + ' Friends and followers \n')
1531     usage += s * 2 + \
1532         light_green('ls fl') + \
1533         ' will list all followers (people who are following you).\n'
1534     usage += s * 2 + \
1535         light_green('ls fr') + \
1536         ' will list all friends (people who you are following).\n'
1537     usage += s * 2 + light_green('fl @dtvd88') + ' will follow ' + \
1538         magenta('@dtvd88') + '.\n'
1539     usage += s * 2 + light_green('ufl @dtvd88') + ' will unfollow ' + \
1540         magenta('@dtvd88') + '.\n'
1541     usage += s * 2 + light_green('mute @dtvd88') + ' will mute ' + \
1542         magenta('@dtvd88') + '.\n'
1543     usage += s * 2 + light_green('unmute @dtvd88') + ' will unmute ' + \
1544         magenta('@dtvd88') + '.\n'
1545     usage += s * 2 + light_green('muting') + ' will list muting users.\n'
1546     usage += s * 2 + light_green('block @dtvd88') + ' will block ' + \
1547         magenta('@dtvd88') + '.\n'
1548     usage += s * 2 + light_green('unblock @dtvd88') + ' will unblock ' + \
1549         magenta('@dtvd88') + '.\n'
1550     usage += s * 2 + light_green('report @dtvd88') + ' will report ' + \
1551         magenta('@dtvd88') + ' as a spam account.\n'
1552     printNicely(usage)
1553
1554
1555 def help_list():
1556     """
1557     Lists
1558     """
1559     s = ' ' * 2
1560     # Twitter list
1561     usage = '\n'
1562     usage += s + grey(u'\u266A' + ' Twitter list\n')
1563     usage += s * 2 + light_green('list') + \
1564         ' will show all lists you are belong to.\n'
1565     usage += s * 2 + light_green('list home') + \
1566         ' will show timeline of list. You will be asked for list\'s name.\n'
1567     usage += s * 2 + light_green('list all_mem') + \
1568         ' will show list\'s all members.\n'
1569     usage += s * 2 + light_green('list all_sub') + \
1570         ' will show list\'s all subscribers.\n'
1571     usage += s * 2 + light_green('list add') + \
1572         ' will add specific person to a list owned by you.' + \
1573         ' You will be asked for list\'s name and person\'s name.\n'
1574     usage += s * 2 + light_green('list rm') + \
1575         ' will remove specific person from a list owned by you.' + \
1576         ' You will be asked for list\'s name and person\'s name.\n'
1577     usage += s * 2 + light_green('list sub') + \
1578         ' will subscribe you to a specific list.\n'
1579     usage += s * 2 + light_green('list unsub') + \
1580         ' will unsubscribe you from a specific list.\n'
1581     usage += s * 2 + light_green('list own') + \
1582         ' will show all list owned by you.\n'
1583     usage += s * 2 + light_green('list new') + \
1584         ' will create a new list.\n'
1585     usage += s * 2 + light_green('list update') + \
1586         ' will update a list owned by you.\n'
1587     usage += s * 2 + light_green('list del') + \
1588         ' will delete a list owned by you.\n'
1589     printNicely(usage)
1590
1591
1592 def help_stream():
1593     """
1594     Stream switch
1595     """
1596     s = ' ' * 2
1597     # Switch
1598     usage = '\n'
1599     usage += s + grey(u'\u266A' + ' Switching streams \n')
1600     usage += s * 2 + light_green('switch public #AKB') + \
1601         ' will switch to public stream and follow "' + \
1602         light_yellow('AKB') + '" keyword.\n'
1603     usage += s * 2 + light_green('switch mine') + \
1604         ' will switch to your personal stream.\n'
1605     usage += s * 2 + light_green('switch mine -f ') + \
1606         ' will prompt to enter the filter.\n'
1607     usage += s * 3 + light_yellow('Only nicks') + \
1608         ' filter will decide nicks will be INCLUDE ONLY.\n'
1609     usage += s * 3 + light_yellow('Ignore nicks') + \
1610         ' filter will decide nicks will be EXCLUDE.\n'
1611     usage += s * 2 + light_green('switch list') + \
1612         ' will switch to a Twitter list\'s stream. You will be asked for list name\n'
1613     printNicely(usage)
1614
1615
1616 def help():
1617     """
1618     Help
1619     """
1620     s = ' ' * 2
1621     h, w = os.popen('stty size', 'r').read().split()
1622     # Start
1623     usage = '\n'
1624     usage += s + 'Hi boss! I\'m ready to serve you right now!\n'
1625     usage += s + '-' * (int(w) - 4) + '\n'
1626     usage += s + 'You are ' + \
1627         light_yellow('already') + ' on your personal stream.\n'
1628     usage += s + 'Any update from Twitter will show up ' + \
1629         light_yellow('immediately') + '.\n'
1630     usage += s + 'In addition, following commands are available right now:\n'
1631     # Twitter help section
1632     usage += '\n'
1633     usage += s + grey(u'\u266A' + ' Twitter help\n')
1634     usage += s * 2 + light_green('h discover') + \
1635         ' will show help for discover commands.\n'
1636     usage += s * 2 + light_green('h tweets') + \
1637         ' will show help for tweets commands.\n'
1638     usage += s * 2 + light_green('h messages') + \
1639         ' will show help for messages commands.\n'
1640     usage += s * 2 + light_green('h friends_and_followers') + \
1641         ' will show help for friends and followers commands.\n'
1642     usage += s * 2 + light_green('h list') + \
1643         ' will show help for list commands.\n'
1644     usage += s * 2 + light_green('h stream') + \
1645         ' will show help for stream commands.\n'
1646     # Smart shell
1647     usage += '\n'
1648     usage += s + grey(u'\u266A' + ' Smart shell\n')
1649     usage += s * 2 + light_green('111111 * 9 / 7') + ' or any math expression ' + \
1650         'will be evaluate by Python interpreter.\n'
1651     usage += s * 2 + 'Even ' + light_green('cal') + ' will show the calendar' + \
1652         ' for current month.\n'
1653     # Config
1654     usage += '\n'
1655     usage += s + grey(u'\u266A' + ' Config \n')
1656     usage += s * 2 + light_green('theme') + ' will list available theme. ' + \
1657         light_green('theme monokai') + ' will apply ' + light_yellow('monokai') + \
1658         ' theme immediately.\n'
1659     usage += s * 2 + light_green('config') + ' will list all config.\n'
1660     usage += s * 3 + \
1661         light_green('config ASCII_ART') + ' will output current value of ' +\
1662         light_yellow('ASCII_ART') + ' config key.\n'
1663     usage += s * 3 + \
1664         light_green('config TREND_MAX default') + ' will output default value of ' + \
1665         light_yellow('TREND_MAX') + ' config key.\n'
1666     usage += s * 3 + \
1667         light_green('config CUSTOM_CONFIG drop') + ' will drop ' + \
1668         light_yellow('CUSTOM_CONFIG') + ' config key.\n'
1669     usage += s * 3 + \
1670         light_green('config IMAGE_ON_TERM = true') + ' will set value of ' + \
1671         light_yellow('IMAGE_ON_TERM') + ' config key to ' + \
1672         light_yellow('True') + '.\n'
1673     # Screening
1674     usage += '\n'
1675     usage += s + grey(u'\u266A' + ' Screening \n')
1676     usage += s * 2 + light_green('h') + ' will show this help again.\n'
1677     usage += s * 2 + light_green('p') + ' will pause the stream.\n'
1678     usage += s * 2 + light_green('r') + ' will unpause the stream.\n'
1679     usage += s * 2 + light_green('c') + ' will clear the screen.\n'
1680     usage += s * 2 + light_green('v') + ' will show version info.\n'
1681     usage += s * 2 + light_green('q') + ' will quit.\n'
1682     # End
1683     usage += '\n'
1684     usage += s + '-' * (int(w) - 4) + '\n'
1685     usage += s + 'Have fun and hang tight! \n'
1686     # Show help
1687     d = {
1688         'discover': help_discover,
1689         'tweets': help_tweets,
1690         'messages': help_messages,
1691         'friends_and_followers': help_friends_and_followers,
1692         'list': help_list,
1693         'stream': help_stream,
1694     }
1695     if g['stuff']:
1696         d.get(
1697             g['stuff'].strip(),
1698             lambda: printNicely(red('No such command.'))
1699         )()
1700     else:
1701         printNicely(usage)
1702
1703
1704 def pause():
1705     """
1706     Pause stream display
1707     """
1708     g['pause'] = True
1709     printNicely(green('Stream is paused'))
1710
1711
1712 def replay():
1713     """
1714     Replay stream
1715     """
1716     g['pause'] = False
1717     printNicely(green('Stream is running back now'))
1718
1719
1720 def clear():
1721     """
1722     Clear screen
1723     """
1724     os.system('clear')
1725
1726
1727 def quit():
1728     """
1729     Exit all
1730     """
1731     try:
1732         save_history()
1733         printNicely(green('See you next time :)'))
1734     except:
1735         pass
1736     sys.exit()
1737
1738
1739 def reset():
1740     """
1741     Reset prefix of line
1742     """
1743     if g['reset']:
1744         if c.get('USER_JSON_ERROR'):
1745             printNicely(red('Your ~/.rainbow_config.json is messed up:'))
1746             printNicely(red('>>> ' + c['USER_JSON_ERROR']))
1747             printNicely('')
1748         printNicely(magenta('Need tips ? Type "h" and hit Enter key!'))
1749     g['reset'] = False
1750     try:
1751         printNicely(str(eval(g['cmd'])))
1752     except Exception:
1753         pass
1754
1755
1756 # Command set
1757 cmdset = [
1758     'switch',
1759     'trend',
1760     'home',
1761     'notification',
1762     'view',
1763     'mentions',
1764     't',
1765     'rt',
1766     'quote',
1767     'allrt',
1768     'conversation',
1769     'fav',
1770     'rep',
1771     'del',
1772     'ufav',
1773     'share',
1774     's',
1775     'mes',
1776     'show',
1777     'open',
1778     'ls',
1779     'inbox',
1780     'thread',
1781     'trash',
1782     'whois',
1783     'fl',
1784     'ufl',
1785     'mute',
1786     'unmute',
1787     'muting',
1788     'block',
1789     'unblock',
1790     'report',
1791     'list',
1792     'cal',
1793     'config',
1794     'theme',
1795     'h',
1796     'p',
1797     'r',
1798     'c',
1799     'v',
1800     'q',
1801 ]
1802
1803 # Handle function set
1804 funcset = [
1805     switch,
1806     trend,
1807     home,
1808     notification,
1809     view,
1810     mentions,
1811     tweet,
1812     retweet,
1813     quote,
1814     allretweet,
1815     conversation,
1816     favorite,
1817     reply,
1818     delete,
1819     unfavorite,
1820     share,
1821     search,
1822     message,
1823     show,
1824     urlopen,
1825     ls,
1826     inbox,
1827     thread,
1828     trash,
1829     whois,
1830     follow,
1831     unfollow,
1832     mute,
1833     unmute,
1834     muting,
1835     block,
1836     unblock,
1837     report,
1838     twitterlist,
1839     cal,
1840     config,
1841     theme,
1842     help,
1843     pause,
1844     replay,
1845     clear,
1846     upgrade_center,
1847     quit,
1848 ]
1849
1850
1851 def process(cmd):
1852     """
1853     Process switch
1854     """
1855     return dict(zip(cmdset, funcset)).get(cmd, reset)
1856
1857
1858 def listen():
1859     """
1860     Listen to user's input
1861     """
1862     d = dict(zip(
1863         cmdset,
1864         [
1865             ['public', 'mine', 'list'],  # switch
1866             [],  # trend
1867             [],  # home
1868             [],  # notification
1869             ['@'],  # view
1870             [],  # mentions
1871             [],  # tweet
1872             [],  # retweet
1873             [],  # quote
1874             [],  # allretweet
1875             [],  # conversation
1876             [],  # favorite
1877             [],  # reply
1878             [],  # delete
1879             [],  # unfavorite
1880             [],  # url
1881             ['#'],  # search
1882             ['@'],  # message
1883             ['image'],  # show image
1884             [''],  # open url
1885             ['fl', 'fr'],  # list
1886             [],  # inbox
1887             [i for i in g['message_threads']],  # sent
1888             [],  # trash
1889             ['@'],  # whois
1890             ['@'],  # follow
1891             ['@'],  # unfollow
1892             ['@'],  # mute
1893             ['@'],  # unmute
1894             ['@'],  # muting
1895             ['@'],  # block
1896             ['@'],  # unblock
1897             ['@'],  # report
1898             [
1899                 'home',
1900                 'all_mem',
1901                 'all_sub',
1902                 'add',
1903                 'rm',
1904                 'sub',
1905                 'unsub',
1906                 'own',
1907                 'new',
1908                 'update',
1909                 'del'
1910             ],  # list
1911             [],  # cal
1912             [key for key in dict(get_all_config())],  # config
1913             g['themes'],  # theme
1914             [
1915                 'discover',
1916                 'tweets',
1917                 'messages',
1918                 'friends_and_followers',
1919                 'list',
1920                 'stream'
1921             ],  # help
1922             [],  # pause
1923             [],  # reconnect
1924             [],  # clear
1925             [],  # version
1926             [],  # quit
1927         ]
1928     ))
1929     init_interactive_shell(d)
1930     read_history()
1931     reset()
1932     while True:
1933         try:
1934             # raw_input
1935             if g['prefix']:
1936                 # Only use PREFIX as a string with raw_input
1937                 line = raw_input(g['decorated_name'](g['PREFIX']))
1938             else:
1939                 line = raw_input()
1940             # Save cmd to compare with readline buffer
1941             g['cmd'] = line.strip()
1942             # Get short cmd to pass to handle function
1943             try:
1944                 cmd = line.split()[0]
1945             except:
1946                 cmd = ''
1947             # Lock the semaphore
1948             c['lock'] = True
1949             # Save cmd to global variable and call process
1950             g['stuff'] = ' '.join(line.split()[1:])
1951             # Process the command
1952             process(cmd)()
1953             # Not re-display
1954             if cmd in ['switch', 't', 'rt', 'rep']:
1955                 g['prefix'] = False
1956             else:
1957                 g['prefix'] = True
1958             # Release the semaphore lock
1959             c['lock'] = False
1960         except EOFError:
1961             printNicely('')
1962         except Exception:
1963             debug_option()
1964             printNicely(red('OMG something is wrong with Twitter right now.'))
1965
1966
1967 def reconn_notice():
1968     """
1969     Notice when Hangup or Timeout
1970     """
1971     guide = light_magenta("You can use ") + \
1972         light_green("switch") + \
1973         light_magenta(" command to return to your stream.\n")
1974     guide += light_magenta("Type ") + \
1975         light_green("h stream") + \
1976         light_magenta(" for more details.")
1977     printNicely(guide)
1978     sys.stdout.write(g['decorated_name'](g['PREFIX']))
1979     sys.stdout.flush()
1980
1981
1982 def stream(domain, args, name='Rainbow Stream'):
1983     """
1984     Track the stream
1985     """
1986     # The Logo
1987     art_dict = {
1988         c['USER_DOMAIN']: name,
1989         c['PUBLIC_DOMAIN']: args.track_keywords,
1990         c['SITE_DOMAIN']: name,
1991     }
1992     if c['ASCII_ART']:
1993         ascii_art(art_dict[domain])
1994     # These arguments are optional:
1995     stream_args = dict(
1996         timeout=0.5,  # To check g['stream_stop'] after each 0.5 s
1997         block=True,
1998         heartbeat_timeout=c['HEARTBEAT_TIMEOUT'] * 60)
1999     # Track keyword
2000     query_args = dict()
2001     if args.track_keywords:
2002         query_args['track'] = args.track_keywords
2003     # Get stream
2004     stream = TwitterStream(
2005         auth=authen(),
2006         domain=domain,
2007         **stream_args)
2008     try:
2009         if domain == c['USER_DOMAIN']:
2010             tweet_iter = stream.user(**query_args)
2011         elif domain == c['SITE_DOMAIN']:
2012             tweet_iter = stream.site(**query_args)
2013         else:
2014             if args.track_keywords:
2015                 tweet_iter = stream.statuses.filter(**query_args)
2016             else:
2017                 tweet_iter = stream.statuses.sample()
2018         # Block new stream until other one exits
2019         StreamLock.acquire()
2020         g['stream_stop'] = False
2021         last_tweet_time = time.time()
2022         for tweet in tweet_iter:
2023             if tweet is None:
2024                 printNicely("-- None --")
2025             elif tweet is Timeout:
2026                 # Because the stream check for each 0.3s
2027                 # so we shouldn't output anything here
2028                 if(g['stream_stop']):
2029                     StreamLock.release()
2030                     break
2031             elif tweet is HeartbeatTimeout:
2032                 printNicely("-- Heartbeat Timeout --")
2033                 reconn_notice()
2034                 StreamLock.release()
2035                 break
2036             elif tweet is Hangup:
2037                 printNicely("-- Hangup --")
2038                 reconn_notice()
2039                 StreamLock.release()
2040                 break
2041             elif tweet.get('text'):
2042                 # Slow down the stream by STREAM_DELAY config key
2043                 if time.time() - last_tweet_time < c['STREAM_DELAY']:
2044                     continue
2045                 last_tweet_time = time.time()
2046                 # Check the semaphore pause and lock (stream process only)
2047                 if g['pause']:
2048                     continue
2049                 while c['lock']:
2050                     time.sleep(0.5)
2051                 # Draw the tweet
2052                 draw(
2053                     t=tweet,
2054                     keyword=args.track_keywords,
2055                     humanize=False,
2056                     fil=args.filter,
2057                     ig=args.ignore,
2058                 )
2059                 # Current readline buffer
2060                 current_buffer = readline.get_line_buffer().strip()
2061                 # There is an unexpected behaviour in MacOSX readline + Python 2:
2062                 # after completely delete a word after typing it,
2063                 # somehow readline buffer still contains
2064                 # the 1st character of that word
2065                 if current_buffer and g['cmd'] != current_buffer:
2066                     sys.stdout.write(
2067                         g['decorated_name'](g['PREFIX']) + current_buffer)
2068                     sys.stdout.flush()
2069                 elif not c['HIDE_PROMPT']:
2070                     sys.stdout.write(g['decorated_name'](g['PREFIX']))
2071                     sys.stdout.flush()
2072             elif tweet.get('direct_message'):
2073                 # Check the semaphore pause and lock (stream process only)
2074                 if g['pause']:
2075                     continue
2076                 while c['lock']:
2077                     time.sleep(0.5)
2078                 print_message(tweet['direct_message'])
2079             elif tweet.get('event'):
2080                 c['events'].append(tweet)
2081                 print_event(tweet)
2082     except TwitterHTTPError as e:
2083         printNicely('')
2084         printNicely(
2085             magenta("We have connection problem with twitter'stream API right now :("))
2086         detail_twitter_error(e)
2087         sys.stdout.write(g['decorated_name'](g['PREFIX']))
2088         sys.stdout.flush()
2089
2090
2091 def fly():
2092     """
2093     Main function
2094     """
2095     # Initial
2096     args = parse_arguments()
2097     try:
2098         proxy_connect(args)
2099         init(args)
2100     # Twitter API connection problem
2101     except TwitterHTTPError as e:
2102         printNicely('')
2103         printNicely(
2104             magenta("We have connection problem with twitter'REST API right now :("))
2105         detail_twitter_error(e)
2106         save_history()
2107         sys.exit()
2108     # Proxy connection problem
2109     except (socks.ProxyConnectionError, URLError):
2110         printNicely(
2111             magenta("There seems to be a connection problem."))
2112         printNicely(
2113             magenta("You might want to check your proxy settings (host, port and type)!"))
2114         save_history()
2115         sys.exit()
2116
2117     # Spawn stream thread
2118     th = threading.Thread(
2119         target=stream,
2120         args=(
2121             c['USER_DOMAIN'],
2122             args,
2123             g['original_name']))
2124     th.daemon = True
2125     th.start()
2126     # Start listen process
2127     time.sleep(0.5)
2128     g['reset'] = True
2129     g['prefix'] = True
2130     listen()