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         link_prefix = ('http://', 'https://')
 655         link_ary = [u for u in tweet['text'].split()
 656                     if u.startswith(link_prefix)]
 657         if not link_ary:
 658             printNicely(light_magenta('No url here @.@!'))
 659             return
 660         for link in link_ary:
 661             webbrowser.open(link)
 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 changelog_notify():
1738     # For v1.2.8. Hardcoded here but will improve later
1739     notice = light_yellow('Hey! RS just ')
1740     notice += light_green('doubled ')
1741     notice += light_yellow('pixels for higher image resolution. Upgrade and try')
1742     notice += light_green(' -iot ')
1743     notice += light_yellow('and you will like it for sure :)')
1744     printNicely(notice)
1745
1746
1747 def reset():
1748     """
1749     Reset prefix of line
1750     """
1751     if g['reset']:
1752         if c.get('USER_JSON_ERROR'):
1753             printNicely(red('Your ~/.rainbow_config.json is messed up:'))
1754             printNicely(red('>>> ' + c['USER_JSON_ERROR']))
1755             printNicely('')
1756         if not g['using_latest']:
1757             changelog_notify()
1758         printNicely(magenta('Need tips ? Type "h" and hit Enter key!'))
1759     g['reset'] = False
1760     try:
1761         printNicely(str(eval(g['cmd'])))
1762     except Exception:
1763         pass
1764
1765
1766 # Command set
1767 cmdset = [
1768     'switch',
1769     'trend',
1770     'home',
1771     'notification',
1772     'view',
1773     'mentions',
1774     't',
1775     'rt',
1776     'quote',
1777     'allrt',
1778     'conversation',
1779     'fav',
1780     'rep',
1781     'repall',
1782     'del',
1783     'ufav',
1784     'share',
1785     's',
1786     'mes',
1787     'show',
1788     'open',
1789     'ls',
1790     'inbox',
1791     'thread',
1792     'trash',
1793     'whois',
1794     'fl',
1795     'ufl',
1796     'mute',
1797     'unmute',
1798     'muting',
1799     'block',
1800     'unblock',
1801     'report',
1802     'list',
1803     'cal',
1804     'config',
1805     'theme',
1806     'h',
1807     'p',
1808     'r',
1809     'c',
1810     'v',
1811     'q',
1812 ]
1813
1814 # Handle function set
1815 funcset = [
1816     switch,
1817     trend,
1818     home,
1819     notification,
1820     view,
1821     mentions,
1822     tweet,
1823     retweet,
1824     quote,
1825     allretweet,
1826     conversation,
1827     favorite,
1828     reply,
1829     reply_all,
1830     delete,
1831     unfavorite,
1832     share,
1833     search,
1834     message,
1835     show,
1836     urlopen,
1837     ls,
1838     inbox,
1839     thread,
1840     trash,
1841     whois,
1842     follow,
1843     unfollow,
1844     mute,
1845     unmute,
1846     muting,
1847     block,
1848     unblock,
1849     report,
1850     twitterlist,
1851     cal,
1852     config,
1853     theme,
1854     help,
1855     pause,
1856     replay,
1857     clear,
1858     upgrade_center,
1859     quit,
1860 ]
1861
1862
1863 def process(cmd):
1864     """
1865     Process switch
1866     """
1867     return dict(zip(cmdset, funcset)).get(cmd, reset)
1868
1869
1870 def listen():
1871     """
1872     Listen to user's input
1873     """
1874     d = dict(zip(
1875         cmdset,
1876         [
1877             ['public', 'mine', 'list'],  # switch
1878             [],  # trend
1879             [],  # home
1880             [],  # notification
1881             ['@'],  # view
1882             [],  # mentions
1883             [],  # tweet
1884             [],  # retweet
1885             [],  # quote
1886             [],  # allretweet
1887             [],  # conversation
1888             [],  # favorite
1889             [],  # reply
1890             [],  # reply_all
1891             [],  # delete
1892             [],  # unfavorite
1893             [],  # url
1894             ['#'],  # search
1895             ['@'],  # message
1896             ['image'],  # show image
1897             [''],  # open url
1898             ['fl', 'fr'],  # list
1899             [],  # inbox
1900             [i for i in g['message_threads']],  # sent
1901             [],  # trash
1902             ['@'],  # whois
1903             ['@'],  # follow
1904             ['@'],  # unfollow
1905             ['@'],  # mute
1906             ['@'],  # unmute
1907             ['@'],  # muting
1908             ['@'],  # block
1909             ['@'],  # unblock
1910             ['@'],  # report
1911             [
1912                 'home',
1913                 'all_mem',
1914                 'all_sub',
1915                 'add',
1916                 'rm',
1917                 'sub',
1918                 'unsub',
1919                 'own',
1920                 'new',
1921                 'update',
1922                 'del'
1923             ],  # list
1924             [],  # cal
1925             [key for key in dict(get_all_config())],  # config
1926             g['themes'],  # theme
1927             [
1928                 'discover',
1929                 'tweets',
1930                 'messages',
1931                 'friends_and_followers',
1932                 'list',
1933                 'stream'
1934             ],  # help
1935             [],  # pause
1936             [],  # reconnect
1937             [],  # clear
1938             [],  # version
1939             [],  # quit
1940         ]
1941     ))
1942     init_interactive_shell(d)
1943     read_history()
1944     reset()
1945     while True:
1946         try:
1947             # raw_input
1948             if g['prefix']:
1949                 # Only use PREFIX as a string with raw_input
1950                 line = raw_input(g['decorated_name'](g['PREFIX']))
1951             else:
1952                 line = raw_input()
1953             # Save cmd to compare with readline buffer
1954             g['cmd'] = line.strip()
1955             # Get short cmd to pass to handle function
1956             try:
1957                 cmd = line.split()[0]
1958             except:
1959                 cmd = ''
1960             # Lock the semaphore
1961             c['lock'] = True
1962             # Save cmd to global variable and call process
1963             g['stuff'] = ' '.join(line.split()[1:])
1964             # Check tweet length
1965             if check_tweet_length():
1966                 # Process the command
1967                 process(cmd)()
1968                 # Not re-display
1969                 if cmd in ['switch', 't', 'rt', 'rep']:
1970                     g['prefix'] = False
1971                 else:
1972                     g['prefix'] = True
1973             # Release the semaphore lock
1974             c['lock'] = False
1975         except EOFError:
1976             printNicely('')
1977         except Exception:
1978             debug_option()
1979             printNicely(red('OMG something is wrong with Twitter right now.'))
1980
1981
1982 def check_tweet_length():
1983     """
1984     Check tweet length (should be <= 140 chars)
1985     """
1986     length = len(g['stuff'])
1987     if length <= 140:
1988         return True
1989
1990     printNicely(red("Message is too long: %s chars" % length))
1991     return False
1992
1993
1994 def reconn_notice():
1995     """
1996     Notice when Hangup or Timeout
1997     """
1998     guide = light_magenta('You can use ') + \
1999         light_green('switch') + \
2000         light_magenta(' command to return to your stream.\n')
2001     guide += light_magenta('Type ') + \
2002         light_green('h stream') + \
2003         light_magenta(' for more details.')
2004     printNicely(guide)
2005     sys.stdout.write(g['decorated_name'](g['PREFIX']))
2006     sys.stdout.flush()
2007
2008
2009 def stream(domain, args, name='Rainbow Stream'):
2010     """
2011     Track the stream
2012     """
2013     # The Logo
2014     art_dict = {
2015         c['USER_DOMAIN']: name,
2016         c['PUBLIC_DOMAIN']: args.track_keywords or 'Global',
2017         c['SITE_DOMAIN']: name,
2018     }
2019     if c['ASCII_ART']:
2020         ascii_art(art_dict.get(domain, name))
2021     # These arguments are optional:
2022     stream_args = dict(
2023         timeout=0.5,  # To check g['stream_stop'] after each 0.5 s
2024         block=True,
2025         heartbeat_timeout=c['HEARTBEAT_TIMEOUT'] * 60)
2026     # Track keyword
2027     query_args = dict()
2028     if args.track_keywords:
2029         query_args['track'] = args.track_keywords
2030     # Get stream
2031     stream = TwitterStream(
2032         auth=authen(),
2033         domain=domain,
2034         **stream_args)
2035     try:
2036         if domain == c['USER_DOMAIN']:
2037             tweet_iter = stream.user(**query_args)
2038         elif domain == c['SITE_DOMAIN']:
2039             tweet_iter = stream.site(**query_args)
2040         else:
2041             if args.track_keywords:
2042                 tweet_iter = stream.statuses.filter(**query_args)
2043             else:
2044                 tweet_iter = stream.statuses.sample()
2045         # Block new stream until other one exits
2046         StreamLock.acquire()
2047         g['stream_stop'] = False
2048         last_tweet_time = time.time()
2049         for tweet in tweet_iter:
2050             if tweet is None:
2051                 printNicely('-- None --')
2052             elif tweet is Timeout:
2053                 # Because the stream check for each 0.3s
2054                 # so we shouldn't output anything here
2055                 if(g['stream_stop']):
2056                     StreamLock.release()
2057                     break
2058             elif tweet is HeartbeatTimeout:
2059                 printNicely('-- Heartbeat Timeout --')
2060                 reconn_notice()
2061                 StreamLock.release()
2062                 break
2063             elif tweet is Hangup:
2064                 printNicely('-- Hangup --')
2065                 reconn_notice()
2066                 StreamLock.release()
2067                 break
2068             elif tweet.get('text'):
2069                 # Slow down the stream by STREAM_DELAY config key
2070                 if time.time() - last_tweet_time < c['STREAM_DELAY']:
2071                     continue
2072                 last_tweet_time = time.time()
2073                 # Check the semaphore pause and lock (stream process only)
2074                 if g['pause']:
2075                     continue
2076                 while c['lock']:
2077                     time.sleep(0.5)
2078                 # Draw the tweet
2079                 draw(
2080                     t=tweet,
2081                     keyword=args.track_keywords,
2082                     humanize=False,
2083                     fil=args.filter,
2084                     ig=args.ignore,
2085                 )
2086                 # Current readline buffer
2087                 current_buffer = readline.get_line_buffer().strip()
2088                 # There is an unexpected behaviour in MacOSX readline + Python 2:
2089                 # after completely delete a word after typing it,
2090                 # somehow readline buffer still contains
2091                 # the 1st character of that word
2092                 if current_buffer and g['cmd'] != current_buffer:
2093                     sys.stdout.write(
2094                         g['decorated_name'](g['PREFIX']) + current_buffer)
2095                     sys.stdout.flush()
2096                 elif not c['HIDE_PROMPT']:
2097                     sys.stdout.write(g['decorated_name'](g['PREFIX']))
2098                     sys.stdout.flush()
2099             elif tweet.get('direct_message'):
2100                 # Check the semaphore pause and lock (stream process only)
2101                 if g['pause']:
2102                     continue
2103                 while c['lock']:
2104                     time.sleep(0.5)
2105                 print_message(tweet['direct_message'])
2106             elif tweet.get('event'):
2107                 c['events'].append(tweet)
2108                 print_event(tweet)
2109     except TwitterHTTPError as e:
2110         printNicely('')
2111         printNicely(
2112             magenta('We have connection problem with twitter stream API right now :('))
2113         detail_twitter_error(e)
2114         sys.stdout.write(g['decorated_name'](g['PREFIX']))
2115         sys.stdout.flush()
2116     except (URLError):
2117         printNicely(
2118             magenta('There seems to be a connection problem.'))
2119         save_history()
2120         sys.exit()
2121
2122
2123 def spawn_public_stream(args, keyword=None):
2124     """
2125     Spawn a new public stream
2126     """
2127     # Only set keyword if specified
2128     if keyword:
2129         if keyword[0] == '#':
2130             keyword = keyword[1:]
2131         args.track_keywords = keyword
2132         g['keyword'] = keyword
2133     else:
2134         g['keyword'] = 'Global'
2135     g['PREFIX'] = u2str(emojize(format_prefix(keyword=g['keyword'])))
2136     g['listname'] = ''
2137     # Start new thread
2138     th = threading.Thread(
2139         target=stream,
2140         args=(
2141             c['PUBLIC_DOMAIN'],
2142             args))
2143     th.daemon = True
2144     th.start()
2145
2146
2147 def spawn_list_stream(args, stuff=None):
2148     """
2149     Spawn a new list stream
2150     """
2151     try:
2152         owner, slug = check_slug(stuff)
2153     except:
2154         owner, slug = get_slug()
2155
2156     # Force python 2 not redraw readline buffer
2157     listname = '/'.join([owner, slug])
2158     # Set the listname variable
2159     # and reset tracked keyword
2160     g['listname'] = listname
2161     g['keyword'] = ''
2162     g['PREFIX'] = g['cmd'] = u2str(emojize(format_prefix(
2163         listname=g['listname']
2164     )))
2165     printNicely(light_yellow('getting list members ...'))
2166     # Get members
2167     t = Twitter(auth=authen())
2168     members = []
2169     next_cursor = -1
2170     while next_cursor != 0:
2171         m = t.lists.members(
2172             slug=slug,
2173             owner_screen_name=owner,
2174             cursor=next_cursor,
2175             include_entities=False)
2176         for u in m['users']:
2177             members.append('@' + u['screen_name'])
2178         next_cursor = m['next_cursor']
2179     printNicely(light_yellow('... done.'))
2180     # Build thread filter array
2181     args.filter = members
2182     # Start new thread
2183     th = threading.Thread(
2184         target=stream,
2185         args=(
2186             c['USER_DOMAIN'],
2187             args,
2188             slug))
2189     th.daemon = True
2190     th.start()
2191     printNicely('')
2192     if args.filter:
2193         printNicely(cyan('Include: ' + str(len(args.filter)) + ' people.'))
2194     if args.ignore:
2195         printNicely(red('Ignore: ' + str(len(args.ignore)) + ' people.'))
2196     printNicely('')
2197
2198
2199 def spawn_personal_stream(args, stuff=None):
2200     """
2201     Spawn a new personal stream
2202     """
2203     # Reset the tracked keyword and listname
2204     g['keyword'] = g['listname'] = ''
2205     # Reset prefix
2206     g['PREFIX'] = u2str(emojize(format_prefix()))
2207     # Start new thread
2208     th = threading.Thread(
2209         target=stream,
2210         args=(
2211             c['USER_DOMAIN'],
2212             args,
2213             g['original_name']))
2214     th.daemon = True
2215     th.start()
2216
2217
2218 def fly():
2219     """
2220     Main function
2221     """
2222     # Initial
2223     args = parse_arguments()
2224     try:
2225         proxy_connect(args)
2226         init(args)
2227     # Twitter API connection problem
2228     except TwitterHTTPError as e:
2229         printNicely('')
2230         printNicely(
2231             magenta('We have connection problem with twitter REST API right now :('))
2232         detail_twitter_error(e)
2233         save_history()
2234         sys.exit()
2235     # Proxy connection problem
2236     except (socks.ProxyConnectionError, URLError):
2237         printNicely(
2238             magenta('There seems to be a connection problem.'))
2239         printNicely(
2240             magenta('You might want to check your proxy settings (host, port and type)!'))
2241         save_history()
2242         sys.exit()
2243
2244     # Spawn stream thread
2245     target = args.stream.split()[0]
2246     if target == 'mine' :
2247         spawn_personal_stream(args)
2248     else:
2249         try:
2250             stuff = args.stream.split()[1]
2251         except:
2252             stuff = None
2253         spawn_dict = {
2254             'public': spawn_public_stream,
2255             'list': spawn_list_stream,
2256         }
2257         spawn_dict.get(target)(args, stuff)
2258
2259     # Start listen process
2260     time.sleep(0.5)
2261     g['reset'] = True
2262     g['prefix'] = True
2263     listen()