rainbowstream/draw.py

   1 import random
   2 import textwrap
   3 import itertools
   4 import requests
   5 import locale
   6 import arrow
   7 import re
   8 import os
   9
  10 from io import BytesIO
  11 from twitter.util import printNicely
  12 from functools import wraps
  13 from pyfiglet import figlet_format
  14 from dateutil import parser
  15 from .c_image import *
  16 from .colors import *
  17 from .config import *
  18 from .py3patch import *
  19 from .emoji import *
  20
  21 # Draw global variables
  22 dg = {}
  23
  24
  25 def init_cycle():
  26     """
  27     Init the cycle
  28     """
  29     colors_shuffle = [globals()[i.encode('utf8')]
  30                       if not str(i).isdigit()
  31                       else term_color(int(i))
  32                       for i in c['CYCLE_COLOR']]
  33     return itertools.cycle(colors_shuffle)
  34
  35
  36 def start_cycle():
  37     """
  38     Notify from rainbow
  39     """
  40     dg['cyc'] = init_cycle()
  41     dg['cache'] = {}
  42     dg['humanize_unsupported'] = False
  43
  44
  45 def order_rainbow(s):
  46     """
  47     Print a string with ordered color with each character
  48     """
  49     colors_shuffle = [globals()[i.encode('utf8')]
  50                       if not str(i).isdigit()
  51                       else term_color(int(i))
  52                       for i in c['CYCLE_COLOR']]
  53     colored = [colors_shuffle[i % 7](s[i]) for i in xrange(len(s))]
  54     return ''.join(colored)
  55
  56
  57 def random_rainbow(s):
  58     """
  59     Print a string with random color with each character
  60     """
  61     colors_shuffle = [globals()[i.encode('utf8')]
  62                       if not str(i).isdigit()
  63                       else term_color(int(i))
  64                       for i in c['CYCLE_COLOR']]
  65     colored = [random.choice(colors_shuffle)(i) for i in s]
  66     return ''.join(colored)
  67
  68
  69 def Memoize(func):
  70     """
  71     Memoize decorator
  72     """
  73     @wraps(func)
  74     def wrapper(*args):
  75         if args not in dg['cache']:
  76             dg['cache'][args] = func(*args)
  77         return dg['cache'][args]
  78     return wrapper
  79
  80
  81 @Memoize
  82 def cycle_color(s):
  83     """
  84     Cycle the colors_shuffle
  85     """
  86     return next(dg['cyc'])(s)
  87
  88
  89 def ascii_art(text):
  90     """
  91     Draw the Ascii Art
  92     """
  93     fi = figlet_format(text, font='doom')
  94     print('\n'.join(
  95         [next(dg['cyc'])(i) for i in fi.split('\n')]
  96     ))
  97
  98
  99 def check_config():
 100     """
 101     Check if config is changed
 102     """
 103     changed = False
 104     data = get_all_config()
 105     for key in c:
 106         if key in data:
 107             if data[key] != c[key]:
 108                 changed = True
 109     if changed:
 110         reload_config()
 111
 112
 113 def validate_theme(theme):
 114     """
 115     Validate a theme exists or not
 116     """
 117     # Theme changed check
 118     files = os.listdir(os.path.dirname(__file__) + '/colorset')
 119     themes = [f.split('.')[0] for f in files if f.split('.')[-1] == 'json']
 120     return theme in themes
 121
 122
 123 def reload_theme(value, prev):
 124     """
 125     Check current theme and update if necessary
 126     """
 127     if value != prev:
 128         config = os.path.dirname(
 129             __file__) + '/colorset/' + value + '.json'
 130         # Load new config
 131         data = load_config(config)
 132         if data:
 133             for d in data:
 134                 c[d] = data[d]
 135         # Restart color cycle and update config
 136         start_cycle()
 137         set_config('THEME', value)
 138         return value
 139     return prev
 140
 141
 142 def color_func(func_name):
 143     """
 144     Call color function base on name
 145     """
 146     if str(func_name).isdigit():
 147         return term_color(int(func_name))
 148     return globals()[func_name]
 149
 150
 151 def fallback_humanize(date, fallback_format=None, use_fallback=False):
 152     """
 153     Format date with arrow and a fallback format
 154     """
 155     # Convert to local timezone
 156     date = arrow.get(date).to('local')
 157     # Set default fallback format
 158     if not fallback_format:
 159         fallback_format = '%Y/%m/%d %H:%M:%S'
 160     # Determine using fallback format or not by a variable
 161     if use_fallback:
 162         return date.datetime.strftime(fallback_format)
 163     try:
 164         # Use Arrow's humanize function
 165         lang, encode = locale.getdefaultlocale()
 166         clock = date.humanize(locale=lang)
 167     except:
 168         # Notice at the 1st time only
 169         if not dg['humanize_unsupported']:
 170             dg['humanize_unsupported'] = True
 171             printNicely(
 172                 light_magenta('Humanized date display method does not support your $LC_ALL.'))
 173         # Fallback when LC_ALL is not supported
 174         clock = date.datetime.strftime(fallback_format)
 175     return clock
 176
 177
 178 def get_full_text(t):
 179     """Handle RTs and extended tweets to always display all the available text"""
 180
 181     if t.get('retweeted_status'):
 182         rt_status = t['retweeted_status']
 183         if rt_status.get('extended_tweet'):
 184             elem = rt_status['extended_tweet']
 185         else:
 186             elem = rt_status
 187         rt_text = elem.get('full_text', elem.get('text'))
 188         t['full_text'] = 'RT @' + rt_status['user']['screen_name'] + ': ' + rt_text
 189     elif t.get('extended_tweet'):
 190         t['full_text'] = t['extended_tweet']['full_text']
 191
 192     return t.get('full_text', t.get('text'))
 193
 194
 195 def draw(t, keyword=None, humanize=True, noti=False, fil=[], ig=[]):
 196     """
 197     Draw the rainbow
 198     """
 199     # Check config
 200     check_config()
 201
 202     # Retrieve tweet
 203     tid = t['id']
 204
 205     text = get_full_text(t)
 206     screen_name = t['user']['screen_name']
 207     name = t['user']['name']
 208     created_at = t['created_at']
 209     favorited = t['favorited']
 210     retweet_count = t['retweet_count']
 211     favorite_count = t['favorite_count']
 212     client = t['source']
 213     date = parser.parse(created_at)
 214     try:
 215         clock_format = c['FORMAT']['TWEET']['CLOCK_FORMAT']
 216     except:
 217         clock_format = '%Y/%m/%d %H:%M:%S'
 218     clock = fallback_humanize(date, clock_format, not humanize)
 219
 220     # Pull extended retweet text
 221     try:
 222         # Display as a notification
 223         target = t['retweeted_status']['user']['screen_name']
 224         if all([target == c['original_name'], not noti]):
 225             # Add to evens for 'notification' command
 226             t['event'] = 'retweet'
 227             c['events'].append(t)
 228             notify_retweet(t)
 229             return
 230     except:
 231         pass
 232
 233     # Unescape HTML character
 234     text = unescape(text)
 235
 236     # Get client name
 237     try:
 238         client = client.split('>')[-2].split('<')[0]
 239     except:
 240         client = None
 241
 242     # Get expanded url
 243     try:
 244         expanded_url = []
 245         url = []
 246         urls = t['entities']['urls']
 247         for u in urls:
 248             expanded_url.append(u['expanded_url'])
 249             url.append(u['url'])
 250     except:
 251         expanded_url = None
 252         url = None
 253
 254     # Get media
 255     try:
 256         media_url = []
 257         media = t['entities']['media']
 258         for m in media:
 259             media_url.append(m['media_url'])
 260     except:
 261         media_url = None
 262
 263     # Filter and ignore
 264     mytweet = screen_name == c['original_name']
 265     screen_name = '@' + screen_name
 266     fil = list(set((fil or []) + c['ONLY_LIST']))
 267     ig = list(set((ig or []) + c['IGNORE_LIST']))
 268     if fil and screen_name not in fil:
 269         return
 270     if ig and screen_name in ig:
 271         return
 272
 273     # Get rainbow id
 274     if tid not in c['tweet_dict']:
 275         c['tweet_dict'].append(tid)
 276         rid = len(c['tweet_dict']) - 1
 277     else:
 278         rid = c['tweet_dict'].index(tid)
 279
 280     # Format info
 281     name = cycle_color(name)
 282     if mytweet:
 283         nick = color_func(c['TWEET']['mynick'])(screen_name)
 284     else:
 285         nick = color_func(c['TWEET']['nick'])(screen_name)
 286     clock = clock
 287     id = str(rid)
 288     fav = ''
 289     if favorited:
 290         fav = color_func(c['TWEET']['favorited'])(u'\u2605')
 291
 292     tweet = text.split(' ')
 293     tweet = [x for x in tweet if x != '']
 294     # Replace url
 295     if expanded_url:
 296         for index in xrange(len(expanded_url)):
 297             tweet = lmap(
 298                 lambda x: expanded_url[index]
 299                 if x == url[index]
 300                 else x,
 301                 tweet)
 302     # Highlight RT
 303     tweet = lmap(
 304         lambda x: color_func(c['TWEET']['rt'])(x)
 305         if x == 'RT'
 306         else x,
 307         tweet)
 308     # Highlight screen_name
 309     tweet = lmap(
 310         lambda x: cycle_color(x) if x.lstrip().startswith('@') else x, tweet)
 311     # Highlight link
 312     tweet = lmap(
 313         lambda x: color_func(c['TWEET']['link'])(x)
 314         if x.lstrip().startswith('http')
 315         else x,
 316         tweet)
 317     # Highlight hashtag
 318     tweet = lmap(
 319         lambda x: color_func(c['TWEET']['hashtag'])(x)
 320         if x.lstrip().startswith('#')
 321         else x,
 322         tweet)
 323     # Highlight my tweet
 324     if mytweet:
 325         tweet = [color_func(c['TWEET']['mytweet'])(x)
 326                  for x in tweet
 327                  if not any([
 328                      x == 'RT',
 329                      x.lstrip().startswith('http'),
 330                      x.lstrip().startswith('#')])
 331                  ]
 332     # Highlight keyword
 333     tweet = ' '.join(tweet)
 334     tweet = '\n  '.join(tweet.split('\n'))
 335     if keyword:
 336         roj = re.search(keyword, tweet, re.IGNORECASE)
 337         if roj:
 338             occur = roj.group()
 339             ary = tweet.split(occur)
 340             delimiter = color_func(c['TWEET']['keyword'])(occur)
 341             tweet = delimiter.join(ary)
 342
 343     # Load config formater
 344     formater = ''
 345     try:
 346         formater = c['FORMAT']['TWEET']['DISPLAY']
 347         formater = name.join(formater.split('#name'))
 348         formater = nick.join(formater.split('#nick'))
 349         formater = fav.join(formater.split('#fav'))
 350         formater = tweet.join(formater.split('#tweet'))
 351         formater = emojize(formater)
 352         # Change clock word
 353         word = [wo for wo in formater.split() if '#clock' in wo][0]
 354         delimiter = color_func(c['TWEET']['clock'])(
 355             clock.join(word.split('#clock')))
 356         formater = delimiter.join(formater.split(word))
 357         # Change id word
 358         word = [wo for wo in formater.split() if '#id' in wo][0]
 359         delimiter = color_func(c['TWEET']['id'])(id.join(word.split('#id')))
 360         formater = delimiter.join(formater.split(word))
 361         # Change retweet count word
 362         word = [wo for wo in formater.split() if '#rt_count' in wo][0]
 363         delimiter = color_func(c['TWEET']['retweet_count'])(
 364             str(retweet_count).join(word.split('#rt_count')))
 365         formater = delimiter.join(formater.split(word))
 366         # Change favorites count word
 367         word = [wo for wo in formater.split() if '#fa_count' in wo][0]
 368         delimiter = color_func(c['TWEET']['favorite_count'])(
 369             str(favorite_count).join(word.split('#fa_count')))
 370         formater = delimiter.join(formater.split(word))
 371         # Change client word
 372         word = [wo for wo in formater.split() if '#client' in wo][0]
 373         delimiter = color_func(c['TWEET']['client'])(
 374             client.join(word.split('#client')))
 375         formater = delimiter.join(formater.split(word))
 376     except:
 377         pass
 378
 379     # Add spaces in begining of line if this is inside a notification
 380     if noti:
 381         formater = '\n  '.join(formater.split('\n'))
 382         # Reformat
 383         if formater.startswith('\n'):
 384             formater = formater[1:]
 385
 386     # Draw
 387     printNicely(formater)
 388
 389     # Display Image
 390     if c['IMAGE_ON_TERM'] and media_url:
 391         for mu in media_url:
 392             try:
 393                 response = requests.get(mu)
 394                 image_to_display(BytesIO(response.content))
 395             except Exception:
 396                 printNicely(red('Sorry, image link is broken'))
 397
 398
 399 def print_threads(d):
 400     """
 401     Print threads of messages
 402     """
 403     id = 1
 404     rel = {}
 405     for partner in d:
 406         messages = d[partner]
 407         count = len(messages)
 408         screen_name = '@' + partner[0]
 409         name = partner[1]
 410         screen_name = color_func(c['MESSAGE']['partner'])(screen_name)
 411         name = cycle_color(name)
 412         thread_id = color_func(c['MESSAGE']['id'])('thread_id:' + str(id))
 413         line = ' ' * 2 + name + ' ' + screen_name + \
 414             ' (' + str(count) + ' message) ' + thread_id
 415         printNicely(line)
 416         rel[id] = partner
 417         id += 1
 418     dg['thread'] = d
 419     return rel
 420
 421
 422 def print_thread(partner, me_nick, me_name):
 423     """
 424     Print a thread of messages
 425     """
 426     # Sort messages by time
 427     messages = dg['thread'][partner]
 428     messages.sort(key=lambda x: int(x['created_at']))
 429     # Use legacy display on non-ascii text message
 430     ms = [m['text'] for m in messages]
 431     ums = [m for m in ms if not all(ord(c) < 128 for c in m)]
 432     if ums:
 433         for m in messages:
 434             print_message(m)
 435         printNicely('')
 436         return
 437     # Print the first line
 438     dg['frame_margin'] = margin = 2
 439     partner_nick = partner[0]
 440     partner_name = partner[1]
 441     left_size = len(partner_nick) + len(partner_name) + 2
 442     right_size = len(me_nick) + len(me_name) + 2
 443     partner_nick = color_func(c['MESSAGE']['partner'])('@' + partner_nick)
 444     partner_name = cycle_color(partner_name)
 445     me_screen_name = color_func(c['MESSAGE']['me'])('@' + me_nick)
 446     me_name = cycle_color(me_name)
 447     left = ' ' * margin + partner_name + ' ' + partner_nick
 448     right = me_name + ' ' + me_screen_name + ' ' * margin
 449     h, w = os.popen('stty size', 'r').read().split()
 450     w = int(w)
 451     line = '{}{}{}'.format(
 452         left, ' ' * (w - left_size - right_size - 2 * margin), right)
 453     printNicely('')
 454     printNicely(line)
 455     printNicely('')
 456     # Print messages
 457     for m in messages:
 458         if m['sender_screen_name'] == me_nick:
 459             print_right_message(m)
 460         elif m['recipient_screen_name'] == me_nick:
 461             print_left_message(m)
 462
 463
 464 def print_right_message(m):
 465     """
 466     Print a message on the right of screen
 467     """
 468     h, w = os.popen('stty size', 'r').read().split()
 469     w = int(w)
 470     frame_width = w // 3 - dg['frame_margin']
 471     frame_width = max(c['THREAD_MIN_WIDTH'], frame_width)
 472     step = frame_width - 2 * dg['frame_margin']
 473     slicing = textwrap.wrap(m['text'], step)
 474     spaces = w - frame_width - dg['frame_margin']
 475     dotline = ' ' * spaces + '-' * frame_width
 476     dotline = color_func(c['MESSAGE']['me_frame'])(dotline)
 477     # Draw the frame
 478     printNicely(dotline)
 479     for line in slicing:
 480         fill = step - len(line)
 481         screen_line = ' ' * spaces + '| ' + line + ' ' * fill + ' '
 482         if slicing[-1] == line:
 483             screen_line = screen_line + ' >'
 484         else:
 485             screen_line = screen_line + '|'
 486         screen_line = color_func(c['MESSAGE']['me_frame'])(screen_line)
 487         printNicely(screen_line)
 488     printNicely(dotline)
 489     # Format clock
 490     date = arrow.get(int(m['created_at'])/1000).to('local').datetime # Read Unixtime in miliseconds
 491     clock_format = '%Y/%m/%d %H:%M:%S'
 492     try:
 493         clock_format = c['FORMAT']['MESSAGE']['CLOCK_FORMAT']
 494     except:
 495         pass
 496     clock = date.strftime(clock_format)
 497     # Format id
 498     if m['id'] not in c['message_dict']:
 499         c['message_dict'].append(m['id'])
 500         rid = len(c['message_dict']) - 1
 501     else:
 502         rid = c['message_dict'].index(m['id'])
 503     id = str(rid)
 504     # Print meta
 505     formater = ''
 506     try:
 507         virtual_meta = formater = c['THREAD_META_RIGHT']
 508         virtual_meta = clock.join(virtual_meta.split('#clock'))
 509         virtual_meta = id.join(virtual_meta.split('#id'))
 510         # Change clock word
 511         word = [wo for wo in formater.split() if '#clock' in wo][0]
 512         delimiter = color_func(c['MESSAGE']['clock'])(
 513             clock.join(word.split('#clock')))
 514         formater = delimiter.join(formater.split(word))
 515         # Change id word
 516         word = [wo for wo in formater.split() if '#id' in wo][0]
 517         delimiter = color_func(c['MESSAGE']['id'])(id.join(word.split('#id')))
 518         formater = delimiter.join(formater.split(word))
 519         formater = emojize(formater)
 520     except Exception:
 521         printNicely(red('Wrong format in config.'))
 522         return
 523     meta = formater
 524     line = ' ' * (w - len(virtual_meta) - dg['frame_margin']) + meta
 525     printNicely(line)
 526
 527
 528 def print_left_message(m):
 529     """
 530     Print a message on the left of screen
 531     """
 532     h, w = os.popen('stty size', 'r').read().split()
 533     w = int(w)
 534     frame_width = w // 3 - dg['frame_margin']
 535     frame_width = max(c['THREAD_MIN_WIDTH'], frame_width)
 536     step = frame_width - 2 * dg['frame_margin']
 537     slicing = textwrap.wrap(m['text'], step)
 538     spaces = dg['frame_margin']
 539     dotline = ' ' * spaces + '-' * frame_width
 540     dotline = color_func(c['MESSAGE']['partner_frame'])(dotline)
 541     # Draw the frame
 542     printNicely(dotline)
 543     for line in slicing:
 544         fill = step - len(line)
 545         screen_line = ' ' + line + ' ' * fill + ' |'
 546         if slicing[-1] == line:
 547             screen_line = ' ' * (spaces - 1) + '< ' + screen_line
 548         else:
 549             screen_line = ' ' * spaces + '|' + screen_line
 550         screen_line = color_func(c['MESSAGE']['partner_frame'])(screen_line)
 551         printNicely(screen_line)
 552     printNicely(dotline)
 553     # Format clock
 554     date = parser.parse(m['created_at'])
 555     date = arrow.get(date).to('local').datetime
 556     clock_format = '%Y/%m/%d %H:%M:%S'
 557     try:
 558         clock_format = c['FORMAT']['MESSAGE']['CLOCK_FORMAT']
 559     except:
 560         pass
 561     clock = date.strftime(clock_format)
 562     # Format id
 563     if m['id'] not in c['message_dict']:
 564         c['message_dict'].append(m['id'])
 565         rid = len(c['message_dict']) - 1
 566     else:
 567         rid = c['message_dict'].index(m['id'])
 568     id = str(rid)
 569     # Print meta
 570     formater = ''
 571     try:
 572         virtual_meta = formater = c['THREAD_META_LEFT']
 573         virtual_meta = clock.join(virtual_meta.split('#clock'))
 574         virtual_meta = id.join(virtual_meta.split('#id'))
 575         # Change clock word
 576         word = [wo for wo in formater.split() if '#clock' in wo][0]
 577         delimiter = color_func(c['MESSAGE']['clock'])(
 578             clock.join(word.split('#clock')))
 579         formater = delimiter.join(formater.split(word))
 580         # Change id word
 581         word = [wo for wo in formater.split() if '#id' in wo][0]
 582         delimiter = color_func(c['MESSAGE']['id'])(id.join(word.split('#id')))
 583         formater = delimiter.join(formater.split(word))
 584         formater = emojize(formater)
 585     except Exception:
 586         printNicely(red('Wrong format in config.'))
 587         return
 588     meta = formater
 589     line = ' ' * dg['frame_margin'] + meta
 590     printNicely(line)
 591
 592
 593 def print_message(m):
 594     """
 595     Print direct message
 596     """
 597     # Retrieve message
 598     sender_screen_name = '@' + m['sender_screen_name']
 599     sender_name = m['sender_name']
 600     text = unescape(m['text'])
 601     recipient_screen_name = '@' + m['recipient_screen_name']
 602     recipient_name = m['recipient_name']
 603     mid = m['id']
 604     date = parser.parse(m['created_at'])
 605     date = arrow.get(date).to('local').datetime
 606     clock_format = '%Y/%m/%d %H:%M:%S'
 607     try:
 608         clock_format = c['FORMAT']['MESSAGE']['CLOCK_FORMAT']
 609     except:
 610         pass
 611     clock = date.strftime(clock_format)
 612
 613     # Get rainbow id
 614     if mid not in c['message_dict']:
 615         c['message_dict'].append(mid)
 616         rid = len(c['message_dict']) - 1
 617     else:
 618         rid = c['message_dict'].index(mid)
 619
 620     # Draw
 621     sender_name = cycle_color(sender_name)
 622     sender_nick = color_func(c['MESSAGE']['sender'])(sender_screen_name)
 623     recipient_name = cycle_color(recipient_name)
 624     recipient_nick = color_func(
 625         c['MESSAGE']['recipient'])(recipient_screen_name)
 626     to = color_func(c['MESSAGE']['to'])('>>>')
 627     clock = clock
 628     id = str(rid)
 629
 630     text = ''.join(lmap(lambda x: x + '  ' if x == '\n' else x, text))
 631
 632     # Load config formater
 633     try:
 634         formater = c['FORMAT']['MESSAGE']['DISPLAY']
 635         formater = sender_name.join(formater.split("#sender_name"))
 636         formater = sender_nick.join(formater.split("#sender_nick"))
 637         formater = to.join(formater.split("#to"))
 638         formater = recipient_name.join(formater.split("#recipient_name"))
 639         formater = recipient_nick.join(formater.split("#recipient_nick"))
 640         formater = text.join(formater.split("#message"))
 641         # Change clock word
 642         word = [wo for wo in formater.split() if '#clock' in wo][0]
 643         delimiter = color_func(c['MESSAGE']['clock'])(
 644             clock.join(word.split('#clock')))
 645         formater = delimiter.join(formater.split(word))
 646         # Change id word
 647         word = [wo for wo in formater.split() if '#id' in wo][0]
 648         delimiter = color_func(c['MESSAGE']['id'])(id.join(word.split('#id')))
 649         formater = delimiter.join(formater.split(word))
 650         formater = emojize(formater)
 651     except:
 652         printNicely(red('Wrong format in config.'))
 653         return
 654
 655     # Draw
 656     printNicely(formater)
 657
 658
 659 def notify_retweet(t):
 660     """
 661     Notify a retweet
 662     """
 663     source = t['user']
 664     created_at = t['created_at']
 665     # Format
 666     source_user = cycle_color(source['name']) + \
 667         color_func(c['NOTIFICATION']['source_nick'])(
 668         ' @' + source['screen_name'])
 669     notify = color_func(c['NOTIFICATION']['notify'])(
 670         'retweeted your tweet')
 671     date = parser.parse(created_at)
 672     clock = fallback_humanize(date)
 673     clock = color_func(c['NOTIFICATION']['clock'])(clock)
 674     meta = c['NOTIFY_FORMAT']
 675     meta = source_user.join(meta.split('#source_user'))
 676     meta = notify.join(meta.split('#notify'))
 677     meta = clock.join(meta.split('#clock'))
 678     meta = emojize(meta)
 679     # Output
 680     printNicely('')
 681     printNicely(meta)
 682     draw(t=t['retweeted_status'], noti=True)
 683
 684
 685 def notify_favorite(e):
 686     """
 687     Notify a favorite event
 688     """
 689     # Retrieve info
 690     target = e['target']
 691     if target['screen_name'] != c['original_name']:
 692         return
 693     source = e['source']
 694     target_object = e['target_object']
 695     created_at = e['created_at']
 696     # Format
 697     source_user = cycle_color(source['name']) + \
 698         color_func(c['NOTIFICATION']['source_nick'])(
 699         ' @' + source['screen_name'])
 700     notify = color_func(c['NOTIFICATION']['notify'])(
 701         'favorited your tweet')
 702     date = parser.parse(created_at)
 703     clock = fallback_humanize(date)
 704     clock = color_func(c['NOTIFICATION']['clock'])(clock)
 705     meta = c['NOTIFY_FORMAT']
 706     meta = source_user.join(meta.split('#source_user'))
 707     meta = notify.join(meta.split('#notify'))
 708     meta = clock.join(meta.split('#clock'))
 709     meta = emojize(meta)
 710     # Output
 711     printNicely('')
 712     printNicely(meta)
 713     draw(t=target_object, noti=True)
 714
 715
 716 def notify_unfavorite(e):
 717     """
 718     Notify a unfavorite event
 719     """
 720     # Retrieve info
 721     target = e['target']
 722     if target['screen_name'] != c['original_name']:
 723         return
 724     source = e['source']
 725     target_object = e['target_object']
 726     created_at = e['created_at']
 727     # Format
 728     source_user = cycle_color(source['name']) + \
 729         color_func(c['NOTIFICATION']['source_nick'])(
 730         ' @' + source['screen_name'])
 731     notify = color_func(c['NOTIFICATION']['notify'])(
 732         'unfavorited your tweet')
 733     date = parser.parse(created_at)
 734     clock = fallback_humanize(date)
 735     clock = color_func(c['NOTIFICATION']['clock'])(clock)
 736     meta = c['NOTIFY_FORMAT']
 737     meta = source_user.join(meta.split('#source_user'))
 738     meta = notify.join(meta.split('#notify'))
 739     meta = clock.join(meta.split('#clock'))
 740     meta = emojize(meta)
 741     # Output
 742     printNicely('')
 743     printNicely(meta)
 744     draw(t=target_object, noti=True)
 745
 746
 747 def notify_follow(e):
 748     """
 749     Notify a follow event
 750     """
 751     # Retrieve info
 752     target = e['target']
 753     if target['screen_name'] != c['original_name']:
 754         return
 755     source = e['source']
 756     created_at = e['created_at']
 757     # Format
 758     source_user = cycle_color(source['name']) + \
 759         color_func(c['NOTIFICATION']['source_nick'])(
 760         ' @' + source['screen_name'])
 761     notify = color_func(c['NOTIFICATION']['notify'])(
 762         'followed you')
 763     date = parser.parse(created_at)
 764     clock = fallback_humanize(date)
 765     clock = color_func(c['NOTIFICATION']['clock'])(clock)
 766     meta = c['NOTIFY_FORMAT']
 767     meta = source_user.join(meta.split('#source_user'))
 768     meta = notify.join(meta.split('#notify'))
 769     meta = clock.join(meta.split('#clock'))
 770     meta = emojize(meta)
 771     # Output
 772     printNicely('')
 773     printNicely(meta)
 774
 775
 776 def notify_list_member_added(e):
 777     """
 778     Notify a list_member_added event
 779     """
 780     # Retrieve info
 781     target = e['target']
 782     if target['screen_name'] != c['original_name']:
 783         return
 784     source = e['source']
 785     target_object = [e['target_object']]  # list of Twitter list
 786     created_at = e['created_at']
 787     # Format
 788     source_user = cycle_color(source['name']) + \
 789         color_func(c['NOTIFICATION']['source_nick'])(
 790         ' @' + source['screen_name'])
 791     notify = color_func(c['NOTIFICATION']['notify'])(
 792         'added you to a list')
 793     date = parser.parse(created_at)
 794     clock = fallback_humanize(date)
 795     clock = color_func(c['NOTIFICATION']['clock'])(clock)
 796     meta = c['NOTIFY_FORMAT']
 797     meta = source_user.join(meta.split('#source_user'))
 798     meta = notify.join(meta.split('#notify'))
 799     meta = clock.join(meta.split('#clock'))
 800     meta = emojize(meta)
 801     # Output
 802     printNicely('')
 803     printNicely(meta)
 804     print_list(target_object, noti=True)
 805
 806
 807 def notify_list_member_removed(e):
 808     """
 809     Notify a list_member_removed event
 810     """
 811     # Retrieve info
 812     target = e['target']
 813     if target['screen_name'] != c['original_name']:
 814         return
 815     source = e['source']
 816     target_object = [e['target_object']]  # list of Twitter list
 817     created_at = e['created_at']
 818     # Format
 819     source_user = cycle_color(source['name']) + \
 820         color_func(c['NOTIFICATION']['source_nick'])(
 821         ' @' + source['screen_name'])
 822     notify = color_func(c['NOTIFICATION']['notify'])(
 823         'removed you from a list')
 824     date = parser.parse(created_at)
 825     clock = fallback_humanize(date)
 826     clock = color_func(c['NOTIFICATION']['clock'])(clock)
 827     meta = c['NOTIFY_FORMAT']
 828     meta = source_user.join(meta.split('#source_user'))
 829     meta = notify.join(meta.split('#notify'))
 830     meta = clock.join(meta.split('#clock'))
 831     meta = emojize(meta)
 832     # Output
 833     printNicely('')
 834     printNicely(meta)
 835     print_list(target_object, noti=True)
 836
 837
 838 def notify_list_user_subscribed(e):
 839     """
 840     Notify a list_user_subscribed event
 841     """
 842     # Retrieve info
 843     target = e['target']
 844     if target['screen_name'] != c['original_name']:
 845         return
 846     source = e['source']
 847     target_object = [e['target_object']]  # list of Twitter list
 848     created_at = e['created_at']
 849     # Format
 850     source_user = cycle_color(source['name']) + \
 851         color_func(c['NOTIFICATION']['source_nick'])(
 852         ' @' + source['screen_name'])
 853     notify = color_func(c['NOTIFICATION']['notify'])(
 854         'subscribed to your list')
 855     date = parser.parse(created_at)
 856     clock = fallback_humanize(date)
 857     clock = color_func(c['NOTIFICATION']['clock'])(clock)
 858     meta = c['NOTIFY_FORMAT']
 859     meta = source_user.join(meta.split('#source_user'))
 860     meta = notify.join(meta.split('#notify'))
 861     meta = clock.join(meta.split('#clock'))
 862     meta = emojize(meta)
 863     # Output
 864     printNicely('')
 865     printNicely(meta)
 866     print_list(target_object, noti=True)
 867
 868
 869 def notify_list_user_unsubscribed(e):
 870     """
 871     Notify a list_user_unsubscribed event
 872     """
 873     # Retrieve info
 874     target = e['target']
 875     if target['screen_name'] != c['original_name']:
 876         return
 877     source = e['source']
 878     target_object = [e['target_object']]  # list of Twitter list
 879     created_at = e['created_at']
 880     # Format
 881     source_user = cycle_color(source['name']) + \
 882         color_func(c['NOTIFICATION']['source_nick'])(
 883         ' @' + source['screen_name'])
 884     notify = color_func(c['NOTIFICATION']['notify'])(
 885         'unsubscribed from your list')
 886     date = parser.parse(created_at)
 887     clock = fallback_humanize(date)
 888     clock = color_func(c['NOTIFICATION']['clock'])(clock)
 889     meta = c['NOTIFY_FORMAT']
 890     meta = source_user.join(meta.split('#source_user'))
 891     meta = notify.join(meta.split('#notify'))
 892     meta = clock.join(meta.split('#clock'))
 893     meta = emojize(meta)
 894     # Output
 895     printNicely('')
 896     printNicely(meta)
 897     print_list(target_object, noti=True)
 898
 899
 900 def print_event(e):
 901     """
 902     Notify an event
 903     """
 904     event_dict = {
 905         'retweet': notify_retweet,
 906         'favorite': notify_favorite,
 907         'unfavorite': notify_unfavorite,
 908         'follow': notify_follow,
 909         'list_member_added': notify_list_member_added,
 910         'list_member_removed': notify_list_member_removed,
 911         'list_user_subscribed': notify_list_user_subscribed,
 912         'list_user_unsubscribed': notify_list_user_unsubscribed,
 913     }
 914     event_dict.get(e['event'], lambda *args: None)(e)
 915
 916
 917 def show_profile(u):
 918     """
 919     Show a profile
 920     """
 921     # Retrieve info
 922     name = u['name']
 923     screen_name = u['screen_name']
 924     description = u['description']
 925     profile_image_url = u['profile_image_url']
 926     location = u['location']
 927     url = u['url']
 928     created_at = u['created_at']
 929     statuses_count = u['statuses_count']
 930     friends_count = u['friends_count']
 931     followers_count = u['followers_count']
 932
 933     # Create content
 934     statuses_count = color_func(
 935         c['PROFILE']['statuses_count'])(
 936         str(statuses_count) +
 937         ' tweets')
 938     friends_count = color_func(
 939         c['PROFILE']['friends_count'])(
 940         str(friends_count) +
 941         ' following')
 942     followers_count = color_func(
 943         c['PROFILE']['followers_count'])(
 944         str(followers_count) +
 945         ' followers')
 946     count = statuses_count + '  ' + friends_count + '  ' + followers_count
 947     user = cycle_color(
 948         name) + color_func(c['PROFILE']['nick'])(' @' + screen_name + ' : ') + count
 949     profile_image_raw_url = 'Profile photo: ' + \
 950         color_func(c['PROFILE']['profile_image_url'])(profile_image_url)
 951     description = ''.join(
 952         lmap(lambda x: x + ' ' * 4 if x == '\n' else x, description))
 953     description = color_func(c['PROFILE']['description'])(description)
 954     location = 'Location : ' + color_func(c['PROFILE']['location'])(location)
 955     url = 'URL : ' + (color_func(c['PROFILE']['url'])(url) if url else '')
 956     date = parser.parse(created_at)
 957     clock = fallback_humanize(date)
 958     clock = 'Joined ' + color_func(c['PROFILE']['clock'])(clock)
 959
 960     # Format
 961     line1 = u"{u:>{uw}}".format(
 962         u=user,
 963         uw=len(user) + 2,
 964     )
 965     line2 = u"{p:>{pw}}".format(
 966         p=profile_image_raw_url,
 967         pw=len(profile_image_raw_url) + 4,
 968     )
 969     line3 = u"{d:>{dw}}".format(
 970         d=description,
 971         dw=len(description) + 4,
 972     )
 973     line4 = u"{l:>{lw}}".format(
 974         l=location,
 975         lw=len(location) + 4,
 976     )
 977     line5 = u"{u:>{uw}}".format(
 978         u=url,
 979         uw=len(url) + 4,
 980     )
 981     line6 = u"{c:>{cw}}".format(
 982         c=clock,
 983         cw=len(clock) + 4,
 984     )
 985
 986     # Display
 987     printNicely('')
 988     printNicely(line1)
 989     if c['IMAGE_ON_TERM']:
 990         try:
 991             response = requests.get(profile_image_url)
 992             image_to_display(BytesIO(response.content))
 993         except:
 994             pass
 995     else:
 996         printNicely(line2)
 997     for line in [line3, line4, line5, line6]:
 998         printNicely(line)
 999     printNicely('')
