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