Pcc25 (#51)

* init commit

* rename

* api / data retrieving / storage done

* first version

Author: bbelderbos

25/bbelderbos/.gitignore

@@ -0,0 +1,7 @@
+**sqlite
+**pkl
+**log
+**swp
+**pyc
+**.shelve*
+web

25/bbelderbos/main.py

@@ -0,0 +1,44 @@
+from collections import defaultdict
+from datetime import datetime
+import shelve
+
+from themoviedb import Movies, Tv, CACHE
+from notifications import generate_mail_msg, mail_msg
+
+SENT_CACHE = 'sent.shelve'
+
+language = 'en'
+num_pages = 3
+
+
+def update_store():
+    mo = Movies()
+    mo.get_now_playing()
+    mo.get_upcoming()
+    tv = Tv()
+    tv.get_on_the_air()
+    tv.get_popular()
+
+
+def load_store():
+    items = defaultdict(lambda: defaultdict(list))
+
+    with shelve.open(CACHE) as sh, shelve.open(SENT_CACHE) as ca:
+        for key in sh:
+
+            if key in ca:
+                continue
+            ca[key] = datetime.utcnow()
+
+            entry = sh[key]
+            items[entry.kind][entry.listing].append(
+                entry)
+
+        return items
+
+
+if __name__ == '__main__':
+    update_store()
+    items = load_store()
+    content = generate_mail_msg(items)
+    mail_msg(content)

25/bbelderbos/notifications/__init__.py

@@ -0,0 +1 @@
+from .mail import generate_mail_msg, mail_msg

25/bbelderbos/notifications/mail.py

@@ -0,0 +1,81 @@
+from datetime import datetime
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+import os
+import smtplib
+import sys
+
+from themoviedb import get_genres_cache
+
+BASE_IMG_URL = 'http://image.tmdb.org/t/p/w92{}'
+BASE_MOVIE_URL = 'https://www.themoviedb.org/{}/{}'
+SUBJECT = 'Movies / Series Digest'
+GENRES = get_genres_cache()
+
+FROM_MAIL = os.environ.get('FROM_MAIL')
+TO_MAIL = os.environ.get('TO_MAIL')
+
+if not FROM_MAIL or not TO_MAIL:
+    print('set FROM_MAIL and TO_MAIL in env')
+    sys.exit(1)
+
+# TODO: retrieve director and actors
+TEMPLATE = '''<h4><a href="{link}">{title}</a></h4>
+              <p>Overview: {overview}
+              <img src="{img}" style="float: right;"></p>
+              <p>Genres: {genres} / (first) release: {release}</p>
+              <hr>
+            '''
+
+
+def generate_mail_msg(items):
+    output = []
+
+    for kind in items:
+        output.append('<h2>{}</h2>'.format(kind))
+
+        for listing, entries in items[kind].items():
+            output.append('<h3>{}</h3>'.format(listing))
+
+            if not entries:
+                output.append('No new items')
+                continue
+
+            for entry in sorted(entries,
+                                key=lambda x: datetime.strptime(
+                                              x.release_date, '%Y-%m-%d'),
+                                reverse=True):
+
+                img = BASE_IMG_URL.format(entry.poster)
+                kind_for_url = kind.replace('movies', 'movie')
+                url = BASE_MOVIE_URL.format(kind_for_url, entry.id)
+                genres = ', '.join([GENRES.get(gen) for gen in entry.genres
+                                    if GENRES.get(gen)])
+
+                output.append(TEMPLATE.format(link=url,
+                                              title=entry.title,
+                                              overview=entry.overview,
+                                              img=img,
+                                              genres=genres,
+                                              release=entry.release_date))
+
+    return '\n'.join(output)
+
+
+def mail_msg(content, recipients=TO_MAIL, subject=SUBJECT):
+    if isinstance(recipients, list):
+        recipients = ', '.join(recipients)
+
+    sender = FROM_MAIL
+
+    msg = MIMEMultipart('alternative')
+    msg['Subject'] = subject
+    msg['From'] = sender
+    msg['To'] = recipients
+
+    part = MIMEText(content, 'html')
+    msg.attach(part)
+
+    s = smtplib.SMTP('localhost')
+    s.sendmail(sender, recipients, msg.as_string())
+    s.quit()

25/bbelderbos/themoviedb/__init__.py

@@ -0,0 +1,3 @@
+from .tmdb_api import Movies, Tv
+from .genres import get_genres_cache
+from .decorators import CACHE

25/bbelderbos/themoviedb/decorators.py

@@ -0,0 +1,73 @@
+from collections import namedtuple
+from functools import wraps
+import re
+import shelve
+
+CACHE = 'items.shelve'
+DEFAULT_OVERWRITE = True
+
+Item = namedtuple('Item', 'id kind listing title genres overview release_date poster')  # noqa E501
+
+
+def _get_title(item):
+    # movies API uses 'title', series API uses 'name'
+    title = item.get('title')
+
+    if not title:
+        title = item.get('name')
+
+    return title
+
+
+def _get_release_date(item):
+    # movies API uses 'release_date', series API uses 'first_air_date'
+    release_date = item.get('release_date')
+
+    if not release_date:
+        release_date = item.get('first_air_date')
+
+    return release_date
+
+
+def _store(kind, listing, resp, overwrite=DEFAULT_OVERWRITE):
+    with shelve.open(CACHE) as sh:
+        for item in resp:
+            key = str(item['id'])
+
+            if overwrite and key in sh:
+                del sh[key]
+
+            title = _get_title(item)
+            if not title:
+                continue
+
+            release_date = _get_release_date(item)
+            if not release_date:
+                continue
+
+            item = Item(id=item['id'],
+                        kind=kind,
+                        listing=listing,
+                        title=title,
+                        genres=item['genre_ids'],
+                        overview=item['overview'],
+                        release_date=release_date,
+                        poster=item['poster_path'])
+
+            sh[key] = item
+
+
+def store_results(f):
+    @wraps(f)
+    def wrapped(*args, **kwargs):
+        class_name = str(args[0]).lower()
+        kind = re.sub(r'.*\.(\S+)\sobject.*', r'\1', class_name)
+        print(kind)
+        func_name = str(args[1]).lower()
+        listing = re.sub(r'.*bound.*?\.(\S+) of.*', r'\1', func_name)
+        print(listing)
+        resp = f(*args, **kwargs)
+        _store(kind, listing, resp)
+        print(len(resp))
+        return resp
+    return wrapped

25/bbelderbos/themoviedb/genres.py

@@ -0,0 +1,35 @@
+import os
+import pickle
+
+from .tmdb_init import tmdb
+
+CACHE = 'genres.pkl'
+
+
+def cache_genres():
+    gen = tmdb.Genres()
+    genres = gen.list()
+
+    genres = {g['id']: g['name'] for g in genres['genres']}
+
+    with open(CACHE, 'wb') as f:
+        pickle.dump(genres, f)
+
+
+def get_genres_cache():
+    if not os.path.isfile(CACHE):
+        print('Cache file not found, generating one')
+        cache_genres()
+
+    with open(CACHE, 'rb') as f:
+        return pickle.load(f)
+
+
+if __name__ == '__main__':
+    if os.path.isfile(CACHE):
+        os.remove(CACHE)
+
+    genres = get_genres_cache()
+
+    from pprint import pprint as pp
+    pp(genres)

25/bbelderbos/themoviedb/tmdb_api.py

@@ -0,0 +1,77 @@
+import time
+
+from .tmdb_init import tmdb
+from .decorators import store_results
+
+DEFAULT_LANG = 'en'
+DEFAULT_NUM_PAGES = 2
+DEFAULT_MIN_VOTE_COUNT = 1
+
+
+class Tmdb:
+
+    def __init__(self, language=None, num_pages=None, min_vote_count=None):
+        self.language = language or DEFAULT_LANG
+        self.num_pages = num_pages or DEFAULT_NUM_PAGES
+        self.min_vote_count = min_vote_count or DEFAULT_MIN_VOTE_COUNT
+
+    @store_results
+    def get_items(self, obj_method):
+        results = []
+
+        for i in range(self.num_pages):
+            page = i + 1
+
+            num_tries = 0
+            resp = None
+
+            while num_tries < 3:
+                try:
+                    resp = obj_method(language=self.language,
+                                      page=page)
+                    break
+                except:
+                    num_tries += 1
+                    continue
+
+            if not resp or 'results' not in resp:
+                continue
+
+            results += [r for r in resp['results']
+                        if r['vote_count'] > self.min_vote_count]
+
+            time.sleep(1)
+
+        return results
+
+
+class Movies(Tmdb):
+
+    def __init__(self, language=None, num_pages=None):
+        super().__init__(language, num_pages)
+        self.movies = tmdb.Movies()
+
+    def get_now_playing(self):
+        return self.get_items(self.movies.now_playing)
+
+    def get_upcoming(self):
+        return self.get_items(self.movies.upcoming)
+
+
+class Tv(Tmdb):
+
+    def __init__(self, language=None, num_pages=None):
+        super().__init__(language, num_pages)
+        self.tv = tmdb.TV()
+
+    def get_popular(self):
+        return self.get_items(self.tv.popular)
+
+    def get_on_the_air(self):
+        return self.get_items(self.tv.on_the_air)
+
+
+if __name__ == '__main__':
+    mo = Movies('en', 3)
+    resp = mo.get_now_playing()
+    print(len(resp))

25/bbelderbos/themoviedb/tmdb_init.py

@@ -0,0 +1,13 @@
+import os
+import sys
+
+import tmdbsimple as tmdb
+
+key = os.environ.get('THE_MOVIE_DB_API_KEY')
+
+if not key:
+    print('Set themoviedb API_KEY in your env')
+    print('export THE_MOVIE_DB_API_KEY=xyz')
+    sys.exit(1)
+
+tmdb.API_KEY = key