def get_all_shows():
tmdb3.set_key(api_key)
tmdb3.set_cache('null')
tmdb3.set_cache(filename='/full/path/to/cache') # the 'file' engine is assumed
tmdb3.set_cache(filename='tmdb3.cache') # relative paths are put in /tmp
tmdb3.set_cache(engine='file', filename='~/.tmdb3cache')
with open(names_file) as f:
content = f.readlines()
show_img_urls = []
for raw in content:
show_name = raw.replace("\n", "")
print show_name
(show, show_seasons, show_episodes) = get_show_data(show_name)
with open(shows_json, 'a') as show_file:
json.dump(show, show_file, sort_keys=True, indent=4, separators=(',', ': '))
show_file.writelines(",\n")
with open(seasons_json, 'a') as season_file:
for show_season in show_seasons:
json.dump(show_season, season_file, sort_keys=True, indent=4, separators=(',', ': '))
season_file.writelines(",\n")
with open(episodes_json, 'a') as episode_file:
for show_episode in show_episodes:
json.dump(show_episode, episode_file, sort_keys=True, indent=4, separators=(',', ': '))
episode_file.writelines(",\n")
show_seasons = None
show_episodes = None
show_img_urls.append((show['name'], show['remote_img_url'], show['img_filename']))
return show_img_urls
def tmdb_info(self):
from tmdb3 import searchSeries, set_cache, set_key, set_locale, get_locale
set_key('587c13e576f991c0a653f783b290a065')
set_cache(filename='/tmp/tmdb3.cache')
set_locale('en', 'us')
_locale = get_locale()
try:
tmdb_results = searchSeries(self.title, first_air_date_year=self.year, locale=_locale)
for _series in tmdb_results:
if self.country:
if not self.country in _series.origin_countries:
continue
if self.year:
if not self.year == _series.first_air_date.year():
continue
if self.title == decode(_series.name):
raise GetOutOfLoop(_series)
raise SeriesNotFound("Series Not Found in TMDb: {}".format(self.title))
except GetOutOfLoop, e:
_series = e.message
alias = {'name': 'title',
'id': 'tmdb_id',
'origin_countries': 'country'}
for key in dir(_series):
if key[:1] == '_': continue
if key in alias: key2 = alias[key]
else: key2 = key
if not hasattr(self, key2):
continue
setattr(self, key2, decode(getattr(_series, key)))
def getMovie(query):
key = '79f8797f2c2e527e4e396dfe9816a3cd'
set_key(key)
#Movie
url = 'https://api.themoviedb.org/3/search/movie?api_key='
url += key
url += '&query=' + query
url += '&include_adult=true'
payload = "{}"
response = requests.request("GET", url, data=payload)
json1_data = json.loads(response.text)
while (1):
try:
results = json1_data['results']
break
except KeyError:
pass
if (len(results) == 0):
return (0, results)
pops = []
results = results[:3]
for i in results:
i = Movie(i['id'])
mx = Movies()
mx.set(movie=i)
pops.append(mx)
return (1, pops)
def main():
set_key('c27cb71cff5bd76e1a7a009380562c62')
parser = OptionParser()
# parser.add_option('-v', "--version", action="store_true", default=False,
# dest="version", help="Display version and author")
parser.add_option('-M', "--movielist", action="store_true", default=False,
dest="movielist", help="Get Movies matching search.")
parser.add_option('-D', "--moviedata", action="store_true", default=False,
dest="moviedata", help="Get Movie data.")
parser.add_option('-C', "--collection", action="store_true", default=False,
dest="collectiondata", help="Get Collection data.")
parser.add_option( "-l", "--language", metavar="LANGUAGE", default=u'en',
dest="language", help="Specify language for filtering.")
opts, args = parser.parse_args()
# if opts.version:
# buildVersion()
if (len(args) != 1) or (args[0] == ''):
sys.stdout.write('ERROR: tmdb3.py requires exactly one non-empty argument')
sys.exit(1)
if opts.movielist:
buildList(args[0], opts.language)
if opts.moviedata:
buildSingle(args[0], opts.language)
if opts.collectiondata:
buildCollection(args[0], opts.language)
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 __init__(self):
addEvent('movie.info', self.getInfo, priority = 3)
addEvent('movie.info_by_tmdb', self.getInfo)
# Configure TMDB settings
tmdb3.set_key(self.conf('api_key'))
tmdb3.set_cache('null')
def __init__(self):
addEvent("movie.info", self.getInfo, priority=3)
addEvent("movie.info_by_tmdb", self.getInfo)
# Configure TMDB settings
tmdb3.set_key(self.conf("api_key"))
tmdb3.set_cache("null")
def __init__(self, args):
if args is None or "key" not in args or args["key"] is None or args[
"key"] == "":
logging.critical("Need a tmdb-key")
raise RuntimeError("Need a tmdb key")
tmdb_key = args["key"]
tmdb3.set_key(tmdb_key)
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 getRecTV(ID):
#TV
key = '79f8797f2c2e527e4e396dfe9816a3cd'
set_key(key)
url = 'https://api.themoviedb.org/3/tv/'
url += str(ID) + '/recommendations?api_key='
url += key
payload = "{}"
response = requests.request("GET", url, data=payload)
json1_data = json.loads(response.text)
while (1):
try:
results = json1_data['results']
break
except KeyError:
pass
results = results[0:2]
pops = []
for i in results:
m = Series(i['id'])
mx = TV()
mx.set(tv=m)
pops.append(mx)
return pops
def __init__(self):
addEvent('movie.search', self.search, priority=2)
addEvent('movie.info', self.getInfo, priority=2)
addEvent('movie.info_by_tmdb', self.getInfo)
# Configure TMDB settings
tmdb3.set_key(self.conf('api_key'))
tmdb3.set_cache('null')
def init_tmdb3(alternative_lang=None):
tmdb3.set_key('1f834eb425728133b9a2c1c0c82980eb')
tmdb3.set_cache('null')
lng = alternative_lang or config.plugins.tmbd.locale.value
try:
tmdb3.set_locale(lng, lng.upper())
except:
tmdb3.set_locale('en', 'GB')
return tmdb3
def __init__(self):
addEvent('movie.info', self.getInfo, priority = 1)
addEvent('movie.info_by_tmdb', self.getInfo)
addEvent('info.search', self.search, priority = 1)
addEvent('movie.search', self.search, priority = 1)
# Configure TMDB settings
tmdb3.set_key(self.conf('api_key'))
tmdb3.set_locale(self.conf('locale', None))
tmdb3.set_cache('null')
def getPopular():
key = '79f8797f2c2e527e4e396dfe9816a3cd'
set_key(key)
#Movie
url = 'https://api.themoviedb.org/3/movie/popular?api_key='
url += key
payload = "{}"
response = requests.request("GET", url, data=payload)
json1_data = json.loads(response.text)
while(1):
try:
results = json1_data['results']
break
except KeyError:
pass
results = results[0:4]
pops = []
for i in results:
m = Movie(i['id'])
mx = Movies()
mx.set(movie=m)
pops.append(mx)
#TV
url = 'https://api.themoviedb.org/3/tv/popular?api_key='
url += key
payload = "{}"
response = requests.request("GET", url, data=payload)
json1_data = json.loads(response.text)
while(1):
try:
results = json1_data['results']
break
except KeyError:
pass
results = results[0:4]
for i in results:
m = Series(i['id'])
mx = TV()
mx.set(tv = m)
pops.append(mx)
return pops
def setUp(self):
set_key(FAKE_API_KEY)
if self.cache_file:
set_cache(filename=self.cache_file)
else:
set_cache(engine='null')
for mock_key in self.mock_requests:
mock_json_file, mock_url = self.mock_data[mock_key]
body = get_json_result(join(LOCALDIR, 'data', mock_json_file))
HTTPretty.register_uri(HTTPretty.GET,
mock_url.format(base_url=self.base_url,
api=self.api_key),
body=body)
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 __init__(self):
log.trace('__init__ method: Started')
super(CleanUp, self).__init__()
trakt_auth_group = DadVision.cmdoptions.parser.add_argument_group("Profiles", description=None)
trakt_auth_group.add_argument("-y", "--grumpy", dest="HostName",
action="append_const", const="grumpy",
help="Entries for Grumpy")
trakt_auth_group.add_argument("-t", "--tigger", dest="HostName",
action="append_const", const="tigger",
help="Entires for Tigger")
trakt_auth_group.add_argument("-g", "--goofy", dest="HostName",
action="append_const", const="goofy",
help="Entries for Goofy")
trakt_auth_group.add_argument("-e", "--eeyore", dest="HostName",
action="append_const", const="eeyore",
help="Entries for Eeore")
trakt_auth_group.add_argument("-p", "--pluto", dest="HostName",
action="append_const", const="pluto",
help="Entries for Pluto")
trakt_options_group = DadVision.cmdoptions.parser.add_argument_group("Options", description=None)
trakt_options_group.add_argument("-c", "--clear", dest="Clear", nargs='*',
action='store', default='None',
help='Clear/Delete all entries in requested area: shows, movies')
trakt_options_group.add_argument("-l", "--list", dest="list", nargs='*',
action='store', default='None',
help='Clear/Delete all entries in requested area: shows, movies')
tmdb3.set_key('587c13e576f991c0a653f783b290a065')
tmdb3.set_cache(filename='tmdb3.cache')
self.db = api.TVDB("959D8E76B796A1FB")
#self.tmdbinfo = TMDBInfo()
self._collectedShows = []
self._watchedShows = []
self._watchlistShows = []
self._trakt_sdtv = []
self._trakt_720P = []
self._trakt_list = []
self.errorLog = []
return
def init_tmdb3():
tmdb3.set_key(config['apikey'])
tmdb3.set_cache('null')
lng = config['locale']
if lng == 'en':
tmdb3.set_locale(lng, 'US')
elif lng == 'el':
tmdb3.set_locale(lng, 'GR')
elif lng == 'cs':
tmdb3.set_locale(lng, 'CZ')
elif lng == 'da':
tmdb3.set_locale(lng, 'DK')
elif lng == 'uk':
tmdb3.set_locale('en', 'GB')
elif lng == 'fy':
tmdb3.set_locale(lng, 'NL')
else:
tmdb3.set_locale(lng, lng.upper())
print('tmdbv3 locale', tmdb3.get_locale())
return tmdb3
def __init__(self, title, title_modifier, trailer_modifier):
Video.__init__(self, title, title_modifier, trailer_modifier)
# was having trouble with inhereting the imported tmbd3 module from class video. So reimported it.
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.tagline = Movie(
self.video_id
).tagline # returns short 'tagline' description of movie.
self.storyline = Movie(
self.video_id).overview # returns longer description of movie.
self.runtime = Movie(self.video_id).runtime # total runtime in minutes
self.poster_image_url = Movie(self.video_id).poster.geturl(
) # returns url of .jpg of the movie poster
self.trailer_youtube_url = Movie(
self.video_id).youtube_trailers[trailer_modifier].geturl(
) # youtube trailer.
self.release_date = Movie(self.video_id).releasedate
def init_tmdb3(alternative_lang=None):
import tmdb3
tmdb3.set_key('1f834eb425728133b9a2c1c0c82980eb')
tmdb3.set_cache('null')
lng = alternative_lang or config.plugins.tmbd.locale.value
if lng == 'en':
tmdb3.set_locale(lng, 'US')
elif lng == 'el':
tmdb3.set_locale(lng, 'GR')
elif lng == 'cs':
tmdb3.set_locale(lng, 'CZ')
elif lng == 'da':
tmdb3.set_locale(lng, 'DK')
elif lng == 'uk':
tmdb3.set_locale('en', 'GB')
elif lng == 'fy':
tmdb3.set_locale(lng, 'NL')
else:
try:
tmdb3.set_locale(lng, lng.upper())
except:
tmdb3 = None
return tmdb3
def init_tmdb3(alternative_lang=None):
import tmdb3
tmdb3.set_key('1f834eb425728133b9a2c1c0c82980eb')
tmdb3.set_cache('null')
lng = alternative_lang or config.plugins.tmbd.locale.value
if lng == 'en':
tmdb3.set_locale(lng, 'US')
elif lng == 'el':
tmdb3.set_locale(lng, 'GR')
elif lng == 'cs':
tmdb3.set_locale(lng, 'CZ')
elif lng == 'da':
tmdb3.set_locale(lng, 'DK')
elif lng == 'uk':
tmdb3.set_locale('en', 'GB')
elif lng == 'fy':
tmdb3.set_locale(lng, 'NL')
else:
try:
tmdb3.set_locale(lng, lng.upper())
except:
tmdb3 = None
return tmdb3
def tmdb_info(self):
from tmdb3 import searchSeries, set_cache, set_key, set_locale, get_locale
set_key('587c13e576f991c0a653f783b290a065')
set_cache(filename='/tmp/tmdb3.cache')
set_locale('en', 'us')
_locale = get_locale()
try:
tmdb_results = searchSeries(self.title,
first_air_date_year=self.year,
locale=_locale)
for _series in tmdb_results:
if self.country:
if not self.country in _series.origin_countries:
continue
if self.year:
if not self.year == _series.first_air_date.year():
continue
if self.title == decode(_series.name):
raise GetOutOfLoop(_series)
raise SeriesNotFound("Series Not Found in TMDb: {}".format(
self.title))
except GetOutOfLoop, e:
_series = e.message
alias = {
'name': 'title',
'id': 'tmdb_id',
'origin_countries': 'country'
}
for key in dir(_series):
if key[:1] == '_': continue
if key in alias: key2 = alias[key]
else: key2 = key
if not hasattr(self, key2):
continue
setattr(self, key2, decode(getattr(_series, key)))
# web serve
import sqlite3
from flask import Flask, request, session, g, redirect, url_for, abort, render_template, flash
app = Flask(__name__)
# database config
DATABASE = os.path.dirname(__file__) + 'moviecat.db'
DEBUG = True
SECRET_KEY = '123omgsecret321'
USERNAME = '******'
PASSWORD = '******'
# movie
from tmdb3 import Movie, set_key
set_key('a158113d4e983474500180058409852c')
def updateGlobalPath():
# get directory and set as GLOBALPATH
cur = g.db.execute('select location from directories where id=1 limit 1')
GLOBALPATH = cur.fetchone()
def recurseIt(path):
# cur = g.db.execute('select id from movies where (filename=? and location=?) limit 1', [os.path.basename(path), os.path.dirname(path)])
# result = cur.fetchone()
# if result is not None:
# return {}
# else:
list = {}
from tmdb3 import set_key
import json
import requests
import os
API = '259f7fc6b26292afaf6ec1dabe6fdd6a'
set_key(API)
from tmdb3 import set_cache
set_cache('null')
set_cache(filename='/full/path/to/cache') # the 'file' engine is assumed
set_cache(filename='tmdb3.cache') # relative paths are put in /tmp
set_cache(engine='file', filename='~/.tmdb3cache')
from tmdb3 import get_locale, set_locale
set_locale()
print(get_locale())
#locale has bet set to english and United States...yes
print
print
'''import urllib2 #import Request#, urlopen headers = {"Accept": "application/json"}
request = urllib2.Request("https://api.themoviedb.org/3/search/movie?api_key="+API+"&query=Foxx")
responsebody = urllib2.urlopen(request).read()
print responsebody
print
print'''
import tmdb3
search = 'Hanks'
a = tmdb3.searchPerson(search)
''' Define Movie class and backend code to get attributes '''
import webbrowser
from tmdb3 import set_key
# change name of imported class to avoid conflict with our class
from tmdb3 import Movie as theMovie
import os
import datetime
# Make sure this is set as an environment variable!
set_key(os.getenv('TMDB_API_KEY'))
# Movie class that takes TMDB ID to initialize,
# and fills in attributes through TMDB lookups
class Movie(object):
def __init__(self, movie_ID):
self.title = theMovie(movie_ID).title
self.tagline = theMovie(movie_ID).tagline
self.release_year = theMovie(movie_ID).releasedate.strftime("%Y")
self.poster_image_url = theMovie(movie_ID).poster.geturl()
self.trailer_youtube_url = theMovie(
movie_ID).youtube_trailers[0].geturl()
def show_trailer(self):
webbrowser.open(self.trailer_youtube_url)
from csv import DictReader
from pprint import pprint
import pickle
from collections import Counter
import json
import tmdb3
RATINGS_PATH = './ratings-dominic.csv'
FILMS_WITH_KEYWORDS_PATH = './films-with-keywords.p'
KEYWORD_MAP_PATH = './keywords.json'
tmdb3.set_key('95a5e0f59034242b05d55145c16a1c35')
class Film(object):
pass
def extract_films_from_ratings_file(path):
with open(path) as f:
reader = DictReader(f)
films = []
for row in reader:
film = Film()
film.imdb_id = row['const']
film.rating = row['You rated']
film.title = row['Title']
films.append(film)
return films
from tmdb3 import set_key
from tmdb3 import get_locale, set_locale
from tmdb3 import set_cache
from tmdb3 import Movie
import collections
import psycopg2
import csv
import tmdbsimple as tmdb
import distance
path="D:\hiwimov\meta_Movies_&_TV.txt"
path1='D:\hiwimov/tempo.txt'
import unicodedata
conn = psycopg2.connect(database="miner", user="******", password="******", host="192.168.32.161", port="5432")
cursor = conn.cursor()
temp = 1.0
set_key('**********')
tmdb.API_KEY = '*********'
set_cache('null')
with open(path,'r') as file:
for i in file:
asin_matches = re.findall("(?<=\"asin\"\: \")[0-9A-Za-z\'\s()-\:\;\.]{1,}",i)
im_url=re.findall('http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', i)
title_matches = re.findall("(?<=\"title\"\: \")[0-9A-Za-z\'\s()\-\:\;\.]{1,}",i)
for title_amazon in title_matches:
for id_amazon in asin_matches:
for url_amazon in im_url:
search = tmdb.Search()
response = search.movie(query=title_amazon)
for s in search.results:
# web serve
import sqlite3
from flask import Flask, request, session, g, redirect, url_for, abort, render_template, flash
app = Flask(__name__)
# database config
DATABASE = os.path.dirname(__file__) + 'moviecat.db'
DEBUG = True
SECRET_KEY = '123omgsecret321'
USERNAME = '******'
PASSWORD = '******'
# movie
from tmdb3 import Movie, set_key
set_key('a158113d4e983474500180058409852c')
def updateGlobalPath():
# get directory and set as GLOBALPATH
cur = g.db.execute('select location from directories where id=1 limit 1')
GLOBALPATH = cur.fetchone()
def recurseIt(path):
# cur = g.db.execute('select id from movies where (filename=? and location=?) limit 1', [os.path.basename(path), os.path.dirname(path)])
# result = cur.fetchone()
# if result is not None:
# return {}
# else:
import re
import tmdb3
import pymongo
import datetime
from urllib2 import Request, urlopen, URLError
api_key='7fb362b555787b7add015e35fcadad84'
tmdb3.set_key(api_key)
client = pymongo.MongoClient('localhost', 27017)
db = client['MoviesDB']
movies = db['Movies']
def findMovieById(mId):
try:
searchResults = movies.find({"_data.id": mId})
#Return searchResults.toList or something equivalent
return list(searchResults)
##for movie in searchResults:
## print movie
"""
request = Request('https://api.themoviedb.org/3/movie/'+mId+'?api_key='+api_key)
movies.insert_one(); ///to be continued"""
except pymongo.errors.PyMongoError as e:
print "ERROR: ",e
def findMovieByKeyword(keyword):
try:
#Use search array
keyword = keyword.lower()
regx = re.compile(keyword, re.IGNORECASE)
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
##
## I have added a copy of the GPL in the file LICENSE
import sys, os, os.path, optparse, lxml.etree, re, subprocess, types, urllib
from string import *
from cStringIO import StringIO
from t4.debug import log, debug
import tmdb3 as tmdb
tmdb.set_key("a888a20b801aeefde1ba41a932898d48")
options = None
def present_movie(idx, movie):
print idx,
if type(movie.releasedate) == types.UnicodeType:
year = movie.releasedate
elif not movie.releasedate:
year = "unknown"
else:
year = str(movie.releasedate.year)
print "%s (%s)" % (
import api_config
import nltk
from tmdb3 import set_key
from tmdb3 import searchPerson
from tmdb3 import searchMovie
from random import randrange
set_key(api_config.API_KEY)
articles = ['and', 'a', 'the', 'as']
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
import media
from tmdb3 import set_key
from tmdb3 import set_cache
from tmdb3 import Movie as Movie_db
import os
import fresh_tomatoes
set_key('XXX') #Insert API key for TMDB3 website
set_cache('null')
list_of_movies = []
for i in range(11, 23):
#Taking 12 movies from Movie_db and storing the data in list_of movies
curr_movie = Movie_db(i)
title = (curr_movie.title)
story_line = (curr_movie.overview)
poster = (curr_movie.poster.geturl())
trailer = (curr_movie.youtube_trailers[0].geturl())
movie_instance = media.Movie(title, story_line, poster, trailer)
list_of_movies.append(
movie_instance) #adding instances of Movie() class to list_of_movies
os.chdir(r"C:\Users\venkata.pushpak\Documents\Udacity\FSD\Project 1")
fresh_tomatoes.open_movies_page(list_of_movies)
from flask import Flask, session, redirect, url_for, request, render_template
from flask_debugtoolbar import DebugToolbarExtension
from flask.ext.mongoengine import MongoEngine
from tmdb3 import set_key
app = Flask('project')
app.config['SECRET_KEY'] = 'random'
app.config['MONGODB_SETTINGS'] = {'DB': 'my_movie_library'}
app.config['SMTP_USER'] = ""
app.config['SMTP_PASSWORD'] = ""
app.config['SMTP_SERVER'] = "smtp.gmail.com:587"
app.config['TMDB_API_KEY'] = ""
set_key(app.config['TMDB_API_KEY'])
# app.config["MONGODB_SETTINGS"] = {'DB': "my_movie_library",
# 'host': '192.168.1.89'}
# app.debug = True
# toolbar = DebugToolbarExtension(app)
db = MongoEngine(app)
# app.debug = True
# toolbar = DebugToolbarExtension(app)
def security(role=None):
def wrapper(func):
@wraps(func)
def security_check(*args,**kwargs):
import json
user = None
if 'user' in session:
''' Define Movie class and backend code to get attributes '''
import webbrowser
from tmdb3 import set_key
# change name of imported class to avoid conflict with our class
from tmdb3 import Movie as theMovie
import os
import datetime
# Make sure this is set as an environment variable!
set_key(os.getenv('TMDB_API_KEY'))
# Movie class that takes TMDB ID to initialize,
# and fills in attributes through TMDB lookups
class Movie(object):
def __init__(self, movie_ID):
self.title = theMovie(movie_ID).title
self.tagline = theMovie(movie_ID).tagline
self.release_year = theMovie(movie_ID).releasedate.strftime("%Y")
self.poster_image_url = theMovie(movie_ID).poster.geturl()
self.trailer_youtube_url = theMovie(
movie_ID).youtube_trailers[0].geturl()
def show_trailer(self):
webbrowser.open(self.trailer_youtube_url)
def __init__(self, api_key, movie_id):
tmbd.set_key(api_key)
tmbd.set_cache('null')
tmbd.set_locale('en', 'US')
self.movie = tmbd.Movie(movie_id)
for p in d.cast[:10]:
newPerson = pmovie.person(m.cast)
newPerson.id = p.id
newPerson.name = p.name
m.cast = newPerson
return m
# Main
args = parseArguments()
db = psql.movieDB(dbFilename)
set_cache(engine='file', filename='/tmp/tmdb.cache')
set_key('f5a1e6218573b468f59d654ebe6269f9')
mFlask = Flask(__name__)
@mFlask.route('/')
def rootEndpoint():
return 'Pvice root endpoint\n'
@mFlask.route('/search/<pattern>')
def searchEndpoint(pattern):
return 'Search endpoint'
@mFlask.route('/movieSearch/<movie>')
def movieSearchEndpoint(movie):
search = searchMovie(movie)
start = 0
def __init__(self):
set_key('2bc810beb95dc1c694f6a935b16e4f16')
def init_tmdb():
"""Initialize TMDb api"""
tmdb3.set_key(config.cfg['API_KEY'])
tmdb3.set_cache(engine='file', filename=config.cfg['CACHEPATH']+'/.tmdb3cache')
tmdb3.set_locale(config.cfg['LANG'], config.cfg['COUNTRY'])
# encoding: utf-8
import csv
import tmdb3
from itertools import izip
from collections import defaultdict
from tmdb3 import searchMovie
from tmdb3 import set_key
from tmdb3 import Movie
set_key('')
'''
columns = defaultdict(list) # each value in each column is appended to a list
with open('movieTitle.csv') as f:
reader = csv.DictReader(f) # read rows into a dictionary format
for row in reader: # read a row as {column1: value1, column2: value2,...}
for (k,v) in row.items(): # go over each column name and value
columns[k].append(v) # append the value into the appropriate list
# based on column name k
'''
imdbid = []
with open('imdb.csv', 'rb') as f:
reader = csv.reader(f)
next(reader) # Ignore first row
for row in reader:
imdbid.append(row[0])
j = 0
imdb_real = []
name = []
import json
from random import shuffle
from .models import genre
from .models import customUser
# Create your views here.
from django.views.decorators.cache import cache_page
from django.core.cache import cache
from tmdb3 import Movie
from tmdb3 import Series
from tmdb3 import set_key
key = '79f8797f2c2e527e4e396dfe9816a3cd'
set_key(key)
def slide():
movies_tv = popular.getPopular()
shuffle(movies_tv)
first_movie = movies_tv[0]
movies_tv = movies_tv[1:]
return first_movie, movies_tv
def popularMovies(GenreMovieList):
popMovies = []
for genre in GenreMovieList:
'NAME': 'movienight/data/db.sqlite',
# The following settings are not used with sqlite3:
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': '',
}
}
GAME_OF_THRONES = os.path.isfile(
os.path.join(PROJECT_PATH, 'game.of.thrones.txt')
)
# The API key needs to be set as soon as possible, so why not here?
with open('tmdb3.api.txt') as _api:
tmdb3.set_key(_api.read().strip())
# Hosts/domain names that are valid for this site; required if DEBUG is False
# See https://docs.djangoproject.com/en/1.5/ref/settings/#allowed-hosts
ALLOWED_HOSTS = []
# Local time zone for this installation. Choices can be found here:
# http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
# although not all choices may be available on all operating systems.
# In a Windows environment this must be set to your system time zone.
TIME_ZONE = 'Europe/Stockholm'
# Language code for this installation. All choices can be found here:
# http://www.i18nguy.com/unicode/language-identifiers.html
LANGUAGE_CODE = 'en-us'
def __init__(self):
log.trace('__init__ method: Started')
super(CleanUp, self).__init__()
trakt_auth_group = DadVision.cmdoptions.parser.add_argument_group(
"Profiles", description=None)
trakt_auth_group.add_argument("-y",
"--grumpy",
dest="HostName",
action="append_const",
const="grumpy",
help="Entries for Grumpy")
trakt_auth_group.add_argument("-t",
"--tigger",
dest="HostName",
action="append_const",
const="tigger",
help="Entires for Tigger")
trakt_auth_group.add_argument("-g",
"--goofy",
dest="HostName",
action="append_const",
const="goofy",
help="Entries for Goofy")
trakt_auth_group.add_argument("-e",
"--eeyore",
dest="HostName",
action="append_const",
const="eeyore",
help="Entries for Eeore")
trakt_auth_group.add_argument("-p",
"--pluto",
dest="HostName",
action="append_const",
const="pluto",
help="Entries for Pluto")
trakt_options_group = DadVision.cmdoptions.parser.add_argument_group(
"Options", description=None)
trakt_options_group.add_argument(
"-c",
"--clear",
dest="Clear",
nargs='*',
action='store',
default='None',
help='Clear/Delete all entries in requested area: shows, movies')
trakt_options_group.add_argument(
"-l",
"--list",
dest="list",
nargs='*',
action='store',
default='None',
help='Clear/Delete all entries in requested area: shows, movies')
tmdb3.set_key('587c13e576f991c0a653f783b290a065')
tmdb3.set_cache(filename='tmdb3.cache')
self.db = api.TVDB("959D8E76B796A1FB")
#self.tmdbinfo = TMDBInfo()
self._collectedShows = []
self._watchedShows = []
self._watchlistShows = []
self._trakt_sdtv = []
self._trakt_720P = []
self._trakt_list = []
self.errorLog = []
return
from __future__ import unicode_literals
from django.conf import settings
import tmdb3
tmdb3.set_key(settings.TMDB_API_KEY)
tmdb3.set_locale('hu', 'hu')
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:
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
##
## I have added a copy of the GPL in the file LICENSE
import sys, os, os.path, optparse, lxml.etree, re, subprocess, types, urllib
from string import *
from cStringIO import StringIO
from t4.debug import log, debug
import tmdb3 as tmdb; tmdb.set_key("a888a20b801aeefde1ba41a932898d48")
options = None
def present_movie(idx, movie):
print idx,
if type(movie.releasedate) == types.UnicodeType:
year = movie.releasedate
elif not movie.releasedate:
year = "unknown"
else:
year = str(movie.releasedate.year)
print "%s (%s)" % ( movie.title, year, )
def getGenreList(genresMovie, genresTV):
key = '79f8797f2c2e527e4e396dfe9816a3cd'
set_key(key)
#Movie
GenreMovieList = {}
for genre in genresMovie:
url = 'https://api.themoviedb.org/3/discover/movie?api_key='
extra = '&sort_by=popularity.desc&include_adult=true&with_genres='
url += key
genreID = genreNameDict[genre]
extra += str(genreID)
url += extra
payload = "{}"
response = requests.request("GET", url, data=payload)
json1_data = json.loads(response.text)
while (1):
try:
results = json1_data['results']
break
except KeyError:
pass
movie_list = []
spare = []
for i in results:
if (i['genre_ids'][0] == genreID):
try:
m = Movie(i['id'])
mx = Movies()
mx.set(movie=m, spGenre=genre)
movie_list.append(mx)
except:
pass
else:
try:
if (i['genre_ids'][1] == genreID):
try:
m = Movie(i['id'])
mx = Movies()
mx.set(movie=m, spGenre=genre)
movie_list.append(mx)
except:
pass
else:
try:
m = Movie(i['id'])
mx = Movies()
mx.set(movie=m, spGenre=genre)
spare.append(mx)
except:
pass
except:
pass
movie_list += spare
GenreMovieList[genre] = movie_list
#TV
GenreTVList = {}
for genre in genresTV:
url = 'https://api.themoviedb.org/3/discover/tv?api_key='
extra = '&sort_by=popularity.desc&with_genres='
url += key
genreID = genreTVNameDict[genre]
extra += str(genreID)
url += extra
payload = "{}"
response = requests.request("GET", url, data=payload)
json1_data = json.loads(response.text)
while (1):
try:
results = json1_data['results']
break
except KeyError:
pass
tv_list = []
spare = []
for i in results:
if (i['genre_ids'][0] == genreID):
try:
m = Series(i['id'])
mx = TV()
mx.set(tv=m, spGenre=genre)
tv_list.append(mx)
except:
pass
else:
try:
if (i['genre_ids'][1] == genreID):
try:
m = Series(i['id'])
mx = TV()
mx.set(tv=m, spGenre=genre)
tv_list.append(mx)
except:
pass
else:
try:
m = Series(i['id'])
mx = TV()
mx.set(tv=m, spGenre=genre)
spare.append(mx)
except:
pass
except:
pass
tv_list += spare
GenreTVList[genre] = tv_list
return GenreMovieList, GenreTVList
def add_tmdb_movie(id):
set_key('c97c17e619252e35bad2e158d4211fcc')
set_locale('ru', 'ru')
set_cache(engine='file', filename='/home/swasher/kinobox/.tmdb3cache')
m = Movi()
try:
mov = Movie(id)
except:
pass
#обработать (не нашло фильм, или ппц ваще) sys.exc_info()[0].__dict__
m.title=mov.title
m.overview=mov.overview
m.origtitle=mov.originaltitle
m.tmdb_id=mov.id
m.year=str(mov.releasedate)[0:4]
m.seen=False
m.seendate=datetime.date.today()
m.myrating=0
m.stored=True
m.adddate=datetime.date.today()
m.tagline=mov.tagline
m.save()
try:
poster = urllib.urlretrieve(mov.poster.geturl(size='w92'))
m.poster.save('poster_'+'w92_'+str(id)+'.jpg', File(open(poster[0])))
except:
#отсутствует постер
#print sys.exc_info()[0].__dict__
#{'__module__': 'tmdb3.tmdb_exceptions', '__doc__': None}
#print 'cant retrieve'
# если не обрабатывать - просто получается пустое поле, его можно обработать дальше
poster = urllib.urlretrieve(mov.poster.geturl(size='w92'))
m.poster.save('poster_'+'w92_'+str(id)+'.jpg', File(open(poster[0])))
pass
try:
posterbig = urllib.urlretrieve(mov.poster.geturl(size='w500'))
m.posterbig.save('poster_'+'w500_'+str(id)+'.jpg', File(open(posterbig[0])))
except:
pass
#get counries
countries = mov.countries
l = ''
for country in countries:
if country.name=='United States of America':
l+='USA'+', '
else:
l+=country.name+', '
m.countries=l[:-2]
genres = mov.genres
genre_list=[]
for genre in genres:
genre_list.append(genre.name)
for genre in genre_list:
try:
# пытаемся найти жанр по названию
gen=Genre.objects.filter(genre=genre)[0]
except:
# Если не найден, возникает исключение, и мы создаем новый жанр.
# Исключение возникает из-за попытки взять нулевой элемент пустого тупла
g=Genre(genre=genre)
g.save()
gen=Genre.objects.filter(genre=genre)[0]
m.genres.add(gen)
m.save()
cast=mov.cast
for actor in cast:
try:
pers=Person.objects.filter(name=actor.name)[0]
except:
#если актера actor.name нет в базе, то вызывется исключение, актер добавляется, и обзывется как pers
p = Person(name=actor.name, tmdb_id=actor.id)
p.save()
pers=Person.objects.filter(name=actor.name)[0]
#если актера до сих пор небыло, то добавляем фото
#todo в дальнейшем это убрать - сделать даунлоад фото, когда актер star-рится
try:
photo = urllib.urlretrieve(actor.profile.geturl(size='w45'))
p.photo.save('photo_'+'w45_'+str(actor.id)+'.jpg', File(open(photo[0])))
except:
#отсутствует постер
#print sys.exc_info()[0].__dict__
#{'__module__': 'tmdb3.tmdb_exceptions', '__doc__': None}
#print 'cant retrieve'
# если не обрабатывать - просто получается пустое поле, его можно обработать дальше
pass
# В это месте у нас есть объекты фильма 'm' и актера 'pers'
d = Duty(person=pers, movi=m, department='', character=actor.character, job='', order=actor.order)
d.save()
from tmdb3 import searchMovie
from urlparse import urlparse
from flask import session as login_session
import random
import string
from oauth2client.client import flow_from_clientsecrets
from oauth2client.client import FlowExchangeError
import httplib2
import json
from flask import make_response
import requests
# Using the movie DB API to get info about the movie
# for more info visit https://www.themoviedb.org/
set_key('b42f313de752b4082729b83599e87b3f')
engine = create_engine('sqlite:///catalogmovi.db')
Base.metadata.bind = engine
DBSession = sessionmaker(bind=engine)
session = DBSession()
app = Flask(__name__)
CLIENT_ID = json.loads(open('client_secrets.json',
'r').read())['web']['client_id']
@app.route('/login')
def showLogin():
state = ''.join(
# -*- coding: UTF-8 -*-
from urllib2 import urlopen, HTTPError
from HTMLParser import HTMLParser
from traceback import print_exc
from xml.dom import minidom
from sys import exit
import datetime
import re
import tmdb3
import tvdb_api
tmdb3.set_key('50d210cbe126f116d13b83239d0f18d0')
tmdb3.set_locale('en', 'US')
class rewiredBotPlugin():
"""IMDb.com plugin"""
def __init__(self, parent, *args):
self.parent = parent
self.defines = "!imdb"
self.privs = {'!imdb': 1}
def run(self, params, *args):
"""!imdb: Usage: !imdb imdbid/Text
Searches imdb.com for movies and tv shows.
When a search term is given. It will respond with a list
of results to choose from. When called with a imdbid instead:
!imdb tt0099785
the plugin will look up the movie on imdb and post a overview into chat.
___"""
if not params:
return "Usage: !imdb SearchText"
import sys
# Import the tmdb package.
try:
from tmdb3 import set_key, searchMovie
except ImportError:
print 'You need to install the pytmdb3 package!'
sys.exit(1)
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]
class TMDB(Movie):
tmdb3.set_key('587c13e576f991c0a653f783b290a065')
tmdb3.set_cache(filename='tmdb3.cache')
def __init__(self, **kwargs):
super(TMDB, self).__init__(**kwargs)
return
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 review_entries(self, tmdb_results):
"""
:param tmdb_results:
:param chkyear:
:return: :raise MovieNotFound:
"""
try:
for _movie in tmdb_results:
_title = decode(_movie.title)
if self.year:
if matching(" ".join([_title.lower(), str(_movie.releasedate.year)]),
" ".join([self.title.lower(), str(self.year)])):
self.title = _title
raise GetOutOfLoop(_movie)
if matching(_title.lower(), self.title.lower()):
self.title = _title
raise GetOutOfLoop(_movie)
else:
# Check Alternate Titles: list(AlternateTitle) alternate_titles
for _alternate_title in _movie.alternate_titles:
log.trace('Check Alternate Titles: {}'.format(_alternate_title))
_alternate_title = decode(_alternate_title)
if matching(_alternate_title, self.title):
_movie.alternate_titles.append(_title)
self.title = _alternate_title
self.alternate_title = _movie.alternate_titles
raise GetOutOfLoop(_movie)
log.warn("Movie Not Found in TMDb: {}".format(self.title))
raise MovieNotFound("Movie Not Found in TMDb: {}".format(self.title))
except GetOutOfLoop, e:
_movie = e.message
if _movie.releasedate:
if self.year:
if (-2 < (self.year - _movie.releasedate.year) < 2):
self.year = _movie.releasedate.year
else:
msg = "Movie name found, Years too far apart: {} - {}/{}".format(self.title,
self.year,
_movie.releasedate.year)
log.warning(msg)
raise MovieNotFound(msg)
else:
self.year = _movie.releasedate.year
log.trace("Movie Located in TMDB")
self.tmdb_id = _movie.id
self.imdb_id = _movie.imdb
self.slug = self.title
self.cast = _movie.cast
if hasattr(_movie, "alternate_titles"):
self.alternate_title = _movie.alternate_titles
return
import urlparse
from flask import Flask, render_template, request
from tmdb3 import set_key, searchMovie, Movie
app = Flask(__name__)
# Set api key for TMDb
set_key('TMDB_API_KEY')
# Home page
@app.route('/', methods=['GET', 'POST'])
def home():
return render_template('index.html')
# Search & results
@app.route('/search/', methods=['GET', 'POST'])
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')
import SocketServer
from handler import HCIRequestHandler
from tmdb3 import set_key
from tmdb3 import set_cache
Handler = HCIRequestHandler
server = SocketServer.TCPServer(('0.0.0.0', 8080), Handler)
set_key('43b0a2c458adc3c7d5968151b9599958')
set_cache('null') #TODO consider adding cache mechanism
server.serve_forever()
def init_movie():
#set_cache('null')
set_key(FB_SECRETS['tmdb_key'])
import media
# Visit https://github.com/wagnerrp/pytmdb3 for more info
from tmdb3 import set_key
from tmdb3 import set_cache
from tmdb3 import set_locale
from tmdb3 import List
# Set personal key to API access
set_key('0ba74440350bf374cee4a9b89f7249a8')
# Caches data to limit excessive usage against API server
set_cache('null')
set_cache(filename='/full/path/to/cache')
set_cache(filename='tmdb3.cfrom random import randintache')
set_cache(engine='file', filename='~/.tmdb3cache')
# Set language and country configuration for API data
set_locale('en', 'us')
now_playing = []
coming_soon = []
modern_classics = []
classics = []
for x in range(0, len(List(35555).members)):
media_title = List(35555).members[x].title.replace(' ', '_')
media_title = media.Media(
List(35555).members[x].title,
def init_tmdb():
tmdb3.set_key(settings.TMDB_KEY)
tmdb3.set_cache(filename=settings.TMDB_CACHE_PATH)
tmdb3.set_locale(*settings.LOCALES[settings.LANGUAGE_CODE])
return tmdb3
if __name__ == '__main__':
## 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)
from flask import Flask, request, render_template, redirect, url_for
app = Flask(__name__)
from tmdb3 import Movie, set_key, searchMovie, searchPerson, searchStudio
set_key('8756c376f367fb966d3c0dec2c69e1c5')
@app.route("/")
def root():
return render_template('base.html', title='Main', pageActive='home')
#@app.route("/noresults/")
#def noresults():
# return render_template('no_results.html')
@app.route("/movies/", methods=['POST', 'GET'])
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')
@app.route("/people/", methods=['POST', 'GET'])
def people():
if request.method == 'POST':
keyword = request.form['keyword']
# Movie Trailer Main File
# By Or Grunebaum
# Modified from Python Course
import fresh_tomatoes
import media
# enable api by setting key for movie database
from tmdb3 import set_key, set_cache
set_key('')
set_cache('null')
# import movie module from the movie database
from tmdb3 import Movie
# add all my favourite movies
list_movies = list()
list_movies.extend([Movie(862),Movie(1542),Movie(671),Movie(83542),Movie(957),
Movie(10156),Movie(8005),Movie(658), Movie(10671),
Movie(813),Movie(86838),Movie(640),Movie(98),
Movie(616),Movie(1669)])
# create movies list to store information needed for the movie trailer website
# (using the Fresh Tomatoes Script) provided by udacity
movies = list()
# loop through the list of movies selected, and add them to movies list to be
# displayed. Specifically we are adding the title, poster, and youtube url.
for number in range(len(list_movies)):
movies.append(media.Movie(list_movies[number].title,
list_movies[number].poster.geturl(),
list_movies[number].youtube_trailers[0].geturl()))
