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