def add_dvd(request):
# This is a form, with an input box or two.
# Should trigger some omdb stuff and fill in the database
if request.method == 'POST':
form = DvDForm(request.POST, user=request.user)
if form.is_valid():
name = form.cleaned_data['name']
year = form.cleaned_data['year']
dvd_location = form.cleaned_data['location']
type = form.cleaned_data['type']
omdb.set_default('apikey', api_key)
if type == 'film':
possible_dvds = omdb.search_movie(name, year=year)
request.session['is_series'] = False
else:
possible_dvds = omdb.search_series(name, year=year)
request.session['is_series'] = True
request.session['possible_dvds'] = possible_dvds
request.session['dvd_location'] = dvd_location.id
# this is a list of dictionaries with films matching the search.
# want to display the possibilities to the user.
# user then picks which one is right, and a further call to the omdb api
# gets the rest of the data.
return redirect('confirm_dvd')
else:
# display the form
form = DvDForm(user=request.user)
return render(request, 'dvds/add_dvd.html', {'form': form})
def new_file(self, num):
if __name__ == '__main__':
c = [5, 5]
else:
c = [settings.START_X, settings.START_Y]
self.save_file['current'] = {
'player': {
'strength': 1,
'dir': 0,
'ball': 5000,
'coord': c,
},
'movie': {},
}
omdb.set_default('apikey', settings.OMDBAPI_KEY)
movies = []
for movie in settings.MOVIE_LIST:
data = omdb.imdbid(movie)
movies.append({
'name': data['title'],
'strength': int(float(data['imdb_rating'])),
'rating': data['imdb_rating'],
'actors': data['actors'],
'year': data['released'].split(' ')[2],
'image': data['poster'],
'director': data['director'],
'catched': False,
})
self.save_file['current']['movie'] = movies
def fetch_movies(self, search_keywords):
print("Fetching movies...")
movies = []
omdb.set_default('apikey', api_key)
for keyword in search_keywords:
res = requests.get(url + keyword)
encoded = json.dumps(res.json()['Search'])
decoded = json.loads(encoded)
for j in decoded:
req = requests.get(url_ratings + j['Title'])
movie = json.dumps(req.json())
data = json.loads(movie)
temp = {
'title': data['Title'],
'year': data['Year'],
'genre': data['Genre'],
'type': data['Type'],
'plot': data['Plot']
}
movies.append(temp)
print("Fetching completed")
print("Storing the movie data in the json file...")
with open('movies.json', 'w') as jsonFile:
json.dump(movies, jsonFile, indent=4)
print("Successfully stored.")
def picture(self):
omdb.set_default('apikey', 'c69d8944')
res = omdb.get(title=self._name, year=self._year)
if "poster" in res.keys():
return res["poster"]
else:
return None
def collectData(imdb_id):
omdb.set_default('apikey', 'b5e3df7f')
info = omdb.imdbid(imdb_id)
print(info)
inst = Tv_details.objects.create(imdb_id=imdb_id,
title=info['title'],
image_url=info['poster'],
description=info['plot'],
imdb_rating=info['imdb_rating'],
language=info['language'],
country=info['country'],
year=info['year'],
tv_rating=info['rated'])
inst.save()
genres = info['genre'].split(', ')
for genre in genres:
try:
g = Genres.objects.get(genre=genre)
except Genres.DoesNotExist:
g = Genres.objects.create(genre=genre)
g.save()
for genre in genres:
g = Genres.objects.get(genre=genre)
mg = Tv_genre.objects.create(tv_id=inst, genre_id=g)
mg.save()
def main():
omdb.set_default('apikey', '4ed3fc46')
while True:
moviesFolder = 'C:\Movies'
userInput = input(
f"[W]pisujesz nazwy, czy mam je [P]obrać z '{moviesFolder}'? : ")
if userInput == 'W':
userInput = input("Podaj tytuły filmów: ")
elif userInput == 'P':
userInput = downloadTitlesFromFolder(moviesFolder)
else:
continue
movies, sortBy = createMoviesDatabase(userInput)
sortMovies(movies, sortBy)
printMoviesToConsole(movies)
createFoldersForMovies(movies, moviesFolder)
userInput = input("Chcesz wyświetlić trailery? [T]ak : ")
if userInput == 'T':
openTrailers(movies)
userInput = input("Chcesz kontynuować? ('end' konczy program): ")
if userInput == 'end':
break
print()
def main():
# get auth keys from environment
omdb_api_key = os.environ['OMDB_API_KEY']
airtable_api_key = os.environ['AIRTABLE_API_KEY']
airtable_base_movies = os.environ['AIRTABLE_BASE_MOVIES']
# get arguments
argparser = init_argparse()
args = argparser.parse_args()
# set up OMDb connection
omdb.set_default('apikey', omdb_api_key)
# set up Airtable connections
movies_table = Airtable(airtable_base_movies,
'Movies',
api_key=airtable_api_key)
directors_table = Airtable(airtable_base_movies,
'Directors',
api_key=airtable_api_key)
actors_table = Airtable(airtable_base_movies,
'Actors',
api_key=airtable_api_key)
genres_table = Airtable(airtable_base_movies,
'Genres',
api_key=airtable_api_key)
# read movie names, insert movies
for movie_name in load_movie_names(args.movies):
movie_name = movie_name.rstrip()
print(movie_name)
movie_ids = get_movie_ids(movie_name.rstrip())
# make sure --set-field and --append-field are lists, even if they're empty (for upsert_movie())
if args.set_field is None:
args.set_field = []
if args.append_field is None:
args.append_field = []
count = 0
for movie_id in movie_ids['included']:
movie_data = get_movie_data(movie_id)
if movie_data['genre'] == 'Adult' and not args.include_adult:
continue
print(' {} ({})'.format(movie_data['title'], movie_data['year']))
movie_data['directors'] = get_multiple_records(
directors_table, 'Name', movie_data['director'])
movie_data['actors'] = get_multiple_records(
actors_table, 'Name', movie_data['actors'])
movie_data['genres'] = get_multiple_records(
genres_table, 'Name', movie_data['genre'])
data_transformed = transform_data(args, movie_data)
if args.verbose:
print(data_transformed)
upsert_movie(args, movies_table, data_transformed)
count += 1
if count == 0:
print(" NOT FOUND: {}".format(movie_name))
if args.verbose:
for movie_id in movie_ids['excluded']:
print(' excluding {}'.format(movie_id))
def test_set_default(self):
t = 'True Grit'
self.assertEqual(omdb.title(t).year, '2010')
omdb.set_default('year', '1969')
self.assertEqual(omdb.title(t).year, '1969')
def test_set_default(self):
t = 'True Grit'
self.assertEqual(omdb.title(t).year, '2010')
omdb.set_default('year', '1969')
self.assertEqual(omdb.title(t).year, '1969')
def _configure_keys(self):
"""Configures the API services with the keys provided in the settings."""
tmdb.API_KEY = self.settings['tmdb_api_key']
tmdb.SESSION = requests_cache.CachedSession(
os.path.join(self.cache_path, 'requests'),
backend='filesystem',
expire_after=self.settings['cache_expire_after'])
omdb.set_default('apikey', self.settings['omdb_api_key'])
omdb.set_default('timeout', 5)
def test_set_default():
t = 'True Grit'
result = omdb.title(t)
assert result['year'] == '2010'
omdb.set_default('year', '1969')
result = omdb.title(t)
assert result['year'] == '1969'
def __init__(self):
# Set up basic omdb library
self.api_key = '57f4b0ed'
omdb.set_default('apikey', self.api_key)
self.omdb_client = omdb.OMDBClient(apikey=self.api_key)
self.main_url = 'http://www.omdbapi.com/?apikey=%s&' % (self.api_key)
self.db = DB()
def test_set_default():
t = 'True Grit'
result = omdb.title(t)
assert result['year'] == '2010'
omdb.set_default('year', '1969')
result = omdb.title(t)
assert result['year'] == '1969'
def parse_omdb(data):
omdb.set_default('apikey', 'b5e3df7f')
results = omdb.search(data)
ret = []
for result in results:
ret.append((result['title'], result['year'], result['imdb_id'],
result['poster']))
return ret
def get_poster(movie: str):
# Set OMDB API key
omdb.set_default("apikey", "1454b6c1")
movies_list = omdb.search_movie(movie)
# Get poster
if len(movies_list) != 0:
poster = movies_list[0]["poster"]
return poster
else:
return None
def get_movie(imdb_id, api_key):
"""Get movie from imdb_id.
Args:
imdb_id: imdb ID number for movie
api_key: API key for omdb
Returns:
omdb info from imdb_id
"""
omdb.set_default('apikey', api_key)
return omdb.imdbid(imdb_id)
def create_app(test_config=None):
# create and configure the app
app = Flask(__name__, instance_relative_config=True)
omdb.set_default('apikey', '6623baf2')
app.register_blueprint(excel)
app.register_blueprint(shows)
# the toolbar is only enabled in debug mode:
app.debug = True
# upload folder path
app.config['MAX_CONTENT_PATH'] = 5000000
app.config[
'SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://root:' '@127.0.0.1/neo_theater'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config.from_mapping(
SECRET_KEY='dev',
DATABASE=os.path.join(app.instance_path, 'flaskr.db'),
)
sql_db_extension.init_app(app)
toolbar = DebugToolbarExtension(app)
if test_config is None:
# load the instance config, if it exists, when not testing
app.config.from_pyfile('settings.py', silent=True)
else:
# load the test config if passed in
app.config.from_mapping(test_config)
# ensure the instance folder exists
try:
os.makedirs(app.instance_path)
except OSError:
pass
# a simple page that says hello
@app.route('/hello')
def hello():
return 'Hello, World!'
@app.errorhandler(InvalidUsage)
def handle_invalid_usage(error):
response = jsonify(error.to_dict())
response.status_code = error.status_code
return response
from . import db
db.init_app(app)
return app
def media_database_builder(file, API_KEY, start_index, stop_index):
"""
This function used requests imdb movies and tv information using the omdb
module and appends them to a dataframe
INPUTS:
file = file containing imdb keys
API Key
Start index and Stop index for imdb keys
OUTPUTS:
Excel csv spreadsheet containing information
"""
# convert unique imdb title to dataframe
col_name = ['imdbid']
imdb_id = pd.read_csv(file, sep='\t', names=col_name)
omdb.set_default('apikey', API_KEY)
client = OMDBClient(apikey=API_KEY)
rows_list = []
for i in range(int(start_index), int(stop_index)):
print(i)
movie_ID = imdb_id.iloc[i, 0]
try:
movie_dict = omdb.get(imdbid=movie_ID)
rows_list.append(movie_dict)
# Generates HTTP Error
r = omdb.request(imdbid=movie_ID)
# Value error - imdb ID yeilds dictionary that is empty
# HTTPError (522) - Exceeded requests per unit time
# Timeout - Overrules default timeout value
except (ValueError, requests.HTTPError, requests.ReadTimeout) as err:
if err == ValueError:
continue
else:
i = i - 1
time.sleep(2.0)
print('Error has occured')
print('Retry request in 2.0 seconds')
continue
media_df = pd.DataFrame(rows_list)
media_csv = media_df.to_csv(r'media_data.csv',
mode='a',
header=False,
index=None,
encoding="utf-8")
return media_csv
def main():
omdb.set_default('tomatoes', True)
dirname = input("Enter directory: ")
if(len(sys.argv) == 2):
dirname = sys.argv[1]
raw_movies = os.listdir(dirname)
print('Cleaning.....')
l = clean(raw_movies)
print('Retrieving Info...')
info = search(l)
sorted_x = sorted(info.items(), key=operator.itemgetter(1))
sorted_x = sorted_x[::-1]
for i in sorted_x:
print(i[0]+ ' ---------------' + str(i[1]))
def get_movies(self):
#API_KEY = getattr(settings, 'API_KEY', None)
omdb.set_default('apikey', API_KEY)
for movie in MOVIES:
wp_call = omdb.request(t=movie)
if wp_call.status_code != 200:
print("Erreur HTTP, code ", str(wp_call.status_code))
exit(1)
infos_json = wp_call.json()
if infos_json and 'Error' in infos_json.keys():
print('Error: ', infos_json['Error'])
else:
self.movies.append(Movie(infos_json))
def main():
omdb.set_default('tomatoes', True)
dirname = raw_input("Enter directory")
if (len(sys.argv) == 2):
dirname = sys.argv[1]
raw_movies = os.listdir(dirname)
print('Cleaning.....')
l = clean(raw_movies)
print('Retreiving Info...')
info = search(l)
sorted_x = sorted(info.items(), key=operator.itemgetter(1))
sorted_x = sorted_x[::-1]
for i in sorted_x:
print(i[0] + ' ---------------' + str(i[1]))
def add_poster_link(self, movie: Movie):
omdb.set_default('apikey', 'b03ac630')
query_result = omdb.get(title=movie.title,
year=movie.year,
fullplot=True,
tomatoes=True)
try:
poster_link = query_result['poster']
if poster_link is not None and poster_link != "":
movie.poster_link = poster_link
else:
movie.poster_link = '/static/blankimg.jpg'
except:
movie.poster_link = '/static/blankimg.jpg'
def get_data():
# Get rank of process and overall size of communicator:
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
API_KEY = API_KEYS[rank]
omdb.set_default('apikey', API_KEY)
interval = int(len(ids) / size)
start = rank * interval
end = (rank + 1) * interval
for i in range(start, end):
print(i)
data_list[i] = omdb.imdbid(ids[i], fullplot=True, tomatoes=True)
def get_imdsb_info(self, id, type='movie'):
API_KEY = "68735ac"
omdb.set_default('apikey', API_KEY)
omdb.set_default('tomatoes', True)
id = format_id(id)
movie = omdb.imdbid(id, fullplot=True, tomatoes=True)
url = 'https://www.imdb.com/title/' + movie['imdb_id'] + '/'
print(url)
print(json.dumps(movie, indent=4, sort_keys=True))
#return and info about the movie
return movie
def update_db(session, stats):
tmdb.API_KEY = '83b91371cf3596807811c2e4c936f239'
tmdb_search = tmdb.Search()
# session = settings.SESSION()
# stats = UpdateMoviesStatsAlt()
# session.add(stats)
omdb.set_default('tomatoes', True)
# Downloading archive
stats.status = 1
file_path = download_archive()
# Extracting archive
stats.status = 2
csv_path = extract_zip_archive(file_path)
# Open csv file and start parsing
stats.status = 3
csv_file = codecs.open(csv_path, mode='rb')
csv_reader = csv.reader(csv_file, delimiter=',')
csv_headers = csv_reader.next()
i = 0
err = 0
success = 0
added = 0
existed = stats.existed
data_validator = MovieDataValidator(None)
# omdb_data = dict().fromkeys(sets.OMDB_FIELDS)
movie_data = dict().fromkeys(csv_headers)
header_indexes = dict().fromkeys(csv_headers)
for header in csv_headers:
header_indexes[header] = csv_headers.index(header)
for row in csv_reader:
row = [x.decode('unicode-escape') for x in row]
for header in csv_headers:
movie_data[header] = row[header_indexes[header]]
data_validator.set_data(movie_data)
if data_validator.is_valid():
i += 1
existed, err, success, added = process_row(session, movie_data, existed, tmdb_search, i, err, success, added)
stats.detected = i
stats.existed = existed
stats.stored = success
stats.not_recognized = err
session.commit()
return stats.existed, err, success
def datos_peli_imbd(self,
titulo=None,
idFicha=None,
anio=None,
sinopsis=None,
titulo_es=None):
logger.debug('-------------- BUSCAMOS EN IMBD --------------------')
vapikey = 'c3ca59d0'
omdb.set_default('apikey', vapikey)
pelicula = []
if titulo == None and idFicha == None:
logger.error("No hay parámetros para la busqueda")
pelicula = []
elif idFicha <> None:
pelicula = omdb.imdbid(idFicha)
elif titulo <> None:
if anio == None:
pelicula = omdb.get(title=titulo)
else:
pelicula = omdb.get(title=titulo, year=anio)
if pelicula:
log_datos(pelicula)
item = {
'titulo': titulo_es,
'titulo_orig': pelicula.title,
'anio': pelicula.year,
'generos': pelicula.genre,
'imagen': pelicula.poster,
'pais': pelicula.country,
'escritor': pelicula.writer,
'director': pelicula.director,
'actores': pelicula.actors,
'duracion': pelicula.runtime,
'sinopsis': pelicula.plot,
'sinopsis_es': sinopsis,
'idFicha': 'Imdb-' + pelicula.imdb_id,
}
logger.debug('Finalmente nos queda ')
log_datos(item)
else:
return None
return item
def main():
"""Configure, parse the arguments and call show_results"""
try:
api_key = os.environ['OMDB_API_KEY']
except KeyError:
sys.exit('You must set the environment variable OMDB_API_KEY')
omdb.set_default('apikey', api_key)
description = 'Search movies by name and print its Rotten Tomato rating'
parser = argparse.ArgumentParser(description=description)
parser.add_argument(
'name',
help='Movie name you want to know the Rotten Tomato rating',
type=str,
nargs='+',
)
args = parser.parse_args()
show_results(' '.join(args.name))
def main():
global dirPath
omdb.set_default('tomatoes', True)
print(dirPath)
#dirPath = input("Enter directory:")
#if(len(sys.argv) == 2):
#dirPath = sys.argv[1]
raw_movies = os.listdir(dirPath)
#print(raw_movies)
print('Cleaning.....')
l = clean(raw_movies)
print('Retreiving Info...')
info,plot,actors,director,genre = search(l)
#print(info)
#print(plot)
#print(actors)
#print(director)
#print(genre)
sorted_x = sorted(info.items(), key=operator.itemgetter(1))
sorted_x = sorted_x[::-1]
print(sorted_x)
f=open("../Details_Finder/DF_Details.txt","w")
print(sorted_x)
for i in sorted_x:
f.write("\n")
f.write("MOVIE NAME:"+i[0]+"\n")
f.write("IMDb RATING:"+str(i[1])+"\n")
f.write("GENRE:"+genre[i[0]]+"\n")
f.write("ACTORS:"+actors[i[0]]+"\n")
f.write("DIRECTOR:"+director[i[0]]+"\n")
f.write("PLOT:"+plot[i[0]]+"\n")
f.write("\n")
print("****************************");
print("MOVIE NAME:",i[0])
print("IMDb RATING:",str(i[1]))
print("GENRE:",genre[i[0]])
print("ACTORS:",actors[i[0]])
print("DIRECTOR:",director[i[0]])
print("PLOT:",plot[i[0]])
f.close()
extra()
def query_omdb(title, release_year, omdbapikey):
"""
Query OMDB and return a dictionary. Will return empty if not found.
title {str}: movie title to query for
release_year {int}: release year of movie
omdbapikey {str}: OMDB API key
returns {dict}: dictionary of cleaned OMDB API response
"""
omdb.set_default('apikey', omdbapikey)
data = omdb.get(title=title,
year=release_year,
fullplot=False,
tomatoes=False)
data = clean_omdb_response(data) if len(data) else {}
return data
def get_movie_info(start_id, end_id):
omdb.set_default('plot', True)
sub_query = Movie.objects.filter(movie_id__gte=start_id).filter(
movie_id__lt=end_id)
for q in sub_query:
title = q.name.encode('utf-8')
api_result = omdb.title(title)
if api_result:
q.plot = api_result['plot'].encode('utf-8')
q.duration = api_result['runtime'].encode('utf-8')
q.release_date = api_result['released'].encode('utf-8')
q.rating = api_result['imdb_rating'].encode('utf-8')
q.poster = api_result['poster'].encode('utf-8')
q.cast_crew = api_result['actors'].encode('utf-8')
q.genre = api_result['genre'].encode('utf-8')
q.save()
else:
print('cannot retrieve data of movie ' + title)
def omdb_api_call(use_ids, API_KEY, output_filename):
'''
Function to call the OMDb API to retrive information given ids
Inputs:
use_ids: list of int: list of IMDb ids for which info has to be retrieved
API_KEY: the API key used for call
output_filename: file in which the data has to be stored
Returns: Nothing
'''
data_list = []
omdb.set_default('apikey', API_KEY)
for i in range(len(use_ids)):
print(i)
data_list.append(omdb.imdbid(use_ids[i], fullplot=True, tomatoes=True))
with open(output_filename, 'w') as fout:
json.dump(data_list, fout)
def get_ids(apikey, titles) :
"""
apikey : string, clé d'identifacation pour OMDB
titles : list(string), liste des titres des séries
écrit les id des séries dans un fichier
limité à 1000 requêtes par jour
on a tous les id.
"""
omdb.set_default('apikey', apikey) # identification
cpt = 0
series_rejetees = []
with open('titles/titles_imdb_id.txt', 'a') as file2: # 'a' pour ajouter à la suite du fichier
for titre in log_progress(titles, every=1) :
ID = get_IMDB_id_from_title(titre)
if ID != -1 :
file2.write(titre+" "+ID+"\n")
else :
series_rejetees.append(titre)
cpt += 1
def main():
omdb.set_default('tomatoes', True)
manager = GUI_Manager()
directory_path = manager.get_folder_path()
if directory_path == "":
directory_path = os.path.dirname(os.path.realpath(__file__))
if len(sys.argv) == 2:
directory_path = sys.argv[1]
raw_movies = os.listdir(directory_path)
movie_list = clean(raw_movies)
movies_information = get_movies_info(movie_list, manager.top_window)
if not movies_information:
print("No movies were found.\nPlease check directory or file names.")
manager.show_movie_informations(movies_information)
def omdb_request(self):
API_KEY = getattr(settings, 'API_KEY', None)
if API_KEY is None:
print("Error: no API_KEY in settings.py")
exit(1)
moviemons = getattr(settings, 'MOVIEMONS', None)
if moviemons is None:
print("Error: no moviemons in settings.py")
exit(1)
omdb.set_default('apikey', API_KEY)
for movie in moviemons:
wp_call = omdb.request(t=movie)
if wp_call.status_code != 200:
print("Erreur HTTP, code ", str(wp_call.status_code))
exit(1)
infos_json = wp_call.json()
if infos_json and 'Error' in infos_json.keys():
print('Error: ', infos_json['Error'])
else:
self.moviemons[infos_json['Title']] = Moviemon(infos_json)
def querymovie(*args, **kwargs):
title = kwargs.get('title', '')
year = kwargs.get('year', '')
imdbid = kwargs.get('imdbid', None)
#print '###querymovie###',title, year, imdbid #comments
if title:
title = title.replace('.',' ')
omdb.set_default('tomatoes','true')
omdb.set_default('plot','full')
if imdbid <> None:
res = omdb.get(imdbid=imdbid)
else:
res = omdb.get(title=title,year=year)
#print res # comment
if len(res)>0:
return res
elif title:
return searchmovie(title, year)
else:
return ''
def get_movie_info(movie_name):
omdb.set_default('tomatoes', True)
movie_obj = omdb.title(movie_name)
for category,info in movie_obj.iteritems():
print "{0}{1}{2}".format(category.upper(),' : ',info)
def com_omdb_default(self):
"""
Set defaults for data returned
"""
omdb.set_default('tomatoes', True)