1000
1001
1002 def print_trends(trends):
1003     """
1004     Display topics
1005     """
1006     for topic in trends[:c['TREND_MAX']]:
1007         name = topic['name']
1008         url = topic['url']
1009         line = cycle_color(name) + ': ' + color_func(c['TREND']['url'])(url)
1010         printNicely(line)
1011     printNicely('')
1012
1013
1014 def print_list(group, noti=False):
1015     """
1016     Display a list
1017     """
1018     for grp in group:
1019         # Format
1020         name = grp['full_name']
1021         name = color_func(c['GROUP']['name'])(name + ' : ')
1022         member = str(grp['member_count'])
1023         member = color_func(c['GROUP']['member'])(member + ' member')
1024         subscriber = str(grp['subscriber_count'])
1025         subscriber = color_func(
1026             c['GROUP']['subscriber'])(
1027             subscriber +
1028             ' subscriber')
1029         description = grp['description'].strip()
1030         description = color_func(c['GROUP']['description'])(description)
1031         mode = grp['mode']
1032         mode = color_func(c['GROUP']['mode'])('Type: ' + mode)
1033         created_at = grp['created_at']
1034         date = parser.parse(created_at)
1035         clock = fallback_humanize(date)
1036         clock = 'Created at ' + color_func(c['GROUP']['clock'])(clock)
1037
1038         prefix = ' ' * 2
1039         # Add spaces in begining of line if this is inside a notification
1040         if noti:
1041             prefix = ' ' * 2 + prefix
1042         # Create lines
1043         line1 = prefix + name + member + '  ' + subscriber
1044         line2 = prefix + ' ' * 2 + description
1045         line3 = prefix + ' ' * 2 + mode
1046         line4 = prefix + ' ' * 2 + clock
1047
1048         # Display
1049         printNicely('')
1050         printNicely(line1)
1051         printNicely(line2)
1052         printNicely(line3)
1053         printNicely(line4)
1054
1055     if not noti:
1056         printNicely('')
1057
1058
1059 def show_calendar(month, date, rel):
1060     """
1061     Show the calendar in rainbow mode
1062     """
1063     month = random_rainbow(month)
1064     date = ' '.join([cycle_color(i) for i in date.split(' ')])
1065     today = str(int(os.popen('date +\'%d\'').read().strip()))
1066     # Display
1067     printNicely(month)
1068     printNicely(date)
1069     for line in rel:
1070         ary = line.split(' ')
1071         ary = lmap(
1072             lambda x: color_func(c['CAL']['today'])(x)
1073             if x == today
1074             else color_func(c['CAL']['days'])(x),
1075             ary)
1076         printNicely(' '.join(ary))
1077
1078
1079 def format_quote(tweet):
1080     """
1081     Quoting format
1082     """
1083     # Retrieve info
1084     screen_name = tweet['user']['screen_name']
1085     text = get_full_text(tweet)
1086     tid         = str( tweet['id'] )
1087
1088     # Validate quote format
1089     if '#owner' not in c['QUOTE_FORMAT']:
1090         printNicely(light_magenta('Quote should contains #owner'))
1091         return False
1092     if '#comment' not in c['QUOTE_FORMAT']:
1093         printNicely(light_magenta('Quote format should have #comment'))
1094         return False
1095
1096     # Build formater
1097     formater = ''
1098     try:
1099         formater = c['QUOTE_FORMAT']
1100
1101         formater = formater.replace('#owner', screen_name)
1102         formater = formater.replace('#tweet', text)
1103         formater = formater.replace('#tid',   tid)
1104
1105         formater = emojize(formater)
1106     except:
1107         pass
1108     # Highlight like a tweet
1109     notice = formater.split()
1110     notice = lmap(
1111         lambda x: light_green(x)
1112         if x == '#comment'
1113         else x,
1114         notice)
1115     notice = lmap(
1116         lambda x: color_func(c['TWEET']['rt'])(x)
1117         if x == 'RT'
1118         else x,
1119         notice)
1120     notice = lmap(lambda x: cycle_color(x) if x[0] == '@' else x, notice)
1121     notice = lmap(
1122         lambda x: color_func(c['TWEET']['link'])(x)
1123         if x[0:4] == 'http'
1124         else x,
1125         notice)
1126     notice = lmap(
1127         lambda x: color_func(c['TWEET']['hashtag'])(x)
1128         if x.startswith('#')
1129         else x,
1130         notice)
1131     notice = ' '.join(notice)
1132     # Notice
1133     notice = light_magenta('Quoting: "') + notice + light_magenta('"')
1134     printNicely(notice)
1135     return formater
1136
1137
1138 # Start the color cycle
1139 start_cycle()