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