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