def get_genre_based_recommendations(self, max_recommendations):
"""
Returns movie recommendations solely based on personality-genre associations.
Returns the recommendations as well as the list of genres for this user.
"""
genres = get_genres_for_user(self, max_distance=2, max_genres=4)
genre_ids = [
g['id'] for g in tmdb.Genres().movie_list()['genres']
if g['name'] in genres
]
recommendations = []
args = {
'page': 1,
'vote_count_gte': 20,
'vote_average_gte': 7,
'sort_by': 'vote_average.desc'
}
# If at least one rule can be applied, predict movies of the associated genres with a high rating.
# Otherwise, just predict movies of all genres with high ratings.
if len(genres) > 0:
args['with_genres'] = genre_ids
recs = tmdb.Discover().movie(**args)
recommendations += recs['results']
rated_movie_ids = [
r.movie.tmdb_id for r in Rating.objects.filter(rated_by=self)
]
# Filter out movies that the user has already seen
recommendations = [
r for r in recommendations if r['id'] not in rated_movie_ids
]
while len(recommendations) < max_recommendations and recs[
'page'] < recs['total_pages']:
args['page'] += 1
recs = tmdb.Discover().movie(**args)
recommendations += recs['results']
# Filter out movies that the user has already seen
recommendations = [
r for r in recommendations if r['id'] not in rated_movie_ids
]
if len(recommendations) > max_recommendations:
recommendations = recommendations[:max_recommendations]
# Save recommended Movies in DB
for rec in recommendations:
movie = Movie.objects.filter(tmdb_id=rec['id'])
if not movie.exists():
Movie(tmdb_id=rec['id'], title=rec['title']).save()
return recommendations, genres
def discover_by_filter(self, content_type, **kwargs):
"""Filter by keywords or any other TMDB filter capable arguements.
(see tmdbsimple discover.movie and discover.tv)
Args:
content_type: String containing "movie" or "tv".
# Additional kwargs #
keyword: A single String or a List of strings.
_______: Any other values supported by tmdbsimple discover.movie or discover.tv.
"""
try:
if kwargs.__contains__("keyword"):
# Convert all keywords to IDs
keyword_ids = self.__keywords_to_ids(kwargs["keyword"])
if keyword_ids is not None:
kwargs["with_keywords"] = keyword_ids
# Remove keyword strings (invalid parameters)
kwargs.__delitem__("keyword")
# Perform a discovery search for a movie
if content_type.lower() == "movie":
return cache.handler(
"discover movie cache",
function=tmdb.Discover().movie,
page_key=str(kwargs),
cache_duration=DISCOVER_BY_FILTER_CACHE_TIMEOUT,
**kwargs,
)
# Perform a discovery search for a TV show
if content_type.lower() == "tv":
return cache.handler(
"discover tv cache",
function=tmdb.Discover().tv,
page_key=str(kwargs),
cache_duration=DISCOVER_BY_FILTER_CACHE_TIMEOUT,
**kwargs,
)
# Content Type was invalid
log.handler(
"Invalid content_type " + str(content_type) +
" in discover().",
log.WARNING,
self.__logger,
)
return {}
except:
log.handler("Failed to discover!", log.ERROR, self.__logger)
return {}
def getMoviesByYear(year, dbFileName):
# get total pages from discovery query
while (True):
try:
discover = tmdb.Discover()
discoverResponse = discover.movie(page=1,
language='en-US',
sort_by='release_date.asc',
include_adult=True,
primary_release_year=year)
numPages = discover.total_pages
break
except:
print(
f'\tError when getting page number, retrying in {retry_time} secs'
)
time.sleep(retry_time)
# iterate through each page and get info
for currentPage in range(1, numPages + 1):
print(f'Page: {currentPage} / {numPages}')
while (True):
try:
discover = tmdb.Discover()
discoverResponse = discover.movie(page=currentPage,
language='en-US',
sort_by='release_date.asc',
include_adult=True,
primary_release_year=year)
break
except:
print(f'Error when getting page, retying in {retry_time} secs')
time.sleep(retry_time)
for item in discover.results:
discoverId = item['id']
# get Movies by id because discover does not include all info
movieRow = getMovie(discoverId)
# moviesDf = moviesDf.append(movieRow)
# append movie to csv file
movieRow.to_csv(dbFileName,
mode='a',
header=False,
encoding='utf-8')
def discover_tv_by_filter(self,
filter_name,
page_number,
page_multiplier=1,
add_values=(),
**kwargs):
"""Obtains TV results based on a predefined filter name."""
if filter_name == "custom":
filter_params = kwargs
else:
filter_params = tv_filters(filter_name,
slug=True,
add_values=add_values)
return self._set_content_attributes(
"tv",
self._multi_page_fetch(
"discover filter " + filter_name + " tv",
tmdb.Discover().tv,
page_number,
page_multiplier,
timezone=_timezone,
**filter_params,
),
)
def getPopularTvWithGenre(genreList=[], pageNum=1):
tmdbdiscover = tmdb.Discover()
genreQuery = ""
for genre in genreList:
# If the genre is a string, find the associated ID
if (isinstance(genre, str)):
genreId = getGenreId(genre)
genreQuery += str(genreId) + ","
else:
genreQuery += str(genre) + ","
# If the genreQuery is not empty (i.e. specific genres were given, remove the trailing comma)
if (genreQuery != ""):
genreQuery = genreQuery[:-1]
response = tmdbdiscover.tv(with_genres=genreQuery, page=pageNum)
popularTvListWithGenre = []
for item in response["results"]:
popularTvListWithGenre.append(
Tv(item["name"], item["id"], item["vote_average"],
item["genre_ids"], item["overview"], str(item["poster_path"])))
return popularTvListWithGenre
def getPopularMoviesWithGenre(genreList=[], pageNum=1):
tmdbdiscover = tmdb.Discover()
genreQuery = ""
for genre in genreList:
# If the genre is a string, find the associated ID
if (isinstance(genre, str)):
genreId = getGenreId(genre)
genreQuery += str(genreId) + ","
else:
genreQuery += str(genre) + ","
if (genreQuery != ""):
genreQuery = genreQuery[:-1]
response = tmdbdiscover.movie(with_genres=genreQuery, page=pageNum)
popularMovieListWithGenre = []
for item in response["results"]:
popularMovieListWithGenre.append(
Movie(item["title"], item["id"],
item["vote_average"], item["genre_ids"], item["overview"],
str(item["poster_path"])))
return popularMovieListWithGenre
def get_movie_agg(d_d, pages, max=10):
movie_agg = []
for page in range(1, pages):
d_d['page'] = page
movie_l = tmdb.Discover().movie(**d_d)
movie_l = movie_l['results']
# 获取该列表每个元素的detail
for movie in movie_l:
try:
detail = get_movie_detail(movie['id'])
if detail:
movie_agg.append(detail)
if len(movie_agg) >= max:
return sorted(movie_agg,
key=lambda movie: bool(movie['subtitle']),
reverse=True)
except:
print('-' * 30)
traceback.print_exc()
pprint(movie)
print('-' * 30)
return sorted(movie_agg,
key=lambda movie: bool(movie['subtitle']),
reverse=True)
def get_cast_names(self):
# Get the top movies for a year (10 per page)
kwargs = {'primary_release_year': self.year, 'page': '1'}
disc_obj = tmdb.Discover()
top = disc_obj.movie(**kwargs)
movies = top['results']
movie_ids = []
for item in movies:
movie_ids.append(item['id'])
for id in movie_ids:
movie = tmdb.Movies(id)
response = movie.info()
print(movie.title)
cast = movie.credits()['cast']
names_list = []
for value in cast:
if not self.has_numbers(value['character']):
for n in value['character'].split(' '):
if n == '(voice)' or n is '/' or n is '|':
continue
names_list.append(n)
for n in value['name'].split(' '):
names_list.append(n)
print(names_list)
self.count_instances(movie.title, names_list)
def tmdb_api_discover(args):
"""TMDB API call to discover movie from the filter"""
tmdb.API_KEY = _tmdb['apikey']
discover = tmdb.Discover()
kwargs = {
'page': 1,
'vote_average.gte': 6,
'year': 2015,
'with_genres': 35
}
if args.type == "movies":
response = discover.movie(**kwargs)
else:
response = discover.tv(**kwargs)
if args.verbose:
print("TMDB fetched page {page} of {total} pages".format(
total=response['total_pages'], page=response['page']))
print("TMDB found {total} items".format(total=response['total_results']))
results = response['results']
while int(response['page']) < int(response['total_pages']):
kwargs = {
'page': response['page'] + 1,
'vote_average.gte': 6,
'year': 2015,
'with_genres': 35
}
response = discover.movie(**kwargs)
if args.verbose:
print("TMDB fetched page {page} of {total} pages".format(
total=response['total_pages'], page=response['page']))
results += response['results']
return results
def createCorpus(filename, pagesMax=1000):
"""
Load and store abstracts on TMDB, in text file
Parameters:
filename -> String, name of the file where resumes will be stored
pagesMax -> int, number of page to download from tmdb (default: pagesMax=1000)
"""
fileAbstracts = codecs.open(filename, "w", 'utf-8')
# Download stopwords if not present
if not isdir(path[0]):
from nltk import download
download("stopwords")
# cachedStopWords = stopwords.words("english")
for i in range(1, pagesMax):
# response = tmdb.discover.movie(page=i)
response = tmdb.Discover().movie(page=i)
filmsNb = len(response[u'results'])
for j in range(filmsNb):
abstract = response[u'results'][j][u'overview']
abstract = PreprocessText.preProcessingAbstracts(abstract)
fileAbstracts.write(abstract + '\n')
print "Creation of abstracts corpus : page %d / %d" % (i, pagesMax)
fileAbstracts.close()
def get_serials_from_api(self, attr):
search = tmdb.Discover()
for year in self.years:
response = search.tv(sort_by="release_date.desc", first_air_date_year=year, page=1)
array = self.response_to_serials(response)
self.write_to_csv(array)
total = response['total_pages']
self.count = total
for number in range(1, total+1):
response = search.tv(sort_by="release_date.desc", first_air_date_year=year, page=number)
array = self.response_to_serials(response)
self.write_to_csv(array)
self.page+=1
try:
from telegram import bot
bot.send(msg=self.msg_pattern.format(year, self.count, self.errors,self.page))
except Exception as e:
print(e)
self.count = 0
self.errors = 0
self.page=0
try:
from telegram import bot
bot.send(msg="end TV")
except Exception as e:
print(e)
def loaddata(year):
page = totalpages = 1
omdblink = 'http://www.omdbapi.com/?i={}&plot=full&r=json&tomatoes=true'
data = []
discover = tmdb.Discover()
while page <= totalpages:
try:
response = discover.movie(year = year, page = page)
totalpages = int(response['total_pages'])
movies = response['results']
for m in movies:
movie = tmdb.Movies(m['id']).info()
req = urllib.request.urlopen(omdblink.format(movie['imdb_id']))
resp = req.read().decode('utf-8')
addinfo = json.loads(resp)
movie.update(addinfo)
if movie['budget'] == 0: continue
if movie['Response'] == 'False': continue
if movie['imdbRating'] == 'N/A': continue
data.append(movie)
print('progress: {}/{} - {}% ({})'.format(page,totalpages,
round(page/totalpages*100,2),len(data)))
except Exception as e:
print('An error has occurred:\n{}'.format(e))
page += 1
time.sleep(10) # because of the request rate limit
print('completed!')
return data
def lambda_handler(event, context):
if (event is None):
return response(None, "nothing")
# check api key
if (event.get('headers').get('isobar-api-key') !=
os.environ['ISOBAR_API_KEY']):
return response(None, "key error")
if (event.get('body') is None):
return response(None, "no body")
raw_body = event.get('body')
body = json.loads(raw_body)
result = body.get('result')
# print("Received event: " + json.dumps(event, indent=2))
# return response(Exception('Invalid request token'))
# print("API KEY: "+os.environ['TMDB_API_KEY'])
tmdb.API_KEY = os.environ['TMDB_API_KEY']
# current year
now_year = datetime.datetime.now().year
# language
lang = 'zh-TW'
# searching-movie-by-date
# print("Action: "+ event["result"]["action"])
action = result["action"]
# params
date = result["parameters"]["date"][:4]
if (len(date) < 1):
date = now_year
# print("Period: "+ event["result"]["parameters"]["date-period"])
# print("year: "+ event["result"]["parameters"]["date-period"][:4])
period = result["parameters"]["date-period"][:4]
if (len(period) < 1):
period = date
# discover top 10
discover = tmdb.Discover()
speech = ''
if (action == 'searching-movie-by-date'):
result = discover.movie(page=1,
sort_by="popularity.desc",
language=lang,
year=period)
for m in result['results'][:10]:
speech = speech + m['title'] + ','
if (len(speech) > 0):
speech = str(period) + '年 好看的電影如下 ' + speech
return response(None, speech[:-1])
else:
return response(None, '')
def get_data():
title = []
image = []
discover = tmdb.Discover()
response = discover.movie(sort_by='popularity.desc')
for c in discover.results:
title.append(c['title'])
image.append('http://image.tmdb.org/t/p/w500' + c['poster_path'])
return title, image
def add_filter(request, type):
genre_lists = []
genres = []
movies = getTopRatedMovies()
genre_lists = getGenres(type)
genres = ', '.join([str(elem) for elem in request.POST.getlist('genres')])
filter_request = request.POST.copy()
if request.method == 'POST':
filter_request.pop("csrfmiddlewaretoken")
if request.POST.get("genres"):
filter_request.pop("genres")
filter_request['with_genres'] = genres
filter_request['include_adult'] = False
movies = tmdb.Discover().movie(**filter_request)
tv = tmdb.Discover().tv(**filter_request)
return [genre_lists, movies, tv]
def load_data() -> List[Dict[str, Any]]:
discover = tmdb.Discover()
data: List = []
with ProgressBar(title=MD('**Discovering Movies:**')) as pb:
def add_discover(page_num: int):
data.extend(discover.movie(page=page_num)['results'])
with ThreadPoolExecutor(max_workers=5) as executor:
future = [
executor.submit(add_discover, i)
for i in range(1, TOTAL_PAGES + 1)
]
for _ in pb(as_completed(future),
label='Querying TMDB:',
total=TOTAL_PAGES):
pass
print()
with ProgressBar(title=MD('**Compiling Information:**')) as pb:
def scan_crew(movie: Dict[str, Any]):
movie['year'] = movie['release_date'][:4]
crew = tmdb.Movies(movie['id']).credits()['crew']
for person in crew:
if person['job'] == 'Director':
if 'directors' not in movie:
movie['directors'] = [person]
else:
movie['directors'].append(person)
with ThreadPoolExecutor(max_workers=10) as executor:
future = [executor.submit(scan_crew, movie) for movie in data]
for _ in pb(as_completed(future),
label='Scanning Cast and Crew:',
total=len(data)):
pass
data = list(filter(lambda x: 'directors' in x, data))
print()
with open('data/movies.json', 'w') as f:
json.dump(data, f)
return data
def create_movies(cls):
tmdb.API_KEY = 'f1a02539ea044b6d67a19c6bb2025b94'
for i in range(1, 26, 1):
discover = tmdb.Discover()
response = discover.movie(page=i, sort_by='popularity.desc')
for s in discover.results:
movie = tmdb.Movies(s['id'])
response = movie.info()
moviee = Movie(movie.id, movie.revenue, movie.title,
movie.release_date, movie.backdrop_path,
movie.budget, movie.vote_average)
moviee.save_to_db()
def find_movies(self, request):
args = {}
if 'genres' in request and request['genres']:
args['with_genres'] = ','.join(
str(genre) for genre in request['genres'])
if 'dates' in request and request['dates']:
args['release_date_gte'] = request['dates']['from']
args['release_date_lte'] = request['dates']['to']
return tmdb.Discover().movie(**args)['results']
def request_v3_by_year(year, language="en", keys=None):
possible_keys = [
"id", "genre_ids", "title", "original_title", "video",
"original_language", "release_date", "vote_count", "vote_average",
"popularity", "adult", "poster_path", "backdrop_path", "overview"
]
retry_limit = 100
year_of_movies = []
if keys is None:
requested_keys = possible_keys
else:
requested_keys = keys
# Need id key (it's used as master key)
if "id" not in requested_keys:
requested_keys.append("id")
discover = tmdb.Discover()
# Get the number of pages
for db_request in range(0, retry_limit):
while True:
try:
movie_page = discover.movie(language="en",
primary_release_year=year)
except:
log.out.debug("HTTP error, waiting and retrying.")
time.sleep(db_request / retry_limit)
continue
break
log.out.info("Adding year: " + str(year) + " (" +
str(movie_page["total_pages"]) + " pages)")
for page_num in tqdm(range(1, movie_page["total_pages"] + 1)):
for db_request in range(0, retry_limit):
while True:
try:
movie_page = discover.movie(page=page_num,
language=language,
primary_release_year=year)
except:
log.out.debug("HTTP error, waiting and retrying.")
time.sleep(db_request / retry_limit)
continue
break
result_list = movie_page["results"]
for movie_dict in result_list:
requested_dict = {}
for key in requested_keys:
requested_dict[key] = movie_dict[key]
year_of_movies.append(requested_dict)
return year_of_movies
def sort(request):
sort_option = 'popularity.desc'
genre_option = ''
page = '1'
context = {'page_type' : 'sort_and_filter'}
tmdb.API_KEY = settings.TMDB_API_KEY
try:
discover = tmdb.Discover()
config = tmdb.Configuration().info()
POSTER_SIZE = 2
if request.method == 'POST':
context['status'] = 'success'
sort_option = request.POST['sort_by']
genre_option = request.POST['genre']
if request.POST.__contains__('prev_page'):
page = request.POST.get('prev_page', '2')
pageNumber = int(page)
page = str(pageNumber - 1)
elif request.POST.__contains__('next_page'):
page = request.POST.get('next_page', '0')
pageNumber = int(page)
page = str(pageNumber + 1)
else:
page = '1'
movie_query = discover.movie(page=page, sort_by=sort_option, with_genres=genre_option, with_release_type='2|3|4|5|6')
# For testing purposes, you can use commented query below to get result which will only return 2 pages
# movie_query = discover.movie(page=page, sort_by=sort_option, with_genres=genre_option, vote_count_gte='6234')
context['results'] = movie_query['results']
context['last_page'] = 'false'
if int(page) == movie_query['total_pages']:
context['last_page'] = 'true'
if len(context['results']) == 0:
context['status'] = 'noresult'
context['image_path'] = config['images']['base_url'] + config['images']['poster_sizes'][POSTER_SIZE]
context['sort_selected'] = sort_option
context['genre_selected'] = genre_option
context['page_num'] = page
return render(request, 'home.html', context)
except (requests.exceptions.HTTPError, tmdb.APIKeyError)as e:
print("THE API IS WRONG")
context["status"] = 'failure'
return render(request, 'home.html', context)
def get_context_data(self, **kwargs):
context = super(MoviesPageView, self).get_context_data(**kwargs)
context['genres'] = movie_genres
search = self.request.GET.get('search')
genre = self.request.GET.getlist('genre')
if search != '' and search is not None:
movies = tmdb.Search().movie(query=search)['results']
genre = [ int(i) for i in genre ]
movies = [movie for movie in movies if set(genre) == set(genre).intersection(movie['genre_ids'])]
context['movies'] = sorted(movies, key=lambda x: x['popularity'], reverse=True)
else:
genre = ', '.join(genre)
movies = tmdb.Discover().movie(sort_by='popularity.desc', with_genres=genre)['results']
context['movies'] = movies
return context
def get_context_data(self, **kwargs):
context = super(TVShowsPageView, self).get_context_data(**kwargs)
context['genres'] = tv_genres
search = self.request.GET.get('search')
genre = self.request.GET.getlist('genre')
if search != '' and search is not None:
tvshows = tmdb.Search().tv(query=search)['results']
genre = [ int(i) for i in genre ]
tvshows = [show for show in tvshows if set(genre) == set(genre).intersection(show['genre_ids'])]
context['tvshows'] = sorted(tvshows, key=lambda x: x['popularity'], reverse=True)
else:
genre = ', '.join(genre)
tvshows = tmdb.Discover().tv(sort_by='popularity.desc', with_genres=genre)['results']
context['tvshows'] = tvshows
return context
def run(self, dispatcher, tracker, domain):
#genre from user text
genre_name = tracker.get_slot('genre')
if genre_name == '':
response = "Sorry, found no genre name in that sentence. Try with different wording."
dispatcher.utter_message(response)
return [SlotSet('genre', genre_name)]
genre = tmdb.Genres()
response = genre.movie_list()
movie_id = 0
movie_genre = ''
for x in range(0, len(genre.genres)):
if genre.genres[x]['name'].lower() == genre_name:
movie_id = genre.genres[x]['id']
movie_genre = genre.genres[x]['name']
discover = tmdb.Discover()
response = discover.movie(page=1,
sort_by='popularity.desc',
include_adult=False,
include_video=False,
with_genres=movie_id)
if len(discover.results) > 0:
response = """Most popular {} movies:
{}, {},
{}, {},
{}, {},
{}, {},
{}, {}.""".format(movie_genre, discover.results[0]['title'],
discover.results[0]['release_date'],
discover.results[1]['title'],
discover.results[1]['release_date'],
discover.results[2]['title'],
discover.results[2]['release_date'],
discover.results[3]['title'],
discover.results[3]['release_date'],
discover.results[4]['title'],
discover.results[4]['release_date'])
else:
response = "Searched for genre " + genre_name + " movies but found no information. Check spelling and try again."
dispatcher.utter_message(response)
return [SlotSet('genre', genre_name)]
def home(request):
if request.method=='GET' :
tv_title = request.GET.get('keyword', False)
if tv_title:
search = tmdb.Search()
response = search.tv(query=tv_title)
tmdb_tv={'tvshows':search.results}
return render(request, 'movies/home.html',tmdb_tv)
else:
trending=tmdb.Discover()
response=trending.tv(vote_average=8)
tmdb_tv={'tvshows':trending.results}
return render(request, 'movies/home.html',tmdb_tv)
else:
trending=tmdb.Trending()
response=trending.tv()
tmdb_tv={'tvshows':trending.results}
return render(request, 'movies/home.html',tmdb_tv)
def get_popular(self, pages=5):
if len(self.current_movies) == 0: # if we don't have any previous recs
d = tm.Discover() # Setting discovery mode for the API
movies = []
a = []
for i in range(1, pages):
movies.append(
d.movie(sort_by=[
'vote_count.desc'
], page=i)['results']) # get 5 pages with most vote counts
flatten = [
item for sublist in movies for item in sublist
] # Since we get a list of lists of dicts we have to flatten it to one list of dicts
flatten = sorted(flatten,
key=lambda k: k['vote_average'],
reverse=True) # sort them by vote_average
self.current_movies = flatten
else: # if we just want to sort the current selection by popularity
self.current_movies = sorted(
self.current_movies,
key=lambda k: k['vote_average'],
reverse=True) # sort them by vote_average
def handle(self, *args, **options):
year, curr_page, percentage = options['year'], options[
'page'], options['percentage']
discover = tmdb.Discover()
response = discover.movie(primary_release_year=year, page=curr_page)
total_pages = response['total_pages']
needed_pages = int(total_pages * percentage / 100)
print('Going tot process {} pages(Total: {})'.format(
needed_pages, total_pages))
while curr_page <= needed_pages:
print('####################### {} page ########################'.
format(curr_page))
response = discover.movie(primary_release_year=year,
page=curr_page)
ids = [item['id'] for item in response['results']]
for id in ids:
upload_movie(id)
curr_page += 1
def _execute_search_preset(self, search_config) -> list:
"""Given an search preset, execute it."""
try:
media_type = search_config['media_type']
discover = tmdb.Discover()
search_args = json.loads(search_config['search_args'])
# if the user wants to search by genre, we need to get the genre's ids first
if 'with_genres' in search_args:
search_args['with_genres'] = self._get_genres_id(
search_args['with_genres'], media_type)
search_args['page'] = self.current_page
search_args['language'] = self.settings['language']
results = getattr(
discover,
media_type)(**search_args) # discover.tv(), discover.movie()
total_pages = 1
if 'total_pages' in results:
total_pages = results['total_pages']
return self._create_suggestions(results['results'], total_pages,
media_type)
except tmdb.base.APIKeyError as exc:
print(exc)
return [
ErrorSuggestion('TMDB API key not configured/invalid!',
'No results found')
]
except Exception as exc:
print(exc)
return [
ErrorSuggestion(
'There was an error trying to connect to TMDB API.',
'No results found')
]
def next_page(self):
if self.TotalPages and self.Page >= self.TotalPages:
raise Exception("already got all page for year: {}".format(
self.Year))
discover = tmdb.Discover()
discovered = discover.movie(primary_release_year=self.Year,
include_adult=False,
page=self.Page)
movies = discovered['results']
self.TotalPages = discovered['total_pages']
for movieinfo in movies:
counter = GenderCounter(movieinfo)
insert_stmt = insert(GenderCounter).\
values(Id=counter.Id,
Title=counter.Title,
Popularity=counter.Popularity,
Valid=counter.Valid,
Year=counter.Year,
Fetched=counter.Fetched)
do_nothing_stmt = insert_stmt.on_conflict_do_nothing(
index_elements=['Id'])
conn.execute(do_nothing_stmt)
self.Page += 1
def get_movies(request):
json_data = json.loads(request.body)
print('json_data',json_data)
params = json_data['params']
# This is basically a list of options that will be passed to the request.
my_kwargs = {}
# We're looking into our params object passed in as part of our request body, and constructing our my_kwargs list based on what params exist on the params object. There may be a cleaner way to do this, though we have to parse the data within the params anyways so they have the proper, expected syntax.
if 'genres' in params:
genres = '|'.join(str(x) for x in params['genres'])
my_kwargs['with_genres'] = genres
# print('genres',genres)
if 'dateFrom' in params:
dateFrom = params['dateFrom']
dateFromFormatted = dateFrom + '-01-01'
my_kwargs['primary_release_date_gte'] = dateFromFormatted
# print('dateFromFormatted',dateFromFormatted)
if 'dateTo' in params:
dateTo = str(int(params['dateTo']) + 1)
dateToFormatted = dateTo + '-01-01'
my_kwargs['primary_release_date_lte'] = dateToFormatted
# print('dateToFormatted',dateToFormatted)
if 'page' in params:
my_kwargs['page'] = params['page']
# print('page',my_kwargs['page'])
# print('my_kwargs',my_kwargs)
discover = tmdb.Discover()
response_data = discover.movie(**my_kwargs)
return JsonResponse({'tmdb_results': response_data})
# -*- coding: utf-8 -*-
import tmdbsimple as tmdb
tmdb.API_KEY = '5f8e77cffdf729efe6cb173496ddf5f1'
DISCOVER_YEAR = 2018
discover = tmdb.Discover()
response = discover.movie(page=1, year=DISCOVER_YEAR)
# for i in response['results']:
# print(i['title'])
movie = tmdb.Movies()
response = movie.now_playing()
for i in response['results']:
print(i['original_title'])
print(i['poster_path'])
print(i['overview'])
print(i['id'])
print(i['genre_ids'])
genres = tmdb.Genres()
response = genres.movie_list(language='id')
# for i in response['genres']:
# print(i['name'])
genres.id = '28'
response = genres.movies(page='1', language='id')
# for i in response['results']:
# print(i['title'])
