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