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