def make_reservation(cls, conn, username):
cursor = conn.cursor()
cursor.execute(cls.INSERT_USERNAME, (username,))
Movies.show_current_movies(conn)
conn.commit()
def query_without_index():
# query_by_boto3()
response = Movies.query().where(Movies.year.eq(year)).all()
items = response['Items']
print("Movies from %s" % year)
for i in items:
print(i.year, ":", i.title)
# query_with_limit_by_boto3()
response = Movies.query().where(Movies.year.eq(1985)).limit(10).all()
items = response['Items']
print("Movies from %s limit 10" % year)
for i in items:
print(i.year, ":", i.title)
# query_with_filter_by_boto3()
response = (Movies.query().where(Movies.year.eq(1992),
Movies.title.between('A', 'L')).all())
items = response['Items']
print("Movies from 1992 - titles A-L, with genres and lead actor")
for i in items:
print(i.year, ":", i.title)
# query_with_limit_and_filter_by_boto3()
response = (Movies.query().where(Movies.year.eq(1992),
Movies.title.between('A', 'L'),
Movies.rating.eq('7.0')).all())
items = response['Items']
print("Movies from 1992 - titles A-L, with genres and lead actor")
for i in items:
print(i.year, ":", i.title)
def __init__(self):
self.currMovies = 702625
self.g = Genres()
self.m = Movies()
self.imgURI = 'https://image.tmdb.org/t/p/w220_and_h330_face'
self._apiKey = 'cab215b672637a6d24409a56bcd457c2'
self._baseUri = 'https://api.themoviedb.org/'
pass
def test_add_movie(self):
db = "cinema.db"
movies = Movies(db)
#movies.add_movie("The Hunger Games: Catching Fire", 7.9)
#movies.add_movie("Wreck-It Ralph", 7.8)
#movies.add_movie("Her", 8.3)
#TESTING SHOW MOVIES
movies.show_movies()
def test_add_movie(self):
db = "cinema.db"
movies = Movies(db)
#movies.add_movie("The Hunger Games: Catching Fire", 7.9)
#movies.add_movie("Wreck-It Ralph", 7.8)
#movies.add_movie("Her", 8.3)
#TESTING SHOW MOVIES
movies.show_movies()
def __init__(self, addon, artutils, options):
'''Initializations pass our common classes and the widget options as arguments'''
self.artutils = artutils
self.addon = addon
self.options = options
self.movies = Movies(self.addon, self.artutils, self.options)
self.tvshows = Tvshows(self.addon, self.artutils, self.options)
self.songs = Songs(self.addon, self.artutils, self.options)
self.albums = Albums(self.addon, self.artutils, self.options)
self.pvr = Pvr(self.addon, self.artutils, self.options)
self.episodes = Episodes(self.addon, self.artutils, self.options)
def make_a_reservation(cursor, connection):
seats = []
username = input("Enter username > ")
number_of_tickets = input("Enter the number of tickets > ")
Movies.get_all(cursor, connection)
movie_id = input("Choose a projection >")
Projections.get_all_for(cursor, movie_id)
projection_id = input("Enter the wanted projection")
for x in range(1, int(number_of_tickets)+1):
seats.append(Reservations.choose_seats(cursor, connection, projection_id))
Reservations.print_reservation(cursor, username, movie_id, projection_id, seats)
Reservations.confirm(cursor, connection, username, projection_id, seats)
def editMovie(id):
if not "user" in session:
return redirect('/')
if session["user"] is not Movies.findMovie(id).director:
return redirect('/')
if request.method == 'GET':
return render_template('editmovies.html', movie=Movies.findMovie(id))
if request.method == 'POST':
values = (id, request.form['title'], request.form["description"],
session["user"], request.form['agelimit'],
request.form['moviedate'])
movie = Movies(*values).edit()
return redirect('/mymovies')
def main():
connection = sqlite3.connect('cinema')
connection.row_factory = sqlite3.Row
cursor = connection.cursor()
cursor.execute('''CREATE TABLE IF NOT EXISTS cinema(id INTEGER PRIMARY KEY,
name TEXT)''')
Projections.load_reservations()
connection.commit()
Reservations.create_database(connection, cursor)
Projections.create_database(connection, cursor)
Movies.create_database(connection, cursor)
cinema = Cinema()
cinema.main_menu(cursor, connection)
def userAllMovies(self):
with DB() as db:
values = (self.id,)
rows = db.execute('SELECT Movies.id, Movies.title, Movies.description, Movies.directorId, Movies.ageLimit, Movies.date FROM Movies INNER JOIN Third ON Movies.id = Third.movieId WHERE Third.userId = ?'
, values).fetchall()
print(rows)
return [Movies(*row) for row in rows]
def movies():
id = None
if "user" in session:
id = session["user"]
return render_template('allmovies.html',
user=Users.loadUserId(id),
movies=Movies.dateActive())
def myMovies():
if not "user" in session:
return redirect('/')
user = Users.loadUserId(session["user"])
return render_template('mymovies.html',
user=user,
movies=Movies.findDirector(user.id))
def query_with_paginator():
response = (Movies.query().where(Movies.year.eq(1992)).limit(20).all())
items = response['Items']
print(response)
LastEvaluatedKey = response['LastEvaluatedKey']
print(LastEvaluatedKey)
for i in items:
print(i.year, ":", i.title)
def create_item():
with open("moviedata.json") as json_file:
movies = json.load(json_file)
for movie in movies[10:200]:
release_date = movie['info'].get('release_date')
release_date = str_to_time(release_date)
result = dict(year=int(movie['year']),
title=movie['title'],
info=movie['info'],
rating=movie['info'].get('rating', 0.0),
rank=movie['info'].get('rank', 0),
release_date=release_date)
print(movie['title'], int(movie['year']))
print(result)
Movies.create(**result)
item_count = Movies.item_count()
print('Movies item count: %s' % item_count)
def query_with_index():
response = (
Movies.query().where(
Movies.year.eq(1992), Movies.rating.between(6.0, 7.9)).order_by(
Movies.rating) # use rating as range key by local index
.all())
items = response['Items']
print("Movies from 1992 - rating 6.0-7.9, with genres and lead actor")
for i in items:
print(i.year, ":", i.title, i.rating)
def get_item():
item = Movies.get(year=year, title=title)
print("GetItem succeeded:", item.info, item.year)
primary_keys = [
{
'year': 1990,
'title': 'Edward Scissorhands'
},
{
'year': 1990,
'title': 'Ghost'
},
{
'year': 2007,
'title': 'Captivity'
},
]
items = Movies.batch_get(*primary_keys)
print('items len:', len(items))
def add():
if not "user" in session:
return redirect('/')
if request.method == 'GET':
return render_template('addmovie.html',
user=Users.loadUserId(session["user"]))
if request.method == 'POST':
values = (None, request.form['title'], request.form['description'],
session["user"], request.form['agelimit'],
request.form['moviedate'])
movie = Movies(*values).create()
return redirect('/')
def do_GET(self):
"""Handle a post request by returning the square of the number."""
#length = int(self.headers.getheader('content-length'))
#data_string = self.rfile.read(length)
if os.path.isfile(self.path[1:]) and self.path[1:].split("/")[0] == "static":
return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET( self )
M = Movies(DOMA, DIRE)
self.ndbmovies = M.getNDB()
print self.ndbmovies, "movies"
expl = self.path.split("/")
if expl[1] == "real":
self.title = "real: " + expl[2]
self.content += M.getReal(expl[2])
elif expl[1] == "id":
self.content += M.getId(expl[2])
elif expl[1] == "year":
self.title = expl[2]
self.content += M.getYear(expl[2])
elif expl[1] == "random":
self.title = "Random"
self.content += M.getRand()
elif expl[1] == "morand":
self.title = "Random (quick)"
self.content += M.getMorand()
elif expl[1] == "search":
parsed = urlparse.urlparse(self.path)
s = urlparse.parse_qs(parsed.query)['s']
self.title = "search:" + s[0]
self.content += M.search(s[0])
elif expl[1] == "top250":
pass
elif expl[1] == "genre":
pass
elif expl[1] == "actor":
pass
elif expl[1] == "":
self.content += M.getAll()
else:
self.content += "<h2>404 Not Found</h2>"
return self.view()
def batch_add_items():
with open("moviedata.json") as json_file:
movies = json.load(json_file)
count = len(movies)
offset, limit = 200, 100
while True:
if count < offset:
break
items = []
for movie in movies[offset:offset + limit]:
release_date = movie['info'].get('release_date')
release_date = str_to_time(release_date)
result = dict(year=int(movie['year']),
title=movie['title'],
info=movie['info'],
rating=movie['info'].get('rating', 0.0),
rank=movie['info'].get('rank', 0),
release_date=release_date)
print(result)
items.append(result)
Movies.batch_write(items)
item_count = Movies.item_count()
print('Movies item count: %s' % item_count)
offset += limit
def added_movie():
if session['username'] != "admin":
return render_template("unworthy.html")
if request.method =="POST":
file = request.files['pic']
filename = None
if 'pic' in request.files:
filename = photos.save(request.files['pic'])
movie = Movies(name = request.form['name'],cast = request.form['cast'],
rat = int(request.form['rating']),lang = request.form['lang'], genre = request.form['genre'],
img_link = filename,c_rating = int(request.form['c_rating']),
avg_rating = int(request.form['avg_rating']),release_date = request.form['release_date'],
duration = request.form['duration'])
if Movies.query.filter_by(name = movie.name).first() != None:
return render_template('unsuccessful.html',error = "Movie already exists!")
db.session.add(movie)
db.session.commit()
return render_template('add_movie.html')
def update_item():
item = Movies.get(year=year, title=title)
print("GetItem succeeded:", item.info, item.year)
item.update(rank=2467, rating=7.1)
assert item.rank == 2467
assert item.rating == 7.1
item.update(Movies.rank.set(2000, attr_label='r'))
assert item.rank == 2000
item.update(Movies.rating.set(7.9, if_not_exists='info.rating'))
assert item.rating == 7.1
item.update(Movies.rating.set(7.9, if_not_exists='info.rat'))
assert item.rating == 7.9
item.update(Movies.info.set(['genres'], list_append=('info.genres', -1)))
print(item.info['genres'])
def run(self):
print("\n Welcome to BookMyShow \n ")
print("\n Please select Movie from following list: \n\n")
movie = Movies()
# Display movie list and select movie
movieList = movie.getMovies()
movie_id = super(BookMyShow, self).displayMovies(movieList)
# Display date list and select date
movieDates = movie.getMovieDates(movie_id)
movies_dates_id = super(BookMyShow,
self).displayDates(movie_id, movieList,
movieDates)
# Display time list and select time
movieTimes = movie.getMovieDateTimes(movie_id, movies_dates_id)
movies_time_id = super(BookMyShow,
self).displayTimes(movie_id, movies_dates_id,
movieList, movieDates,
movieTimes)
# Display seat nos and select seat
bookedTicketNo = movie.getBookedSeats(movie_id, movies_dates_id,
movies_time_id)
seat_nos = super(BookMyShow, self).displaySeats(bookedTicketNo)
decision = input("Want to Book Ticket \n Plese enter Y or N:")
if (decision == 'Y'):
for seat_no in seat_nos:
movie.bookTicket(movie_id, movies_dates_id, movies_time_id,
seat_no, 1)
print("\n Booked seat no " + str(seat_no) + " for " +
movieList[movie_id] + " movie on date " +
str(movieDates[movies_dates_id]) + " and time " +
str(movieTimes[movies_time_id]) + " Successfully ")
class Api:
def __init__(self):
self.currMovies = 702625
self.g = Genres()
self.m = Movies()
self.imgURI = 'https://image.tmdb.org/t/p/w220_and_h330_face'
self._apiKey = 'cab215b672637a6d24409a56bcd457c2'
self._baseUri = 'https://api.themoviedb.org/'
pass
def getGenres(self):
endpoint = '3/genre/movie/list'
genres = requests.get(url=self._baseUri + endpoint,
params=dict(api_key=self._apiKey, ))
d = genres.json()
[self._saveGenres(g) for g in d['genres']]
def _saveGenres(self, genre):
if not self.g.exists(genre['id']):
self.g.saveGenre(genreId=genre['id'], genreName=genre['name'])
def _getGenreWithID(self, id):
return self.g.getGenreName(id)
def getMovies(self):
result = self.makeRequest()
l = 'popularity.asc, popularity.desc, release_date.asc, release_date.desc, revenue.asc, revenue.desc, primary_release_date.asc, primary_release_date.desc, original_title.asc, original_title.desc, vote_average.asc, vote_average.desc, vote_count.asc, vote_count.desc'
totalPages = result['total_pages']
print(
f'going to download info for {result["total_results"]} movies :)))\n\n'
)
[self._saveMovies(m) for m in result['results']]
for page in range(totalPages):
print(f'current page: {page} \n\n')
for c in l.split(', '):
result = self.makeRequest(endpoint='3/discover/movie',
page=page + 1,
c=c)
[self._saveMovies(m) for m in result['results']]
result = self.makeRequest(endpoint='3/discover/tv')
totalPages = result['total_pages']
for page in range(totalPages):
print(f'current page: {page} \n\n')
for c in l.split(', '):
result = self.makeRequest(endpoint='3/discover/tv',
page=page + 1,
c=c)
[self._saveMovies(m) for m in result['results']]
def findMovie(self,
search='',
popularity=-1,
genres='',
adult=False,
limit=10):
print(search, adult, genres, popularity, limit)
popularity = int(popularity)
array = self.m.getList(
search=search,
popularity=popularity,
genres=genres,
isAdult=adult,
)
final = []
if array == []:
final.append(
dict(
imgPath=
'https://scontent.ftia4-1.fna.fbcdn.net/v/t1.0-9/31358061_1486482608130033_6889977130264821760_o.jpg?_nc_cat=108&_nc_sid=09cbfe&_nc_ohc=LTfoIC-71R0AX8GBsPb&_nc_ht=scontent.ftia4-1.fna&oh=38837f4d06399f89709401838678f389&oe=5EDD08ED',
title='No movies with your preferences!',
description=
f'You searched for "{search}". \n We are sorry but we coldn\'t find movies with that name on the categories you chose, so we are ofering you some random suggestions',
bday='',
language='Sorry',
genres=genres,
popularity=popularity,
))
array = self.m.getList(isAdult=adult, )
while len(final) < limit:
final.append(array.pop(random.randint(0, len(array))))
elif len(array) > limit:
while len(final) < limit:
try:
final.append(array.pop(random.randint(0, len(array))))
except Exception:
break
else:
final = array
return final
def makeRequest(self,
endpoint='3/discover/movie',
page=1,
c='popularity.desc'):
genres = requests.get(url=self._baseUri + endpoint,
params=dict(api_key=self._apiKey,
include_adult=True,
sort_by=c,
page=page))
return genres.json()
def getSavedMovies(self):
[print(l, '\n') for l in self.m.getAllMovies()]
return self.m.getAllMovies()
def _saveMovies(self, movie):
try:
popularity = movie['popularity']
if movie['poster_path']:
posterPath = self.imgURI + movie['poster_path']
else:
posterPath = 'https://scontent.ftia4-1.fna.fbcdn.net/v/t1.0-9/31358061_1486482608130033_6889977130264821760_o.jpg?_nc_cat=108&_nc_sid=09cbfe&_nc_ohc=LTfoIC-71R0AX8GBsPb&_nc_ht=scontent.ftia4-1.fna&oh=38837f4d06399f89709401838678f389&oe=5EDD08ED'
movieId = movie['id']
isAdult = movie['adult']
language = movie['original_language']
genres = []
[
genres.append(self._getGenreWithID(id))
for id in movie['genre_ids']
]
title = movie['title']
description = movie['overview']
bday = movie['release_date']
votes = movie['vote_count']
bday = parser.parse(bday)
averageVote = movie['vote_average']
if not self.m.exists(movieId):
self.m.saveMovie(movieId=movieId,
movieTitle=title,
description=description,
popularity=popularity,
posterPath=posterPath,
isAdult=isAdult,
language=language,
genre=''.join(str(e + ' ') for e in genres),
bday=bday,
votes=votes,
averageVote=averageVote)
print(f'\tsaved movie with id: {movieId} \t title: {title}')
return f'\tsaved movie with id: {movieId} \t title: {title}'
else:
print(
f'\talready saved movie with id: {movieId} \t title: {title}'
)
return f'\talready saved movie with id: {movieId} \t title: {title}'
except Exception:
print('smth went wrong but we good')
return False
import fresh_tomatoes
from movies import Movies
the_avenger_infinity_war = Movies(
'Avengers: Infinity War',
'The Avengers and their allies must be willing to sacrifice all in an attempt to defeat the powerful Thanos before his blitz of devastation and ruin puts an end to the universe.',
'https://ia.media-imdb.com/images/M/MV5BMjMxNjY2MDU1OV5BMl5BanBnXkFtZTgwNzY1MTUwNTM@._V1_UX182_CR0,0,182,268_AL_.jpg',
'https://www.youtube.com/watch?v=6ZfuNTqbHE8')
a_quiet_place = Movies(
'A Quiet Place',
'A family is forced to live in silence while hiding from creatures that hunt by sound.',
'https://ia.media-imdb.com/images/M/MV5BMjI0MDMzNTQ0M15BMl5BanBnXkFtZTgwMTM5NzM3NDM@._V1_UX182_CR0,0,182,268_AL_.jpg',
'https://www.youtube.com/watch?v=WR7cc5t7tv8')
rampage = Movies(
'Rampage',
'When three different animals become infected with a dangerous pathogen, a primatologist and a geneticist team up to stop them from destroying Chicago.',
'https://ia.media-imdb.com/images/M/MV5BNDA1NjA3ODU3OV5BMl5BanBnXkFtZTgwOTg3MTIwNTM@._V1_UX182_CR0,0,182,268_AL_.jpg',
'https://www.youtube.com/watch?v=coOKvrsmQiI')
movies = [the_avenger_infinity_war, a_quiet_place, rampage]
fresh_tomatoes.open_movies_page(movies)
from flask import Flask, jsonify, url_for
from movies import Movies, Parser
import random
import os
from functools import wraps
app = Flask(__name__)
searcher = Movies()
top = searcher.imdb_top250()
parser = Parser()
@app.route("/top250", methods=['GET'])
def top250():
return jsonify(list=top)
@app.route("/random", methods=['GET'])
def getmovie():
movie = random.choice(top)
movie_bis = searcher.search_by_name_R(movie['title'])
title, rating, img, text = parser.parse(movie, movie_bis)
return jsonify(title=title, rating=rating, poster=img, plot=text)
if __name__ == '__main__':
port = int(os.environ.get('PORT', 5000))
app.run(host='0.0.0.0', port=port, debug=True)
class Media(object):
'''all media (mixed) widgets provided by the script'''
def __init__(self, addon, artutils, options):
'''Initializations pass our common classes and the widget options as arguments'''
self.artutils = artutils
self.addon = addon
self.options = options
self.movies = Movies(self.addon, self.artutils, self.options)
self.tvshows = Tvshows(self.addon, self.artutils, self.options)
self.songs = Songs(self.addon, self.artutils, self.options)
self.albums = Albums(self.addon, self.artutils, self.options)
self.pvr = Pvr(self.addon, self.artutils, self.options)
self.episodes = Episodes(self.addon, self.artutils, self.options)
def listing(self):
'''main listing with all our movie nodes'''
all_items = [
(self.addon.getLocalizedString(32011),
"inprogress&mediatype=media", "DefaultMovies.png"),
(self.addon.getLocalizedString(32005), "recent&mediatype=media",
"DefaultMovies.png"),
(self.addon.getLocalizedString(32004),
"recommended&mediatype=media", "DefaultMovies.png"),
(self.addon.getLocalizedString(32007),
"inprogressandrecommended&mediatype=media", "DefaultMovies.png"),
(self.addon.getLocalizedString(32060),
"inprogressandrandom&mediatype=media", "DefaultMovies.png"),
(self.addon.getLocalizedString(32022), "similar&mediatype=media",
"DefaultMovies.png"),
(self.addon.getLocalizedString(32059), "random&mediatype=media",
"DefaultMovies.png"),
(self.addon.getLocalizedString(32058), "top250&mediatype=media",
"DefaultMovies.png"),
(self.addon.getLocalizedString(32001),
"favourites&mediatype=media", "DefaultMovies.png")
]
return process_method_on_list(create_main_entry, all_items)
def recommended(self):
''' get recommended media '''
all_items = self.movies.recommended()
all_items += self.tvshows.recommended()
all_items += self.albums.recommended()
all_items += self.songs.recommended()
all_items += self.episodes.recommended()
return sorted(all_items,
key=lambda k: random.random())[:self.options["limit"]]
def recent(self):
''' get recently added media '''
all_items = self.movies.recent()
all_items += self.albums.recent()
all_items += self.songs.recent()
all_items += self.episodes.recent()
all_items += self.pvr.recordings()
return sorted(all_items, key=itemgetter("dateadded"),
reverse=True)[:self.options["limit"]]
def random(self):
''' get random media '''
all_items = self.movies.random()
all_items += self.tvshows.random()
all_items += self.albums.random()
all_items += self.songs.random()
all_items += self.episodes.random()
all_items += self.pvr.recordings()
return sorted(all_items,
key=lambda k: random.random())[:self.options["limit"]]
def inprogress(self):
''' get in progress media '''
all_items = self.movies.inprogress()
all_items += self.episodes.inprogress()
all_items += self.pvr.recordings()
return sorted(all_items, key=itemgetter("lastplayed"),
reverse=True)[:self.options["limit"]]
def similar(self):
''' get similar movies and similar tvshows for given imdbid'''
all_items = self.movies.similar()
all_items += self.tvshows.similar()
all_items += self.albums.similar()
all_items += self.songs.similar()
return sorted(all_items,
key=lambda k: random.random())[:self.options["limit"]]
def inprogressandrecommended(self):
''' get recommended AND in progress media '''
all_items = self.inprogress()
all_titles = [item["title"] for item in all_items]
for item in self.recommended():
if item["title"] not in all_titles:
all_items.append(item)
return all_items[:self.options["limit"]]
def inprogressandrandom(self):
''' get in progress AND random movies '''
all_items = self.inprogress()
all_ids = [item["movieid"] for item in all_items]
for item in self.random():
if item["movieid"] not in all_ids:
all_items.append(item)
return all_items[:self.options["limit"]]
def top250(self):
''' get imdb top250 movies in library '''
all_items = self.movies.top250()
all_items += self.tvshows.top250()
return sorted(all_items,
key=itemgetter("top250_rank"))[:self.options["limit"]]
def favourites(self):
'''get favourite media'''
from favourites import Favourites
self.options["mediafilter"] = "media"
return Favourites(self.addon, self.artutils, self.options).favourites()
def favourite(self):
'''synonym to favourites'''
return self.favourites()
#!/usr/bin/python
# -*- coding: utf-8 -*-
import os
from flask import Flask, render_template
from flask_caching import Cache
from movies import Movies
from people import People
mov = Movies()
pep = People()
def main():
FLASK_DEBUG = False
app = create_app()
app.run(port=8000, debug=FLASK_DEBUG, threaded=True)
def create_app():
app = Flask(__name__, instance_relative_config=True)
config = {'DEBUG': True}
app.config.from_mapping(config)
cache = Cache(app,
config={
'CACHE_TYPE': 'simple',
'CACHE_DEFAULT_TIMEOUT': 60
})
@app.route('/movies/', methods=['GET'])
@cache.cached(timeout=60)
def fetchMoviesWithPeople():
'''
def test_get_movie_name(self):
db = "cinema.db"
movies = Movies(db)
movie = movies._get_movie_name(1)
self.assertEqual(movie, "The Hunger Games: Catching Fire")
from movies import Movies
movie = Movies()
filename = 'data.json'
moviedata = movie.get_movies_data(filename)
# Serach movie details by title
# searchtext = "Indian"
searchtext = str(input("Please enter movie title to search: "))
movie.search_movie(moviedata, searchtext)
from movies import Movies
import json
class mydict(dict):
def __str__(self):
return json.dumps(self)
title = str(input("Please add movie title: "))
genre = str(input("Please add movie genre: "))
year = str(input("Please add movie year: "))
movieDetails = [['title', title], ['genre', genre], ['year', year]]
moviedetails = mydict(movieDetails)
movie = Movies()
filename = 'data.json'
moviedata = movie.get_movies_data(filename)
movie.add_movies(filename, moviedata, moviedetails)
print(moviedata)
def show_movies(self):
return Movies.all_movies(self.__conn)
import inspect
import json
import os
from bson import json_util
from flask import Response, request, Flask, render_template
from typing import Any, Dict
from movies import Movies
from util.flask.flask_utils import reroute_to, preconditions, form_contains
app = Flask(__name__, static_url_path='')
movies = Movies()
@app.route('/')
def index():
# type: () -> Response
return render_template('index.html')
@app.route('/movies_queries', methods=['GET', 'POST'])
def movies_queries():
# type: () -> Response
return json.dumps(movies.queries())
@app.route('/bad', methods=['GET', 'POST'])
def bad_request():
# type: () -> Response
from movies import Movies test = Movies() print(test.get_movie())
from movies import Movies
movie = Movies()
filename = 'data.json'
moviedata = movie.get_movies_data(filename)
reportType = int(
input("Please enter number 1 for Genre 2 for year wise report: "))
if reportType == 1:
# report by genre
genre = str(input("Please enter Genre: "))
movie.report_by_genre(moviedata, genre)
elif reportType == 2:
# report by year
year = int(input("Please enter Year: "))
movie.report_by_year(moviedata, year)
else:
print("Wrong Input!")
# Add module paths
import sys
# Import modules
import fresh_tomatoes
from movies import Movies
# Load movies
movieManager = Movies()
movieManager.loadFile('./data/data.json')
movieManager.saveToFile('./data/data.json')
# Pass movie data to be rendered
fresh_tomatoes.open_movies_page(movieManager.data)
from movies import Movies
movie = Movies()
filename = 'data.json'
moviedata = movie.get_movies_data(filename)
searchtext = str(input("Please enter movie title to delete: "))
movie.delete_movie(moviedata, searchtext, filename)
def add_movie(self):
return Movies.add_movie(self.__conn)
'''
CODERS: CRISPEN && BONGA
DESCRIPTION: GETTING HTTP REQUEST USING THE REQUESTS MODULE IN PYTHON
[CREATING AN EXTERNAL MODULE IN PYTHON]
THIS MODULE WILL ALLOW US TO GET MOVIES INFOMATION FROM AN
API
'''
API_KEY = "API_KEY"
QUERY_STRING ="gamers"
from movies import Movies
if(Movies.get_movies_or_404("", API_KEY, QUERY_STRING) == None or "" ):
pass
else:
print(Movies.get_movies_or_404("", API_KEY, QUERY_STRING))
from movies import Movies
movie = Movies()
filename = 'data.json'
moviedata = movie.get_movies_data(filename)
searchtitle = str(input("Please enter movie title to update: "))
updatetitle = str(input("Please enter Updated movie title: "))
movie.update_movie(moviedata, searchtitle, updatetitle, filename)
def get_movie_by_id(self, m_id):
return Movies.get_movie_by_id(self.__conn, m_id)
def findDirectorMovies(self):
with DB() as db:
values = (self.id,)
rows = db.execute('SELECT * FROM Movies WHERE directorId = ?', values).fetchall()
return [Movies(*row) for row in rows]
def remove_movie_by_name(self, movie_name):
return Movies.delete_movie_by_name(self.__conn, movie_name)
