def get_movies(self, new_movies):
"""Search info for movies in new_movies and add them to the db."""
#TODO: implement multi-threaded search for movies
for path, movie_name in new_movies.iteritems():
logging.info("searching for... %s", movie_name.encode('utf-8'))
try:
res = tmdb3.searchMovie(movie_name.encode('utf-8'))
if len(res) == 0:
words = movie_name.split(' ')
strings_to_test = [' '.join(words[0:i]).encode('utf-8') for i in range(len(words), 0, -1)]
i = 1
while len(res) == 0 and i < len(strings_to_test):
logging.info("searching for... %s", strings_to_test[i])
res = tmdb3.searchMovie(strings_to_test[i])
i += 1
if len(res) == 0:
db_methods.insert_orphan_file(path, movie_name)
else:
db_methods.insert_movie_file(res[0], path, movie_name)
except tmdb3.tmdb_exceptions.TMDBHTTPError as e:
logging.error("HTTP error({0}): {1}".format(e.httperrno, e.response))
db_methods.insert_orphan_file(path, movie_name)
except:
logging.error("Unexpected error: %s", sys.exc_info()[0])
raise
def tmdbFindEm():
from tmdb3 import searchMovie
count = 0
notfound = []
for path in processQueue:
movie = os.path.basename(path)
location = os.path.dirname(path)
filename = movie
if os.path.isfile(movie):
movie = os.path.splitext(movie)[0]
if len(location.replace(GLOBALPATH, '').replace('/', '')) > 0:
movie = location.replace(GLOBALPATH, '').replace('/', '')
res = searchMovie(movie)
if len(res) is 0:
movie = ''.join([c for c in movie if c not in '*-()/\\'])
res = searchMovie(movie)
if len(res) is not 0:
print res[0]
mov = res[0]
if len(mov.youtube_trailers) is not 0:
trailer = mov.youtube_trailers[0].geturl()
else:
trailer = None
if len(str(mov.releasedate)) is not 0:
year = mov.releasedate.year
else:
year = "0000"
movieArr = [
mov.id, mov.title, year, mov.tagline, mov.overview,
mov.runtime, mov.userrating, mov.homepage, trailer, location,
filename
]
addToDB(movieArr)
count += 1
else:
notfound.append(movie)
print "List size: " + str(len(processQueue))
print "Found size: " + str(count)
print "Not found: "
print notfound
processQueue.clear()
def showItem(catalog_name):
'''show catalog's items %s''' % catalog_name
poster = []
user_id = login_session['user_id']
print user_id
catalogs = session.query(Catalog).all()
catalog_id = session.query(Catalog).filter_by(name=catalog_name).first().id
catalog = session.query(Catalog).filter_by(name=catalog_name).one()
# owner = getUserInfo(user_id)
# print owner.name
items = session.query(Item).filter_by(catalog_id=catalog.id).filter_by(
user_id=user_id).all()
if items:
for item in items:
movie = searchMovie(item.name)
poster.append(movie[0].poster.geturl())
else:
print 'NO movies'
if 'username' not in login_session: # owner.id != login_session['user_id']:
return render_template('items.html',
items=items,
catalog=catalog,
catalogs=catalogs,
catalog_name=catalog_name,
x=len(items),
poster=poster)
else:
return render_template('itemsloggedin.html',
items=items,
catalog=catalog,
catalogs=catalogs,
catalog_name=catalog_name,
x=len(items),
poster=poster)
def get_first_mov_url_noyear(moviestr):
movs = searchMovie(moviestr)
try:
movie = movs[0]
except:
return None
if not movie:
return None
movie_id=movie.id
try:
year = movie.releasedate.year
except:
year = ''
title = movie.title
# Error Handling for url-encoding non ascii titles!
try:
title = str(title)
except:
return None
url = '/tmdb-actuarized?' + urlencode(dict(movie_id=movie_id,
movie=title,
year=year))
return url
def searchMovie(query):
max_results = Config['max_results']
log.debug("Searching: %s on themoviedb.com" % query)
try:
search_results = tmdb3.searchMovie(query,
language=Config['language'],
adult=adult)
# paged results, so retrieve them all (max_results)
results = []
for i, result in enumerate(search_results):
log.debug("Search-Result: %s" % result)
results.append(result)
if i >= max_results:
break
except URLError as e:
raise DataRetrievalError(
"Error connecting to themoviedb.com: %s" % e)
# if len(results) == 0:
# raise ShowNotFound(
# "Movie '%s' not found on themoviedb.com"
# % ' '.join(query.split('+')))
try:
return self.__selector.select(force_name or self.movietitle,
results,
candidate_name=operator.attrgetter("title"))
except MatchingDataNotFound:
raise ShowNotFound(
"Movie '%s' not found on themoviedb.com"
% ' '.join(query.split('+')))
def searchMovie(user=None):
term = request.form["term"]
if not term:
return jsonify(response="error", message="Invalid search term"), 404
from tmdb3 import searchMovie
movies = searchMovie(term)
if len(movies) == 0:
return jsonify(response="error", message="No results given"), 404
results = []
limit = 10
for index in range(len(movies)):
movie = movies[index]
if limit <= 0:
break
result = {}
poster = movie.poster
if poster:
sizes = poster.sizes()
if len(sizes) > 0:
result["poster"] = poster.geturl(sizes[0])
result["title"] = movie.title
result["id"] = movie.id
results.append(result)
limit -= 1
return jsonify(response="success", movies=results)
def getinfo(self, film_name):
res = searchMovie(film_name)
title = str(res[0].title)
poster = str(res[0].poster.geturl())
youtube_trailer = str(res.youtube_trailers[0].geturl())
listx = [title, poster, youtube_trailer]
return listx
def searchMovie(user=None):
term = request.form['term']
if not term:
return jsonify(response='error', message='Invalid search term'), 404
from tmdb3 import searchMovie
movies = searchMovie(term)
if len(movies) == 0:
return jsonify(response='error', message='No results given'), 404
results = []
limit = 10
for index in range(len(movies)):
movie = movies[index]
if limit <= 0:
break
result = {}
poster = movie.poster
if poster:
sizes = poster.sizes()
if len(sizes) > 0:
result['poster'] = poster.geturl(sizes[0])
result['title'] = movie.title
result['id'] = movie.id
results.append(result)
limit -= 1
return jsonify(response='success', movies=results)
def searchmovies():
keyword = request.form['search field']
res = searchMovie(keyword)
if len(res) == 0:
return redirect(url_for('noresults'))
else:
return render_template('movies.html', title='Movies', pageActive='movies', movies=res[0:15])
def get_first_mov_url_noyear(moviestr):
movs = searchMovie(moviestr)
try:
movie = movs[0]
except:
return None
if not movie:
return None
movie_id = movie.id
try:
year = movie.releasedate.year
except:
year = ''
title = movie.title
# Error Handling for url-encoding non ascii titles!
try:
title = str(title)
except:
return None
url = '/tmdb-actuarized?' + urlencode(
dict(movie_id=movie_id, movie=title, year=year))
return url
def get_list_by_name(zapros):
set_key('c97c17e619252e35bad2e158d4211fcc')
set_locale('ru', 'ru')
set_cache(engine='file', filename='/home/swasher/kinobox/.tmdb3cache')
results = searchMovie(zapros)
answer=[]
i=0
for movie in results[0:10]:
mov=kino()
#print unicode(results[i])
searchResult = results[i]
mov.id=searchResult.id
mov.title=searchResult.title
mov.year=str(searchResult.releasedate)[0:4]
mov.overview=searchResult.overview
mov.url='http://www.themoviedb.org/movie/'+str(mov.id)
mov.origname=searchResult.originaltitle
try:
mov.altname=searchResult.alternate_titles[0].title
except:
mov.altname=''
try:
mov.poster=searchResult.poster.geturl(size='w154')
except:
mov.poster=''
answer.append(mov)
i+=1
return answer
def fetch_details(self, args):
logging.debug("Fetching with details %s " % args)
title = args["title"]
year = args["year"]
if title is None:
logging.critical("Need a title")
raise RuntimeError("Need a title")
# Keep our temporary cache in /tmp, but one per user
tmdb3.set_cache(filename='tmdb3.' + str(os.getuid()) + '.cache')
# tmdb.set_locale(....) Should be automatic from environment
res = tmdb3.searchMovie(title, year=year)
logging.debug(res)
if len(res) == 0:
logging.error("Could not find any matching movie")
raise LookupError("Could not find match for " + title)
# Assume first match is the best
res0 = res[0]
poster = None
fanart = None
poster = self._get_image_url(res0.poster)
# Want the biggest image by default for fanart
if res0.backdrop:
fanart = res0.backdrop.geturl()
logging.debug("poster=%s fanart=%s title=%s year=%s" %
(poster, fanart, title, year))
return {"poster": poster, "fanart": fanart}
def process_movies(dir):
set_key(API_KEY) #store this key somewhere
set_locale()
dir = expand(dir)
movies = list()
moviesToDisplay = loadfromfile(dir)
if not moviesToDisplay:
moviesToDisplay = list()
titles = list()
for m in moviesToDisplay:
titles.append(m.title)
explore(dir)
for f in fileset:
if f.fulltitle in titles:
continue
result = searchMovie(f.fulltitle)
if len(result) == 0:
if f.filename not in notfound:
notfound.append(f.filename)
print "Couldn't find results for: " + f.fulltitle + " result = " + str(result)
continue
# print "**** Found results for: " + f.fulltitle + " result = " + str(result[0])
movie = result[0] if len(result) > 0 else None
movies.append(movie)
for m in movies:
if not m:
continue
if m.id in movieids:
continue
p = m.poster
if p:
d = DisplayMovie(m, p.geturl('w154'),)
else:
d = DisplayMovie(m, '',)
if m.id in movieids:
continue
pos = bisect.bisect(movieids, m.id)
movieids.insert(pos, m.id)
moviesToDisplay.append(d)
writetofile(dir, moviesToDisplay)
return sorted(moviesToDisplay, key=lambda x: x.movie.title)
def tmdbFindEm():
from tmdb3 import searchMovie
count = 0
notfound = []
for path in processQueue:
movie = os.path.basename(path)
location = os.path.dirname(path)
filename = movie
if os.path.isfile(movie):
movie = os.path.splitext(movie)[0]
if len(location.replace(GLOBALPATH, '').replace('/', '')) > 0:
movie = location.replace(GLOBALPATH, '').replace('/', '')
res = searchMovie(movie)
if len(res) is 0:
movie = ''.join([c for c in movie if c not in '*-()/\\'])
res = searchMovie(movie)
if len(res) is not 0:
print res[0]
mov = res[0]
if len(mov.youtube_trailers) is not 0:
trailer = mov.youtube_trailers[0].geturl()
else:
trailer = None
if len(str(mov.releasedate)) is not 0:
year = mov.releasedate.year
else:
year = "0000"
movieArr = [mov.id, mov.title, year, mov.tagline, mov.overview, mov.runtime, mov.userrating, mov.homepage, trailer, location, filename]
addToDB(movieArr)
count += 1
else:
notfound.append(movie)
print "List size: " + str(len(processQueue))
print "Found size: " + str(count)
print "Not found: "
print notfound
processQueue.clear()
def getMovieInf(movieName):
movie = searchMovie(movieName)
if len(movie):
trailer = movie[0].youtube_trailers[0].geturl()
overview = movie[0].overview
rating = movie[0].userrating
return trailer, overview, rating
return False
def set_poster(self, title_query, video_type):
if video_type is 'MOVIE':
tmdb_id = tmdb3.searchMovie(title_query)[0].id
video = tmdb3.Movie(tmdb_id)
else:
tmdb_id = tmdb3.searchSeries(title_query)[0].id
video = tmdb3.Series(tmdb_id)
self.tmdb_poster = video.poster.geturl('w342')
def getMovies(query):
movies = searchMovie(query)
movieInfo = []
for movie in movies:
movieInfo.append(getMinimalistMovieInfo(movie))
return {'query' : query, 'domain' : 'tmdb', 'movies' : movieInfo}
def searchForMovie(pattern, maxSearch=1): s = searchMovie(pattern) retBuffer = [] for i in range(0, maxSearch): retBuffer.append(s[i]) return retBuffer
def searchMovies(title, year=None):
try:
results = tmdb3.searchMovie(title, year=year, locale=tmdb3.get_locale())
except Exception as e:
print "NOPE: %s - %s" % (e, print_exc())
return 0
if not len(results):
return 0
return results
def return_metadata(actor, genre):
try:
movies = searchMovie(str(genre))
genre_movie = movies[randrange(len(movies))]
featured_actor = searchPerson(str(actor))[0]
except IndexError:
print 'Genre or actor entered is not valid. Please try again'
return None
actor_roles = featured_actor.roles
rand_role = actor_roles[randrange(len(actor_roles))]
actor_movie = searchMovie(str(rand_role).split('\'')[-2])[0]
output = ''
output += str(genre_movie.title) + '\n' + str(actor_movie.title)
output += '\n'
output += genre_movie.overview + '\n' + actor_movie.overview
return output
def insertIntoDB(keyword):
keyword = keyword.lower()
try:
searchResults = tmdb3.searchMovie(keyword)
for searchItem in searchResults:
jsonMovieData = toRecursiveDict(searchItem.__dict__)
jsonMovieData['search_key'] = keyword
movies.insert_one(jsonMovieData)
except pymongo.errors.PyMongoError as e:
print "ERROR: ",e
def insertIntoDB(keyword):
keyword = keyword.lower()
try:
searchResults = tmdb3.searchMovie(keyword)
for searchItem in searchResults:
jsonMovieData = toRecursiveDict(searchItem.__dict__)
jsonMovieData['search_key'] = keyword
movies.insert_one(jsonMovieData)
except pymongo.errors.PyMongoError as e:
print "ERROR: ", e
def return_metadata(actor, genre):
try:
movies = searchMovie(str(genre))
genre_movie = movies[randrange(len(movies))]
featured_actor = searchPerson(str(actor))[0]
except IndexError:
print 'Genre or actor entered is not valid. Please try again'
return None
actor_roles = featured_actor.roles
rand_role = actor_roles[randrange(len(actor_roles))]
actor_movie = searchMovie(str(rand_role).split('\'')[-2])[0]
output = ''
output += str(genre_movie.title) + '\n' + str(actor_movie.title)
output += '\n'
output += genre_movie.overview + '\n' + actor_movie.overview
return output
def movies():
if request.method == 'POST':
keyword = request.form['search field']
res = searchMovie(keyword)
if len(res) == 0:
return redirect(url_for('noresults'))
else:
#return ',,,'.join(m.title for m in res)
return render_template('movies.html', title='Moviesss', pageActive='movies', movies=res)
else:
return render_template('movies.html', title='Moviesss', pageActive='movies')
def tmdb(self):
if self.year:
_movie = '{} ({})'.format(self.title, self.year)
try:
self.review_entries(list(tmdb3.searchMovieWithYear(_movie)))
return
except MovieNotFound:
pass
self.review_entries(list(tmdb3.searchMovie(self.title)))
return self
def test_read_write_cache(self):
# The cache file should not exist at this point
self.assertFalse(isfile(self.cache_file))
# Perform a query, so we force to create the cache file
result = searchMovie('Star Wars', year=1977)
self.assertIsInstance(result, MovieSearchResult)
# The cache file should be created at this point
self.assertTrue(isfile(self.cache_file))
# Here we test the reading of the cache file by requesting some info
movie = [i for i in result if i.title == 'Star Wars'][0]
self.assertEqual(movie.imdb, 'tt0076759')
def search_tmdb_for_movie(title):
"""
Run a search query on the tmdb for `title`.
"""
global options
name, year = name_and_year(title)
if year is not None:
result = tmdb.searchMovieWithYear("%s (%i)" % (name, year))
movies = list(result)
if year is not None:
def year_match(movie):
if movie is None:
return False
else:
if not movie.releasedate:
return False
else:
y = movie.releasedate.year
return y == year or y == year - 1 or y == year + 1
movies = filter(year_match, movies)
else:
result = tmdb.searchMovie(name)
movies = list(result)
if len(movies) == 0:
raise Exception("No movie found: %s" % repr(name))
elif len(movies) > 1:
movies.sort(lambda a, b: cmp(str(a.releasedate), str(b.releasedate)))
print
for idx, movie in enumerate(movies):
present_movie(idx, movie)
print
if options is None or options.choose is None:
print "Enter index [0]:",
i = strip(raw_input())
if i == "":
idx = 0
else:
idx = int(i)
else:
idx = int(options.choose)
else:
idx = 0
return movies[idx]
def search_tmdb_for_movie(title):
"""
Run a search query on the tmdb for `title`.
"""
global options
name, year = name_and_year(title)
if year is not None:
result = tmdb.searchMovieWithYear("%s (%i)" % (name, year))
movies = list(result)
if year is not None:
def year_match(movie):
if movie is None:
return False
else:
if not movie.releasedate:
return False
else:
y = movie.releasedate.year
return y == year or y == year - 1 or y == year + 1
movies = filter(year_match, movies)
else:
result = tmdb.searchMovie(name)
movies = list(result)
if len(movies) == 0:
raise Exception("No movie found: %s" % repr(name))
elif len(movies) > 1:
movies.sort(lambda a, b: cmp(str(a.releasedate), str(b.releasedate)))
print
for idx, movie in enumerate(movies):
present_movie(idx, movie)
print
if options is None or options.choose is None:
print "Enter index [0]:",
i = strip(raw_input())
if i == "":
idx = 0
else:
idx = int(i)
else:
idx = int(options.choose)
else:
idx = 0
return movies[idx]
def tmdbFindOne(path):
from tmdb3 import searchMovie
movie = os.path.basename(path)
location = os.path.dirname(path)
filename = movie
if os.path.isfile(movie):
movie = os.path.splitext(movie)[0]
if len(location.replace(GLOBALPATH, '').replace('/', '')) > 0:
movie = location.replace(GLOBALPATH, '').replace('/', '')
res = searchMovie(movie)
if len(res) is 0:
movie = ''.join([c for c in movie if c not in '*-()/\\'])
res = searchMovie(movie)
if len(res) is not 0:
return res
else:
return None
def tmdbFindOne(path):
from tmdb3 import searchMovie
movie = os.path.basename(path)
location = os.path.dirname(path)
filename = movie
if os.path.isfile(movie):
movie = os.path.splitext(movie)[0]
if len(location.replace(GLOBALPATH, '').replace('/', '')) > 0:
movie = location.replace(GLOBALPATH, '').replace('/', '')
res = searchMovie(movie)
if len(res) is 0:
movie = ''.join([c for c in movie if c not in '*-()/\\'])
res = searchMovie(movie)
if len(res) is not 0:
return res
else:
return None
def __init__(self, title, title_modifier, trailer_modifier):
from tmdb3 import set_key
from tmdb3 import set_cache
from tmdb3 import searchMovie
from tmdb3 import Movie, Collection, Person, Series
set_cache('null')
set_key('a7b2a24af9fbe91fc6003d4d111b3b37')
self.search_results = searchMovie(
title
) #self.search_results is a list returned by the searchMovie function after passing in the title variable.
self.video_id = self.search_results[
title_modifier].id # to use any of the provided methods from tmdb3 we need to get the movie's ID.
self.title = Movie(
self.video_id).title # method to return movies title.
def movieSearchEndpoint(movie): search = searchMovie(movie) start = 0 while True: if 0 == len(search): return "No matches found\n" maxSearch = getSearchLength(search[start:]) + start retBuffer = '' for i in range(start, maxSearch): retBuffer = retBuffer + str(search[i].id) + '. ' + search[i].title + "\n" return retBuffer
def main():
setLocale('de')
tmdb3 = init_tmdb3()
res = tmdb3.searchMovie('James Bond 007 - Skyfall')
print(res)
movie = res[0]
print(movie.title)
print(movie.releasedate.year)
print(movie.overview)
for p in movie.poster_urls:
print(p)
for p in movie.posters:
print(p)
for p in movie.backdrops:
print(p)
p = movie.poster
print(p)
print(p.sizes())
print(p.geturl())
print(p.geturl('w185'))
p = movie.backdrop
print(p)
print(p.sizes())
print(p.geturl())
print(p.geturl('w300'))
crew = [x.name for x in movie.crew if x.job == 'Director']
print(crew)
crew = [x.name for x in movie.crew if x.job == 'Author']
print(crew)
crew = [x.name for x in movie.crew if x.job == 'Producer']
print(crew)
crew = [x.name for x in movie.crew if x.job == 'Director of Photography']
print(crew)
crew = [x.name for x in movie.crew if x.job == 'Editor']
print(crew)
crew = [x.name for x in movie.crew if x.job == 'Production Design']
print(crew)
cast = [x.name for x in movie.cast]
print(cast)
genres = [x.name for x in movie.genres]
print(genres)
studios = [x.name for x in movie.studios]
print(studios)
countries = [x.name for x in movie.countries]
print(countries)
def cerca():
if request.method == 'POST':
mid = int(request.form['id']) if 'id' in request.form else 0
fid = int(request.form['fid']) if 'fid' in request.form else 0
query = request.form['query'] if 'query' in request.form else ""
try:
init_tmdb()
resplist = tmdb3.searchMovie(query.encode('utf-8'))
res = [Movie.from_tmdb(the_movie, False) for the_movie in resplist]
except tmdb3.tmdb_exceptions.TMDBHTTPError as e:
logging.error("HTTP error({0}): {1}".format(e.httperrno, e.response))
raise MovieDbError("HTTP error({0}): {1}".format(e.httperrno, e.response))
except:
logging.error("Unexpected error: %s", sys.exc_info()[0])
raise MovieDbError("Unexpected error: %s", sys.exc_info()[0])
return render_template("cerca.html", movieid=mid, fileid=fid, results=res)
def get_autocomp_movies(moviestr,n):
movs = searchMovie(moviestr)
movies = []
for movie in movs[0:n+1]:
try:
year = movie.releasedate.year
except:
year = ''
uni_title = movie.title
title = unidecode(uni_title)
movie_id = movie.id
movies.append(dict(value = title,
year = year,
movie_id = movie_id,
label = title + ' --- ({})'.format(year) ))
return json.dumps(movies)
def main():
setLocale('de')
tmdb3 = init_tmdb3()
res = tmdb3.searchMovie('F\xc3\xbcr immer Liebe')
print res
movie = res[0]
print movie.title
print movie.releasedate.year
print movie.overview
for p in movie.posters:
print p
for p in movie.backdrops:
print p
p = movie.poster
print p
print p.sizes()
print p.geturl()
print p.geturl('w185')
p = movie.backdrop
print p
print p.sizes()
print p.geturl()
print p.geturl('w300')
crew = [ x.name for x in movie.crew if x.job == 'Director' ]
print crew
crew = [ x.name for x in movie.crew if x.job == 'Author' ]
print crew
crew = [ x.name for x in movie.crew if x.job == 'Producer' ]
print crew
crew = [ x.name for x in movie.crew if x.job == 'Director of Photography' ]
print crew
crew = [ x.name for x in movie.crew if x.job == 'Editor' ]
print crew
crew = [ x.name for x in movie.crew if x.job == 'Production Design' ]
print crew
cast = [ x.name for x in movie.cast ]
print cast
genres = [ x.name for x in movie.genres ]
print genres
studios = [ x.name for x in movie.studios ]
print studios
countries = [ x.name for x in movie.countries ]
print countries
def main():
setLocale('de')
tmdb3 = init_tmdb3()
res = tmdb3.searchMovie('F\xc3\xbcr immer Liebe')
print res
movie = res[0]
print movie.title
print movie.releasedate.year
print movie.overview
for p in movie.posters:
print p
for p in movie.backdrops:
print p
p = movie.poster
print p
print p.sizes()
print p.geturl()
print p.geturl('w185')
p = movie.backdrop
print p
print p.sizes()
print p.geturl()
print p.geturl('w300')
crew = [ x.name for x in movie.crew if x.job == 'Director' ]
print crew
crew = [ x.name for x in movie.crew if x.job == 'Author' ]
print crew
crew = [ x.name for x in movie.crew if x.job == 'Producer' ]
print crew
crew = [ x.name for x in movie.crew if x.job == 'Director of Photography' ]
print crew
crew = [ x.name for x in movie.crew if x.job == 'Editor' ]
print crew
crew = [ x.name for x in movie.crew if x.job == 'Production Design' ]
print crew
cast = [ x.name for x in movie.cast ]
print cast
genres = [ x.name for x in movie.genres ]
print genres
studios = [ x.name for x in movie.studios ]
print studios
countries = [ x.name for x in movie.countries ]
print countries
def buildList(query, language):
results = searchMovie(query, language)
tree = etree.XML(u'<metadata></metadata>')
mapping = [['runtime', 'runtime'], ['title', 'originaltitle'],
['releasedate', 'releasedate'], ['tagline', 'tagline'],
['description', 'overview'], ['homepage', 'homepage'],
['userrating', 'userrating'], ['popularity', 'popularity']]
for res in results:
m = VideoMetadata()
for i,j in mapping:
setattr(m, i, getattr(res, j))
m.inetref = str(res.id)
m.year = res.releasedate.year
m.images.append({'type':'fanart', 'url':res.backdrop.geturl()})
m.images.append({'type':'coverart', 'url':res.poster.geturl()})
tree.append(m.toXML())
sys.stdout.write(etree.tostring(tree, encoding='UTF-8', pretty_print=True))
sys.exit(0)
def get_autocomp_movies(moviestr, n):
movs = searchMovie(moviestr)
movies = []
for movie in movs[0:n + 1]:
try:
year = movie.releasedate.year
except:
year = ''
uni_title = movie.title
title = unidecode(uni_title)
movie_id = movie.id
movies.append(
dict(value=title,
year=year,
movie_id=movie_id,
label=title + ' --- ({})'.format(year)))
return json.dumps(movies)
def showItem(catalog_name):
'''show catalog's items %s''' % catalog_name
poster = []
catalogs = session.query(Catalog).all()
catalog_id = session.query(Catalog).filter_by(name=catalog_name).first().id
catalog = session.query(Catalog).filter_by(name=catalog_name).one()
items = session.query(Item).filter_by(catalog_id=catalog.id).all()
for item in items:
movie = searchMovie(item.name)
poster.append(movie[0].poster.geturl())
print poster
return render_template('items.html',
items=items,
catalog=catalog,
catalogs=catalogs,
catalog_name=catalog_name,
x=len(items),
poster=poster)
def search(self, q, limit=12):
""" Find movie by name """
if self.isDisabled():
return False
search_string = simplifyString(q)
cache_key = 'tmdb.cache.%s.%s' % (search_string, limit)
results = self.getCache(cache_key)
if not results:
log.debug('Searching for movie: %s', q)
raw = None
try:
raw = tmdb3.searchMovie(search_string)
except:
log.error('Failed searching TMDB for "%s": %s',
(search_string, traceback.format_exc()))
results = []
if raw:
try:
nr = 0
for movie in raw:
results.append(self.parseMovie(movie, extended=False))
nr += 1
if nr == limit:
break
log.info('Found: %s', [
result['titles'][0] + ' (' +
str(result.get('year', 0)) + ')' for result in results
])
self.setCache(cache_key, results)
return results
except SyntaxError as e:
log.error('Failed to parse XML response: %s', e)
return False
return results
def get_movie_list(moviestr, n):
movs = searchMovie(moviestr)
movies = []
for movie in movs[0:n + 1]:
movie_id = movie.id
try:
year = movie.releasedate.year
except:
year = ''
title = movie.title
# Error Handling for url-encoding non ascii titles!
try:
title = str(title)
except:
continue
url = '/tmdb-actuarized?' + urlencode(
dict(movie_id=movie_id, movie=title, year=year))
movies.append((title, year, url))
return movies
def search(self, q, limit=12):
""" Find movie by name """
if self.isDisabled():
return False
search_string = simplifyString(q)
cache_key = "tmdb.cache.%s.%s" % (search_string, limit)
results = self.getCache(cache_key)
if not results:
log.debug("Searching for movie: %s", q)
raw = None
try:
raw = tmdb3.searchMovie(search_string)
except:
log.error('Failed searching TMDB for "%s": %s', (search_string, traceback.format_exc()))
results = []
if raw:
try:
nr = 0
for movie in raw:
results.append(self.parseMovie(movie, extended=False))
nr += 1
if nr == limit:
break
log.info(
"Found: %s",
[result["titles"][0] + " (" + str(result.get("year", 0)) + ")" for result in results],
)
self.setCache(cache_key, results)
return results
except SyntaxError as e:
log.error("Failed to parse XML response: %s", e)
return False
return results
def get_movie_list(moviestr,n):
movs = searchMovie(moviestr)
movies = []
for movie in movs[0:n+1]:
movie_id=movie.id
try:
year = movie.releasedate.year
except:
year = ''
title = movie.title
# Error Handling for url-encoding non ascii titles!
try:
title = str(title)
except:
continue
url = '/tmdb-actuarized?' + urlencode(dict(movie_id=movie_id,
movie=title,
year=year))
movies.append((title,year,url))
return movies
def showItem(catalog_name):
poster = []
catalogs = session.query(Catalog).all()
catalog_id = session.query(Catalog).filter_by(name=catalog_name).first().id
catalog = session.query(Catalog).filter_by(name=catalog_name).one()
# Check if the user in login session
# return the movies thay belong to each user
if 'user_id' in login_session:
user_id = login_session['user_id']
items = (session.query(Item).filter_by(
catalog_id=catalog.id).filter_by(user_id=user_id).all())
# If not just return the puplic items
else:
items = (session.query(Item).filter_by(catalog_id=catalog.id).all())
# To avoid errors check if thier items found
# get the movie info and create a list of poster
# pass this poster list to template to display it
if items:
for item in items:
movie = searchMovie(item.name)
poster.append(movie[0].poster.geturl())
if 'username' not in login_session:
return render_template('items.html',
items=items,
catalog=catalog,
catalogs=catalogs,
catalog_name=catalog_name,
x=len(items),
poster=poster)
else:
return render_template('itemsloggedin.html',
items=items,
catalog=catalog,
catalogs=catalogs,
catalog_name=catalog_name,
x=len(items),
poster=poster)
def search(self, q, limit = 12):
""" Find movie by name """
if self.isDisabled():
return False
search_string = simplifyString(q)
cache_key = 'tmdb.cache.%s.%s' % (search_string, limit)
results = self.getCache(cache_key)
if not results:
log.debug('Searching for movie: %s', q)
raw = None
try:
raw = tmdb3.searchMovie(search_string)
except:
log.error('Failed searching TMDB for "%s": %s', (search_string, traceback.format_exc()))
results = []
if raw:
try:
nr = 0
for movie in raw:
results.append(self.parseMovie(movie, with_titles = False))
nr += 1
if nr == limit:
break
log.info('Found: %s', [result['titles'][0] + ' (' + str(result.get('year', 0)) + ')' for result in results])
self.setCache(cache_key, results)
return results
except SyntaxError, e:
log.error('Failed to parse XML response: %s', e)
return False
def get_cast_data(moviestr, year):
movies = searchMovie(moviestr, year=year)
if not movies:
return None
firstmov = movies[0]
cast = firstmov.cast
if not cast:
return None
poster = get_poster(firstmov)
movie_id = firstmov.id
dead = []
alive = []
ages = []
for person in cast:
died = person.dayofdeath
bio = person.biography
if died:
deaddata = get_nm_pic_id(person)
dead.append(deaddata)
continue
born = person.dayofbirth
if not born:
continue
sex = get_sex_from_bio(bio)
if not sex:
continue
livedata = get_nm_pic_id(person)
age = calculate_age(born)
alive.append(livedata)
ages.append(age * sex)
if not ages:
return None
return poster, movie_id, dead, alive, ages
def get_cast_data(moviestr , year):
movies = searchMovie(moviestr, year=year)
if not movies:
return None
firstmov = movies[0]
cast = firstmov.cast
if not cast:
return None
poster = get_poster(firstmov)
movie_id = firstmov.id
dead = []
alive = []
ages = []
for person in cast:
died = person.dayofdeath
bio = person.biography
if died:
deaddata = get_nm_pic_id(person)
dead.append(deaddata)
continue
born = person.dayofbirth
if not born:
continue
sex = get_sex_from_bio(bio)
if not sex:
continue
livedata = get_nm_pic_id(person)
age = calculate_age(born)
alive.append(livedata)
ages.append(age*sex)
if not ages:
return None
return poster,movie_id,dead,alive,ages
def get(self, request):
data = {}
search = request.GET.get('search', '').strip()
if settings.GAME_OF_THRONES:
template = 'got.index.html'
data['houses'] = House.objects.all()
data['selected'] = House.get_selected()
elif search:
template = 'search.html'
res = tmdb3.searchMovie(request.GET['search'])
data['movies'] = [serialize_movie(m) for m in res[:20]]
else:
template = 'start.html'
season = Season.objects.latest()
next = season.next()
data['season'] = season
data['next'] = next
data['booked_by'] = next['user']
return render(request, template, data)
def search():
# Get query from url
query = request.query_string[2:]
if query != '':
try:
# TODO: Catch IO_err
res = searchMovie(query)
movies = []
# Filter results
for i in res:
try:
i.img = i.poster.geturl('w342')
# If YT Trailer, keep the movie
if i.youtube_trailers[0] != None:
i.trailer = i.youtube_trailers[0].geturl()
movies.append(i)
# TODO: Format cast & gernre strings
except:
pass
return render_template('search_results.html', results=movies)
# Catch all other errors
except:
return render_template('search_error.html')
# Handle blank query
elif query == '':
return render_template('search_blank.html')
else:
return render_template('search_error.html')
def _get_first_movie_result(self, title: str, year: str, locale: Locale) -> Union[TMBDMovie, None]:
"""Search the given movie in the DB and use the first result if exists"""
results = searchMovie(title, year=year, locale=locale)
return results[0] if results else None
from tmdb3 import set_key from tmdb3 import searchMovie, searchPerson key = '79f8797f2c2e527e4e396dfe9816a3cd' set_key(key) query = 'Ja' x = searchMovie(query) print(x[0].title)
## PREPARE
args = parse_args()
audioFile = os.path.abspath(args.audioFile)
audioLen = len_audio(args.audioFile) #s
if audioLen < config.finalFrameTime + config.frameTime:
die('Audio not long enough, quitting.')
# audiolen becomes longer the actual length of the audio file but the
# length of audio to fill with backdrop images
audioLen -= config.finalFrameTime + config.fadeInTime
tempDir = tempfile.mkdtemp(prefix="moviepodcastslideshow")
slideshowTextfile = os.path.join(tempDir, 'slideshow.txt')
## GET BACKDROPS
# Find the movie we're looking for
tmdb.set_key(tmdbauth.apiKey)
res = tmdb.searchMovie(args.movieTitle, year=args.year)
if not res:
die('No results found for "' + args.movieTitle + '", qutting.')
# If we're here then we have search results
ourMovie = res[0]
print('Selecting...')
print('<<<', ourMovie.title,
'(' + str(ourMovie.releasedate.year) + ')',
'>>>')
# We have the movie we want now
# Get backdrops urls
backdrops = ourMovie.backdrops
if not backdrops: die('No backdrops found for this film, quitting.')
# Get as many images as needed for our audio length, but no more.
numFramesWanted = int(audioLen / config.frameTime)
# Re-adjust the frame time now that we might be off by some amount less
def test_searchMovie(self):
result = searchMovie('Star Wars', year=1977)
self.assertIsInstance(result, MovieSearchResult)
self.assertGreaterEqual(len(result), 2)
def test_movie(self):
result = searchMovie('Star Wars', year=1977)
movie = [i for i in result if i.title == 'Star Wars'][0]
self.assertIsInstance(movie, Movie)
self.assertEqual(repr(movie), "<Movie 'Star Wars' (1977)>")
self.assertEqual(movie.id, 11)
self.assertEqual(movie.imdb, 'tt0076759')
self.assertEqual(movie.title, 'Star Wars')
self.assertEqual(movie.originaltitle, 'Star Wars')
self.assertEqual(movie.tagline,
'A long time ago in a galaxy far, far away...')
self.assertEqual(
movie.overview,
'Princess Leia is captured and held hostage by the '
'evil Imperial forces in their effort to take over '
'the galactic Empire. Venturesome Luke Skywalker and '
'dashing captain Han Solo team together with the '
'loveable robot duo R2-D2 and C-3PO to rescue the '
'beautiful princess and restore peace and justice in '
'the Empire.')
self.assertEqual(movie.budget, 11000000)
self.assertGreaterEqual(movie.revenue, 775398007)
self.assertEqual(movie.releasedate, date(1977, 5, 25))
self.assertEqual(
movie.homepage, 'http://www.starwars.com/films/'
'star-wars-episode-iv-a-new-hope')
self.assertIsInstance(movie.popularity, float)
self.assertIsInstance(movie.userrating, float)
self.assertIsInstance(movie.votes, int)
self.assertFalse(movie.adult)
self.assertIsInstance(movie.countries, list)
self.assertIsInstance(movie.languages, list)
self.assertIsInstance(movie.poster, Poster)
self.assertTrue(movie.poster.geturl().startswith('http'))
self.assertEqual(
movie.poster.sizes(),
['w92', 'w154', 'w185', 'w342', 'w500', 'w780', 'original'])
self.assertRaises(TMDBImageSizeError, movie.poster.geturl, 'wrong')
self.assertIsInstance(movie.poster.sizes(), list)
self.assertGreater(len(movie.poster.sizes()), 1)
self.assertIsInstance(movie.posters, list)
self.assertIsInstance(movie.posters[0], Poster)
self.assertIsInstance(movie.genres, list)
genre = movie.genres[0]
self.assertIsInstance(genre, Genre)
self.assertEqual(genre.id, 12)
self.assertEqual(genre.name, 'Adventure')
self.assertIsInstance(movie.apple_trailers, list)
self.assertIsInstance(movie.backdrop, Backdrop)
self.assertIsInstance(movie.backdrops, list)
self.assertIsInstance(movie.collection, Collection)
self.assertIsInstance(movie.studios, list)
self.assertIsInstance(movie.studios[0], Studio)
self.assertIsInstance(movie.similar, MovieSearchResult)
import tmdb3 as t # uses https://github.com/wagnerrp/pytmdb3
import pickle
import sys
t.set_key('YOUR API KEY')
b = t.searchMovie('a')
movies = []
for y in range(len(b)):
try:
sys.stdout.write(str(y)+',')
x = b[y]
# we want recent movies
if x.releasedate.year < 1970:
continue
# and movies in English
if 'English' not in [y.name for y in x.languages]:
continue
# and decent movies
if x.releases['US'].certification not in [u'G',u'PG',u'PG-13']:
continue
movie = dict()
movie['title'] = x.title
movie['year'] = x.releasedate.year
movie['date'] = x.releasedate
movie['director'] = [y.name for y in x.crew if y.job == 'Director'][0] or 'Director Unknown'
movie['poster'] = x.poster.geturl('w185')
movie['rating'] = x.userrating
movie['overview'] = x.overview
movies.append(movie)
print len(movies)
except KeyboardInterrupt:
def data_search_movie(query):
movieList = searchMovie(query=query) # TODO remove middle man
return movieList
if len(sys.argv) != 2:
print 'Only one argument is required:'
print ' %s "movie title"' % sys.argv[0]
sys.exit(2)
# This key is taken from the XBMC TMDb scraper
set_key('57983e31fb435df4df77afb854740ea9')
in_encoding = sys.stdin.encoding or sys.getdefaultencoding()
out_encoding = sys.stdout.encoding or sys.getdefaultencoding()
title = unicode(sys.argv[1], in_encoding, 'replace')
print "Retrieving movie \"%s\" from TMDb" % title
res = searchMovie(title)
if len(res) == 0:
print "\"%s\" not found. Try a different one." % title
sys.exit(0)
m = res[0]
print "Retrieving additional information from IMDb"
# Import the tmdb package.
try:
import imdb
except ImportError:
print 'You need to install the imdbpy package!'
sys.exit(1)
