1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
#!/usr/bin/env python2
# coding: utf-8
# python3 works as well
import os
import sys
import re
import dbm
import json
import argparse
import math
try:
import tmdbsimple as tmdb
except ImportError as e:
print(u"Missing dependency: {0}".format(str(e)))
print(u"Install using system package manager or `pip install --user <module>`")
sys.exit(1)
def read_key():
if u"TMDB_KEY" in os.environ.keys():
return os.environ[u"TMDB_KEY"]
if u"XDG_CONFIG_HOME" in os.environ.keys():
cfg_home = os.environ[u"XDG_CONFIG_HOME"]
else:
cfg_home = os.path.join(os.path.expanduser(u"~"), ".config")
if os.path.exists(os.path.join(cfg_home, u"tmdbkey")):
return open(os.path.join(cfg_home, u"tmdbkey"), "r").read().strip()
if os.path.exists(os.path.join(os.path.expanduser(u"~"), ".tmdbkey")):
return open(os.path.join(os.path.expanduser(u"~"), ".tmdbkey")).read().strip()
raise Exception(u"No TheMovieDB Key defined. Set Env. var. TMDB_KEY or .tmdbkey file")
class TMDBCache(object):
def __enter__(self):
self.db = dbm.open(self._get_db_filename(),"c")
return self
def __exit__(self, type, value, traceback):
self.db.close()
def _get_db_filename(self):
if u"XDG_CACHE_HOME" in os.environ.keys():
cachedir = os.environ["XDG_CACHE_HOME"]
else:
cachedir = os.path.join(os.path.expanduser(u"~"), ".cache")
return os.path.join(cachedir, "tmdbmovie.dbm")
def _cache(self, key, callable_func):
if key not in self.db:
self.db[key] = json.dumps(callable_func())
d = self.db[key].decode('utf-8')
return json.loads(d)
def infos(self, movie_id):
try:
return self._cache(movie_id + "movies.info", tmdb.Movies(movie_id).info)
except Exception as e:
raise Exception("Failed to query movie with id {id}: {reason}".format(id=movie_id, reason=str(e)))
def alternative_title(self, movie_id, locale):
"""Returns the title in selected locale or original title otherwise"""
try:
alt_title = list(filter(lambda l: l["iso_3166_1"] == locale,
self._cache(movie_id + "movies.alt_titles", tmdb.Movies(movie_id).alternative_titles)["titles"]))
if alt_title:
return alt_title[0]["title"]
else:
infos = self.infos(movie_id)
return infos["title"] or infos["original_title"]
except Exception as e:
raise Exception("Failed to query movie with id {id}: {reason}".format(id=movie_id, reason=str(e)))
def prune(self, movie_id):
keys = [movie_id + "movies.info", movie_id + "movies.alt_titles"]
for key in keys:
if key in self.db:
print("Remove {}".format(key))
del self.db[key]
def do_aka(args, imdb_ids):
with TMDBCache() as tmdbcache:
for imdb_id in imdb_ids:
print(tmdbcache.alternative_title(imdb_id, locale=args.lang))
def do_data(args, imdb_ids):
with TMDBCache() as tmdbcache:
for imdb_id in imdb_ids:
selected_properties = ["imdb_id", "revenue", "vote_average", "vote_count", "runtime", "budget", "vote_avarage", "release_date", "popularity", ]
kv = map(lambda kv: u"{}={}".format(*kv),
filter(lambda kv: kv[0] in selected_properties,
tmdbcache.infos(imdb_id).items()))
print(u" ".join(kv))
def do_year(args, imdb_ids):
with TMDBCache() as tmdbcache:
for imdb_id in imdb_ids:
print(tmdbcache.infos(imdb_id)["release_date"].split("-")[0])
def do_prune(args, imdb_ids):
with TMDBCache() as tmdbcache:
for imdb_id in imdb_ids:
tmdbcache.prune(imdb_id)
def do_rating(args, imdb_ids):
"""Calculates a rating based on vote_average and vote_count"""
with TMDBCache() as tmdbcache:
infos = list(filter(lambda i: "vote_average" in i and "vote_count" in i,
map(lambda imdb_id: tmdbcache.infos(imdb_id), imdb_ids)))
maxvotes = max(map(lambda i: i["vote_count"], infos))
for info in infos:
f = math.sin(math.pi * ( info["vote_average"]/10.0 ) )
d = (float(info["vote_count"]) / maxvotes) - 0.5
info['rating'] = info["vote_average"] + 2 * d * f
print("{rating:.02f} {imdb_id} {title:30s} avg={vote_average:.1f} count={vote_count:.0f}".format(**info))
class HelpAction(argparse._HelpAction):
def __call__(self, parser, namespace, values, option_string=None):
parser.print_help()
print("")
# retrieve subparsers from parser
subparsers_actions = [
action for action in parser._actions
if isinstance(action, argparse._SubParsersAction)]
# there will probably only be one subparser_action,
# but better save than sorry
for subparsers_action in subparsers_actions:
# get all subparsers and print help
for choice, subparser in subparsers_action.choices.items():
formatter = argparse.HelpFormatter(prog=choice)
print("subcommand {}:".format(choice))
for action_group in subparser._action_groups:
formatter.add_arguments(action_group._group_actions)
print(formatter.format_help())
parser.exit()
if __name__ == u"__main__":
tmdb.API_KEY = read_key()
parser = argparse.ArgumentParser(description="get movie data", add_help=False)
parser.add_argument("--help", action=HelpAction, help="Display full help")
parser.add_argument("-h", action=argparse._HelpAction, help="Display short help")
subparsers = parser.add_subparsers()
parser_aka = subparsers.add_parser("aka", add_help=False)
parser_aka.add_argument("--lang", help="Language code (default 'DE')")
parser_aka.set_defaults(func=do_aka)
parser_aka.add_argument("files", action="append", nargs="+", help="Files containing distinct movie-ids")
parser_data = subparsers.add_parser("data", add_help=False)
parser_data.set_defaults(func=do_data)
parser_data.add_argument("files", action="append", nargs="+", help="Files containing distinct movie-ids")
parser_year = subparsers.add_parser("year", add_help=False)
parser_year.set_defaults(func=do_year)
parser_year.add_argument("files", action="append", nargs="+", help="Files containing distinct movie-ids")
parser_prune = subparsers.add_parser("prune", add_help=False)
parser_prune.set_defaults(func=do_prune)
parser_prune.add_argument("files", action="append", nargs="+", help="Files containing distinct movie-ids")
parser_rating = subparsers.add_parser("rating", add_help=False)
parser_rating.set_defaults(func=do_rating)
parser_rating.add_argument("files", action="append", nargs="+", help="Files containing distinct movie-ids")
args = parser.parse_args(sys.argv[1:])
ids = map(lambda filename: (lambda x: x.groups()[0] if x else None)(re.match(".*#(tt[0-9]{7}).*", filename)),
args.files[0])
args.func(args, filter(lambda i: i is not None, ids))
|
