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 printTwitterErrors
  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['PREFIX'] = emojize(c['PREFIX'])
 208     g['PREFIX'] = u2str(c['PREFIX'])
 209     c['original_name'] = g['original_name'] = screen_name[1:]
 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             # Reset prefix
1247             g['PREFIX'] = u2str(emojize(c['PREFIX']))
1248             # Start new thread
1249             th = threading.Thread(
1250                 target=stream,
1251                 args=(
1252                     c['PUBLIC_DOMAIN'],
1253                     args))
1254             th.daemon = True
1255             th.start()
1256         # Personal stream
1257         elif target == 'mine':
1258             # Kill old thread
1259             g['stream_stop'] = True
1260             # Reset prefix
1261             g['PREFIX'] = u2str(emojize(c['PREFIX']))
1262             # Start new thread
1263             th = threading.Thread(
1264                 target=stream,
1265                 args=(
1266                     c['USER_DOMAIN'],
1267                     args,
1268                     g['original_name']))
1269             th.daemon = True
1270             th.start()
1271         # Stream base on list
1272         elif target == 'list':
1273             owner, slug = get_slug()
1274             # Force python 2 not redraw readline buffer
1275             g['PREFIX'] = g['cmd'] = '/'.join([owner, slug])
1276             printNicely(light_yellow('getting list members ...'))
1277             # Get members
1278             t = Twitter(auth=authen())
1279             members = []
1280             next_cursor = -1
1281             while next_cursor != 0:
1282                 m = t.lists.members(
1283                     slug=slug,
1284                     owner_screen_name=owner,
1285                     cursor=next_cursor,
1286                     include_entities=False)
1287                 for u in m['users']:
1288                     members.append('@' + u['screen_name'])
1289                 next_cursor = m['next_cursor']
1290             printNicely(light_yellow('... done.'))
1291             # Build thread filter array
1292             args.filter = members
1293             # Kill old thread
1294             g['stream_stop'] = True
1295             # Start new thread
1296             th = threading.Thread(
1297                 target=stream,
1298                 args=(
1299                     c['USER_DOMAIN'],
1300                     args,
1301                     slug))
1302             th.daemon = True
1303             th.start()
1304         printNicely('')
1305         if args.filter:
1306             printNicely(cyan('Include: ' + str(len(args.filter)) + ' people.'))
1307         if args.ignore:
1308             printNicely(red('Ignore: ' + str(len(args.ignore)) + ' people.'))
1309         printNicely('')
1310     except:
1311         debug_option()
1312         printNicely(red('Sorry I can\'t understand.'))
1313
1314
1315 def cal():
1316     """
1317     Unix's command `cal`
1318     """
1319     # Format
1320     rel = os.popen('cal').read().split('\n')
1321     month = rel.pop(0)
1322     date = rel.pop(0)
1323     show_calendar(month, date, rel)
1324
1325
1326 def theme():
1327     """
1328     List and change theme
1329     """
1330     if not g['stuff']:
1331         # List themes
1332         for theme in g['themes']:
1333             line = light_magenta(theme)
1334             if c['THEME'] == theme:
1335                 line = ' ' * 2 + light_yellow('* ') + line
1336             else:
1337                 line = ' ' * 4 + line
1338             printNicely(line)
1339     else:
1340         # Change theme
1341         try:
1342             # Load new theme
1343             c['THEME'] = reload_theme(g['stuff'], c['THEME'])
1344             # Redefine decorated_name
1345             g['decorated_name'] = lambda x: color_func(
1346                 c['DECORATED_NAME'])(
1347                 '[' + x + ']: ')
1348             printNicely(green('Theme changed.'))
1349         except:
1350             printNicely(red('No such theme exists.'))
1351
1352
1353 def config():
1354     """
1355     Browse and change config
1356     """
1357     all_config = get_all_config()
1358     g['stuff'] = g['stuff'].strip()
1359     # List all config
1360     if not g['stuff']:
1361         for k in all_config:
1362             line = ' ' * 2 + \
1363                 green(k) + ': ' + light_yellow(str(all_config[k]))
1364             printNicely(line)
1365         guide = 'Detailed explanation can be found at ' + \
1366             color_func(c['TWEET']['link'])(
1367                 'http://rainbowstream.readthedocs.org/en/latest/#config-explanation')
1368         printNicely(guide)
1369     # Print specific config
1370     elif len(g['stuff'].split()) == 1:
1371         if g['stuff'] in all_config:
1372             k = g['stuff']
1373             line = ' ' * 2 + \
1374                 green(k) + ': ' + light_yellow(str(all_config[k]))
1375             printNicely(line)
1376         else:
1377             printNicely(red('No such config key.'))
1378     # Print specific config's default value
1379     elif len(g['stuff'].split()) == 2 and g['stuff'].split()[-1] == 'default':
1380         key = g['stuff'].split()[0]
1381         try:
1382             value = get_default_config(key)
1383             line = ' ' * 2 + green(key) + ': ' + light_magenta(value)
1384             printNicely(line)
1385         except:
1386             debug_option()
1387             printNicely(red('Just can not get the default.'))
1388     # Delete specific config key in config file
1389     elif len(g['stuff'].split()) == 2 and g['stuff'].split()[-1] == 'drop':
1390         key = g['stuff'].split()[0]
1391         try:
1392             delete_config(key)
1393             printNicely(green('Config key is dropped.'))
1394         except:
1395             debug_option()
1396             printNicely(red('Just can not drop the key.'))
1397     # Set specific config
1398     elif len(g['stuff'].split()) == 3 and g['stuff'].split()[1] == '=':
1399         key = g['stuff'].split()[0]
1400         value = g['stuff'].split()[-1]
1401         if key == 'THEME' and not validate_theme(value):
1402             printNicely(red('Invalid theme\'s value.'))
1403             return
1404         try:
1405             set_config(key, value)
1406             # Keys that needs to be apply immediately
1407             if key == 'THEME':
1408                 c['THEME'] = reload_theme(value, c['THEME'])
1409                 g['decorated_name'] = lambda x: color_func(
1410                     c['DECORATED_NAME'])('[' + x + ']: ')
1411             elif key == 'PREFIX':
1412                 g['PREFIX'] = u2str(emojize(c['PREFIX']))
1413             reload_config()
1414             printNicely(green('Updated successfully.'))
1415         except:
1416             debug_option()
1417             printNicely(red('Just can not set the key.'))
1418     else:
1419         printNicely(light_magenta('Sorry I can\'s understand.'))
1420
1421
1422 def help_discover():
1423     """
1424     Discover the world
1425     """
1426     s = ' ' * 2
1427     # Discover the world
1428     usage = '\n'
1429     usage += s + grey(u'\u266A' + ' Discover the world \n')
1430     usage += s * 2 + light_green('trend') + ' will show global trending topics. ' + \
1431         'You can try ' + light_green('trend US') + ' or ' + \
1432         light_green('trend JP Tokyo') + '.\n'
1433     usage += s * 2 + light_green('home') + ' will show your timeline. ' + \
1434         light_green('home 7') + ' will show 7 tweets.\n'
1435     usage += s * 2 + \
1436         light_green('notification') + ' will show your recent notification.\n'
1437     usage += s * 2 + light_green('mentions') + ' will show mentions timeline. ' + \
1438         light_green('mentions 7') + ' will show 7 mention tweets.\n'
1439     usage += s * 2 + light_green('whois @mdo') + ' will show profile  of ' + \
1440         magenta('@mdo') + '.\n'
1441     usage += s * 2 + light_green('view @mdo') + \
1442         ' will show ' + magenta('@mdo') + '\'s home.\n'
1443     usage += s * 2 + light_green('s AKB48') + ' will search for "' + \
1444         light_yellow('AKB48') + '" and return 5 newest tweet. ' + \
1445         'Search can be performed with or without hashtag.\n'
1446     printNicely(usage)
1447
1448
1449 def help_tweets():
1450     """
1451     Tweets
1452     """
1453     s = ' ' * 2
1454     # Tweet
1455     usage = '\n'
1456     usage += s + grey(u'\u266A' + ' Tweets \n')
1457     usage += s * 2 + light_green('t oops ') + \
1458         'will tweet "' + light_yellow('oops') + '" immediately.\n'
1459     usage += s * 2 + \
1460         light_green('rt 12 ') + ' will retweet to tweet with ' + \
1461         light_yellow('[id=12]') + '.\n'
1462     usage += s * 2 + \
1463         light_green('quote 12 ') + ' will quote the tweet with ' + \
1464         light_yellow('[id=12]') + '. If no extra text is added, ' + \
1465         'the quote will be canceled.\n'
1466     usage += s * 2 + \
1467         light_green('allrt 12 20 ') + ' will list 20 newest retweet of the tweet with ' + \
1468         light_yellow('[id=12]') + '.\n'
1469     usage += s * 2 + light_green('conversation 12') + ' will show the chain of ' + \
1470         'replies prior to the tweet with ' + light_yellow('[id=12]') + '.\n'
1471     usage += s * 2 + light_green('rep 12 oops') + ' will reply "' + \
1472         light_yellow('oops') + '" to tweet with ' + \
1473         light_yellow('[id=12]') + '.\n'
1474     usage += s * 2 + \
1475         light_green('fav 12 ') + ' will favorite the tweet with ' + \
1476         light_yellow('[id=12]') + '.\n'
1477     usage += s * 2 + \
1478         light_green('ufav 12 ') + ' will unfavorite tweet with ' + \
1479         light_yellow('[id=12]') + '.\n'
1480     usage += s * 2 + \
1481         light_green('share 12 ') + ' will get the direct link of the tweet with ' + \
1482         light_yellow('[id=12]') + '.\n'
1483     usage += s * 2 + \
1484         light_green('del 12 ') + ' will delete tweet with ' + \
1485         light_yellow('[id=12]') + '.\n'
1486     usage += s * 2 + light_green('show image 12') + ' will show image in tweet with ' + \
1487         light_yellow('[id=12]') + ' in your OS\'s image viewer.\n'
1488     usage += s * 2 + light_green('open 12') + ' will open url in tweet with ' + \
1489         light_yellow('[id=12]') + ' in your OS\'s default browser.\n'
1490     printNicely(usage)
1491
1492
1493 def help_messages():
1494     """
1495     Messages
1496     """
1497     s = ' ' * 2
1498     # Direct message
1499     usage = '\n'
1500     usage += s + grey(u'\u266A' + ' Direct messages \n')
1501     usage += s * 2 + light_green('inbox') + ' will show inbox messages. ' + \
1502         light_green('inbox 7') + ' will show newest 7 messages.\n'
1503     usage += s * 2 + light_green('thread 2') + ' will show full thread with ' + \
1504         light_yellow('[thread_id=2]') + '.\n'
1505     usage += s * 2 + light_green('mes @dtvd88 hi') + ' will send a "hi" messege to ' + \
1506         magenta('@dtvd88') + '.\n'
1507     usage += s * 2 + light_green('trash 5') + ' will remove message with ' + \
1508         light_yellow('[message_id=5]') + '.\n'
1509     printNicely(usage)
1510
1511
1512 def help_friends_and_followers():
1513     """
1514     Friends and Followers
1515     """
1516     s = ' ' * 2
1517     # Follower and following
1518     usage = '\n'
1519     usage += s + grey(u'\u266A' + ' Friends and followers \n')
1520     usage += s * 2 + \
1521         light_green('ls fl') + \
1522         ' will list all followers (people who are following you).\n'
1523     usage += s * 2 + \
1524         light_green('ls fr') + \
1525         ' will list all friends (people who you are following).\n'
1526     usage += s * 2 + light_green('fl @dtvd88') + ' will follow ' + \
1527         magenta('@dtvd88') + '.\n'
1528     usage += s * 2 + light_green('ufl @dtvd88') + ' will unfollow ' + \
1529         magenta('@dtvd88') + '.\n'
1530     usage += s * 2 + light_green('mute @dtvd88') + ' will mute ' + \
1531         magenta('@dtvd88') + '.\n'
1532     usage += s * 2 + light_green('unmute @dtvd88') + ' will unmute ' + \
1533         magenta('@dtvd88') + '.\n'
1534     usage += s * 2 + light_green('muting') + ' will list muting users.\n'
1535     usage += s * 2 + light_green('block @dtvd88') + ' will block ' + \
1536         magenta('@dtvd88') + '.\n'
1537     usage += s * 2 + light_green('unblock @dtvd88') + ' will unblock ' + \
1538         magenta('@dtvd88') + '.\n'
1539     usage += s * 2 + light_green('report @dtvd88') + ' will report ' + \
1540         magenta('@dtvd88') + ' as a spam account.\n'
1541     printNicely(usage)
1542
1543
1544 def help_list():
1545     """
1546     Lists
1547     """
1548     s = ' ' * 2
1549     # Twitter list
1550     usage = '\n'
1551     usage += s + grey(u'\u266A' + ' Twitter list\n')
1552     usage += s * 2 + light_green('list') + \
1553         ' will show all lists you are belong to.\n'
1554     usage += s * 2 + light_green('list home') + \
1555         ' will show timeline of list. You will be asked for list\'s name.\n'
1556     usage += s * 2 + light_green('list all_mem') + \
1557         ' will show list\'s all members.\n'
1558     usage += s * 2 + light_green('list all_sub') + \
1559         ' will show list\'s all subscribers.\n'
1560     usage += s * 2 + light_green('list add') + \
1561         ' will add specific person to a list owned by you.' + \
1562         ' You will be asked for list\'s name and person\'s name.\n'
1563     usage += s * 2 + light_green('list rm') + \
1564         ' will remove specific person from a list owned by you.' + \
1565         ' You will be asked for list\'s name and person\'s name.\n'
1566     usage += s * 2 + light_green('list sub') + \
1567         ' will subscribe you to a specific list.\n'
1568     usage += s * 2 + light_green('list unsub') + \
1569         ' will unsubscribe you from a specific list.\n'
1570     usage += s * 2 + light_green('list own') + \
1571         ' will show all list owned by you.\n'
1572     usage += s * 2 + light_green('list new') + \
1573         ' will create a new list.\n'
1574     usage += s * 2 + light_green('list update') + \
1575         ' will update a list owned by you.\n'
1576     usage += s * 2 + light_green('list del') + \
1577         ' will delete a list owned by you.\n'
1578     printNicely(usage)
1579
1580
1581 def help_stream():
1582     """
1583     Stream switch
1584     """
1585     s = ' ' * 2
1586     # Switch
1587     usage = '\n'
1588     usage += s + grey(u'\u266A' + ' Switching streams \n')
1589     usage += s * 2 + light_green('switch public #AKB') + \
1590         ' will switch to public stream and follow "' + \
1591         light_yellow('AKB') + '" keyword.\n'
1592     usage += s * 2 + light_green('switch mine') + \
1593         ' will switch to your personal stream.\n'
1594     usage += s * 2 + light_green('switch mine -f ') + \
1595         ' will prompt to enter the filter.\n'
1596     usage += s * 3 + light_yellow('Only nicks') + \
1597         ' filter will decide nicks will be INCLUDE ONLY.\n'
1598     usage += s * 3 + light_yellow('Ignore nicks') + \
1599         ' filter will decide nicks will be EXCLUDE.\n'
1600     usage += s * 2 + light_green('switch list') + \
1601         ' will switch to a Twitter list\'s stream. You will be asked for list name\n'
1602     printNicely(usage)
1603
1604
1605 def help():
1606     """
1607     Help
1608     """
1609     s = ' ' * 2
1610     h, w = os.popen('stty size', 'r').read().split()
1611     # Start
1612     usage = '\n'
1613     usage += s + 'Hi boss! I\'m ready to serve you right now!\n'
1614     usage += s + '-' * (int(w) - 4) + '\n'
1615     usage += s + 'You are ' + \
1616         light_yellow('already') + ' on your personal stream.\n'
1617     usage += s + 'Any update from Twitter will show up ' + \
1618         light_yellow('immediately') + '.\n'
1619     usage += s + 'In addition, following commands are available right now:\n'
1620     # Twitter help section
1621     usage += '\n'
1622     usage += s + grey(u'\u266A' + ' Twitter help\n')
1623     usage += s * 2 + light_green('h discover') + \
1624         ' will show help for discover commands.\n'
1625     usage += s * 2 + light_green('h tweets') + \
1626         ' will show help for tweets commands.\n'
1627     usage += s * 2 + light_green('h messages') + \
1628         ' will show help for messages commands.\n'
1629     usage += s * 2 + light_green('h friends_and_followers') + \
1630         ' will show help for friends and followers commands.\n'
1631     usage += s * 2 + light_green('h list') + \
1632         ' will show help for list commands.\n'
1633     usage += s * 2 + light_green('h stream') + \
1634         ' will show help for stream commands.\n'
1635     # Smart shell
1636     usage += '\n'
1637     usage += s + grey(u'\u266A' + ' Smart shell\n')
1638     usage += s * 2 + light_green('111111 * 9 / 7') + ' or any math expression ' + \
1639         'will be evaluate by Python interpreter.\n'
1640     usage += s * 2 + 'Even ' + light_green('cal') + ' will show the calendar' + \
1641         ' for current month.\n'
1642     # Config
1643     usage += '\n'
1644     usage += s + grey(u'\u266A' + ' Config \n')
1645     usage += s * 2 + light_green('theme') + ' will list available theme. ' + \
1646         light_green('theme monokai') + ' will apply ' + light_yellow('monokai') + \
1647         ' theme immediately.\n'
1648     usage += s * 2 + light_green('config') + ' will list all config.\n'
1649     usage += s * 3 + \
1650         light_green('config ASCII_ART') + ' will output current value of ' +\
1651         light_yellow('ASCII_ART') + ' config key.\n'
1652     usage += s * 3 + \
1653         light_green('config TREND_MAX default') + ' will output default value of ' + \
1654         light_yellow('TREND_MAX') + ' config key.\n'
1655     usage += s * 3 + \
1656         light_green('config CUSTOM_CONFIG drop') + ' will drop ' + \
1657         light_yellow('CUSTOM_CONFIG') + ' config key.\n'
1658     usage += s * 3 + \
1659         light_green('config IMAGE_ON_TERM = true') + ' will set value of ' + \
1660         light_yellow('IMAGE_ON_TERM') + ' config key to ' + \
1661         light_yellow('True') + '.\n'
1662     # Screening
1663     usage += '\n'
1664     usage += s + grey(u'\u266A' + ' Screening \n')
1665     usage += s * 2 + light_green('h') + ' will show this help again.\n'
1666     usage += s * 2 + light_green('p') + ' will pause the stream.\n'
1667     usage += s * 2 + light_green('r') + ' will unpause the stream.\n'
1668     usage += s * 2 + light_green('c') + ' will clear the screen.\n'
1669     usage += s * 2 + light_green('v') + ' will show version info.\n'
1670     usage += s * 2 + light_green('q') + ' will quit.\n'
1671     # End
1672     usage += '\n'
1673     usage += s + '-' * (int(w) - 4) + '\n'
1674     usage += s + 'Have fun and hang tight! \n'
1675     # Show help
1676     d = {
1677         'discover': help_discover,
1678         'tweets': help_tweets,
1679         'messages': help_messages,
1680         'friends_and_followers': help_friends_and_followers,
1681         'list': help_list,
1682         'stream': help_stream,
1683     }
1684     if g['stuff']:
1685         d.get(
1686             g['stuff'].strip(),
1687             lambda: printNicely(red('No such command.'))
1688         )()
1689     else:
1690         printNicely(usage)
1691
1692
1693 def pause():
1694     """
1695     Pause stream display
1696     """
1697     g['pause'] = True
1698     printNicely(green('Stream is paused'))
1699
1700
1701 def replay():
1702     """
1703     Replay stream
1704     """
1705     g['pause'] = False
1706     printNicely(green('Stream is running back now'))
1707
1708
1709 def clear():
1710     """
1711     Clear screen
1712     """
1713     os.system('clear')
1714
1715
1716 def quit():
1717     """
1718     Exit all
1719     """
1720     try:
1721         save_history()
1722         printNicely(green('See you next time :)'))
1723     except:
1724         pass
1725     sys.exit()
1726
1727
1728 def reset():
1729     """
1730     Reset prefix of line
1731     """
1732     if g['reset']:
1733         if c.get('USER_JSON_ERROR'):
1734             printNicely(red('Your ~/.rainbow_config.json is messed up:'))
1735             printNicely(red('>>> ' + c['USER_JSON_ERROR']))
1736             printNicely('')
1737         printNicely(magenta('Need tips ? Type "h" and hit Enter key!'))
1738     g['reset'] = False
1739     try:
1740         printNicely(str(eval(g['cmd'])))
1741     except Exception:
1742         pass
1743
1744
1745 # Command set
1746 cmdset = [
1747     'switch',
1748     'trend',
1749     'home',
1750     'notification',
1751     'view',
1752     'mentions',
1753     't',
1754     'rt',
1755     'quote',
1756     'allrt',
1757     'conversation',
1758     'fav',
1759     'rep',
1760     'del',
1761     'ufav',
1762     'share',
1763     's',
1764     'mes',
1765     'show',
1766     'open',
1767     'ls',
1768     'inbox',
1769     'thread',
1770     'trash',
1771     'whois',
1772     'fl',
1773     'ufl',
1774     'mute',
1775     'unmute',
1776     'muting',
1777     'block',
1778     'unblock',
1779     'report',
1780     'list',
1781     'cal',
1782     'config',
1783     'theme',
1784     'h',
1785     'p',
1786     'r',
1787     'c',
1788     'v',
1789     'q',
1790 ]
1791
1792 # Handle function set
1793 funcset = [
1794     switch,
1795     trend,
1796     home,
1797     notification,
1798     view,
1799     mentions,
1800     tweet,
1801     retweet,
1802     quote,
1803     allretweet,
1804     conversation,
1805     favorite,
1806     reply,
1807     delete,
1808     unfavorite,
1809     share,
1810     search,
1811     message,
1812     show,
1813     urlopen,
1814     ls,
1815     inbox,
1816     thread,
1817     trash,
1818     whois,
1819     follow,
1820     unfollow,
1821     mute,
1822     unmute,
1823     muting,
1824     block,
1825     unblock,
1826     report,
1827     twitterlist,
1828     cal,
1829     config,
1830     theme,
1831     help,
1832     pause,
1833     replay,
1834     clear,
1835     upgrade_center,
1836     quit,
1837 ]
1838
1839
1840 def process(cmd):
1841     """
1842     Process switch
1843     """
1844     return dict(zip(cmdset, funcset)).get(cmd, reset)
1845
1846
1847 def listen():
1848     """
1849     Listen to user's input
1850     """
1851     d = dict(zip(
1852         cmdset,
1853         [
1854             ['public', 'mine', 'list'],  # switch
1855             [],  # trend
1856             [],  # home
1857             [],  # notification
1858             ['@'],  # view
1859             [],  # mentions
1860             [],  # tweet
1861             [],  # retweet
1862             [],  # quote
1863             [],  # allretweet
1864             [],  # conversation
1865             [],  # favorite
1866             [],  # reply
1867             [],  # delete
1868             [],  # unfavorite
1869             [],  # url
1870             ['#'],  # search
1871             ['@'],  # message
1872             ['image'],  # show image
1873             [''],  # open url
1874             ['fl', 'fr'],  # list
1875             [],  # inbox
1876             [i for i in g['message_threads']],  # sent
1877             [],  # trash
1878             ['@'],  # whois
1879             ['@'],  # follow
1880             ['@'],  # unfollow
1881             ['@'],  # mute
1882             ['@'],  # unmute
1883             ['@'],  # muting
1884             ['@'],  # block
1885             ['@'],  # unblock
1886             ['@'],  # report
1887             [
1888                 'home',
1889                 'all_mem',
1890                 'all_sub',
1891                 'add',
1892                 'rm',
1893                 'sub',
1894                 'unsub',
1895                 'own',
1896                 'new',
1897                 'update',
1898                 'del'
1899             ],  # list
1900             [],  # cal
1901             [key for key in dict(get_all_config())],  # config
1902             g['themes'],  # theme
1903             [
1904                 'discover',
1905                 'tweets',
1906                 'messages',
1907                 'friends_and_followers',
1908                 'list',
1909                 'stream'
1910             ],  # help
1911             [],  # pause
1912             [],  # reconnect
1913             [],  # clear
1914             [],  # version
1915             [],  # quit
1916         ]
1917     ))
1918     init_interactive_shell(d)
1919     read_history()
1920     reset()
1921     while True:
1922         try:
1923             # raw_input
1924             if g['prefix']:
1925                 # Only use PREFIX as a string with raw_input
1926                 line = raw_input(g['decorated_name'](g['PREFIX']))
1927             else:
1928                 line = raw_input()
1929             # Save cmd to compare with readline buffer
1930             g['cmd'] = line.strip()
1931             # Get short cmd to pass to handle function
1932             try:
1933                 cmd = line.split()[0]
1934             except:
1935                 cmd = ''
1936             # Lock the semaphore
1937             c['lock'] = True
1938             # Save cmd to global variable and call process
1939             g['stuff'] = ' '.join(line.split()[1:])
1940             # Process the command
1941             process(cmd)()
1942             # Not re-display
1943             if cmd in ['switch', 't', 'rt', 'rep']:
1944                 g['prefix'] = False
1945             else:
1946                 g['prefix'] = True
1947             # Release the semaphore lock
1948             c['lock'] = False
1949         except EOFError:
1950             printNicely('')
1951         except Exception:
1952             debug_option()
1953             printNicely(red('OMG something is wrong with Twitter right now.'))
1954
1955
1956 def reconn_notice():
1957     """
1958     Notice when Hangup or Timeout
1959     """
1960     guide = light_magenta("You can use ") + \
1961         light_green("switch") + \
1962         light_magenta(" command to return to your stream.\n")
1963     guide += light_magenta("Type ") + \
1964         light_green("h stream") + \
1965         light_magenta(" for more details.")
1966     printNicely(guide)
1967     sys.stdout.write(g['decorated_name'](c['PREFIX']))
1968     sys.stdout.flush()
1969
1970
1971 def stream(domain, args, name='Rainbow Stream'):
1972     """
1973     Track the stream
1974     """
1975     # The Logo
1976     art_dict = {
1977         c['USER_DOMAIN']: name,
1978         c['PUBLIC_DOMAIN']: args.track_keywords,
1979         c['SITE_DOMAIN']: name,
1980     }
1981     if c['ASCII_ART']:
1982         ascii_art(art_dict[domain])
1983     # These arguments are optional:
1984     stream_args = dict(
1985         timeout=0.5,  # To check g['stream_stop'] after each 0.5 s
1986         block=True,
1987         heartbeat_timeout=c['HEARTBEAT_TIMEOUT'] * 60)
1988     # Track keyword
1989     query_args = dict()
1990     if args.track_keywords:
1991         query_args['track'] = args.track_keywords
1992     # Get stream
1993     stream = TwitterStream(
1994         auth=authen(),
1995         domain=domain,
1996         **stream_args)
1997     try:
1998         if domain == c['USER_DOMAIN']:
1999             tweet_iter = stream.user(**query_args)
2000         elif domain == c['SITE_DOMAIN']:
2001             tweet_iter = stream.site(**query_args)
2002         else:
2003             if args.track_keywords:
2004                 tweet_iter = stream.statuses.filter(**query_args)
2005             else:
2006                 tweet_iter = stream.statuses.sample()
2007         # Block new stream until other one exits
2008         StreamLock.acquire()
2009         g['stream_stop'] = False
2010         last_tweet_time = time.time()
2011         for tweet in tweet_iter:
2012             if tweet is None:
2013                 printNicely("-- None --")
2014             elif tweet is Timeout:
2015                 # Because the stream check for each 0.3s
2016                 # so we shouldn't output anything here
2017                 if(g['stream_stop']):
2018                     StreamLock.release()
2019                     break
2020             elif tweet is HeartbeatTimeout:
2021                 printNicely("-- Heartbeat Timeout --")
2022                 reconn_notice()
2023                 StreamLock.release()
2024                 break
2025             elif tweet is Hangup:
2026                 printNicely("-- Hangup --")
2027                 reconn_notice()
2028                 StreamLock.release()
2029                 break
2030             elif tweet.get('text'):
2031                 # Slow down the stream by STREAM_DELAY config key
2032                 if time.time() - last_tweet_time < c['STREAM_DELAY']:
2033                     continue
2034                 last_tweet_time = time.time()
2035                 # Check the semaphore pause and lock (stream process only)
2036                 if g['pause']:
2037                     continue
2038                 while c['lock']:
2039                     time.sleep(0.5)
2040                 # Draw the tweet
2041                 draw(
2042                     t=tweet,
2043                     keyword=args.track_keywords,
2044                     humanize=False,
2045                     fil=args.filter,
2046                     ig=args.ignore,
2047                 )
2048                 # Current readline buffer
2049                 current_buffer = readline.get_line_buffer().strip()
2050                 # There is an unexpected behaviour in MacOSX readline + Python 2:
2051                 # after completely delete a word after typing it,
2052                 # somehow readline buffer still contains
2053                 # the 1st character of that word
2054                 if current_buffer and g['cmd'] != current_buffer:
2055                     sys.stdout.write(
2056                         g['decorated_name'](c['PREFIX']) + str2u(current_buffer))
2057                     sys.stdout.flush()
2058                 elif not c['HIDE_PROMPT']:
2059                     sys.stdout.write(g['decorated_name'](c['PREFIX']))
2060                     sys.stdout.flush()
2061             elif tweet.get('direct_message'):
2062                 # Check the semaphore pause and lock (stream process only)
2063                 if g['pause']:
2064                     continue
2065                 while c['lock']:
2066                     time.sleep(0.5)
2067                 print_message(tweet['direct_message'])
2068             elif tweet.get('event'):
2069                 c['events'].append(tweet)
2070                 print_event(tweet)
2071     except TwitterHTTPError as e:
2072         printNicely('')
2073         printNicely(
2074             magenta("We have maximum connection problem with twitter'stream API right now :("))
2075         printTwitterErrors(e)
2076
2077
2078 def fly():
2079     """
2080     Main function
2081     """
2082     # Initial
2083     args = parse_arguments()
2084     try:
2085         proxy_connect(args)
2086         init(args)
2087     # Twitter API connection problem
2088     except TwitterHTTPError as e:
2089         printNicely('')
2090         printNicely(
2091             magenta("We have connection problem with twitter'stream API right now :("))
2092         printTwitterErrors(e)
2093         printNicely(magenta("Let's try again later."))
2094         save_history()
2095         sys.exit()
2096     # Proxy connection problem
2097     except (socks.ProxyConnectionError, URLError):
2098         printNicely(
2099             magenta("There seems to be a connection problem."))
2100         printNicely(
2101             magenta("You might want to check your proxy settings (host, port and type)!"))
2102         save_history()
2103         sys.exit()
2104
2105     # Spawn stream thread
2106     th = threading.Thread(
2107         target=stream,
2108         args=(
2109             c['USER_DOMAIN'],
2110             args,
2111             g['original_name']))
2112     th.daemon = True
2113     th.start()
2114     # Start listen process
2115     time.sleep(0.5)
2116     g['reset'] = True
2117     g['prefix'] = True
2118     listen()