def search_movie(request):
if request.method == 'GET':
form = FilmSearchForm()
return render(request, 'save_search.html', {'form': form})
elif request.method == 'POST':
form = FilmSearchForm(request.POST)
if form.is_valid():
tmdb = TMDb()
tmdb.api_key = os.environ['KEY-MDB']
movie = Movie()
query = request.POST.get('query', 'Marlina')
search = movie.search(query)
db, token, uid = initializationDb()
for p in search:
data = {
"id": p.id,
"title": p.title,
"overview": p.overview,
"poster_path": p.poster_path,
"release_date": p.release_date,
"popularity": p.popularity,
"original_title": p.original_title,
"vote_count": p.vote_count,
"vote_average": p.vote_average
}
db.child(uid).child("movie_list").child(p.id).set(data, token)
response = {"status": 200, "message": "Success Save"}
return JsonResponse(response)
else:
response = {"status": 401, "message": "Invalid Input"}
return JsonResponse(response)
def single_page(request, movie_id):
conn = http.client.HTTPSConnection("api.themoviedb.org")
tmdb3 = TMDb()
tmdb3.api_key = 'bf4a7e22bb42072d024a9c1b6f88597f'
movie = Movie()
details = movie.details(movie_id)
credits = movie.credits(movie_id)
conn.request(
"GET",
"/3/movie/" + str(movie_id) + "/translations?api_key=" + tmdb3.api_key)
res = conn.getresponse()
data = res.read()
json_data = json.loads(data)
translations = json_data['translations']
rus = []
for indx in range(0, 10):
if translations[indx]['iso_639_1'] == 'ru':
rus = translations[indx]
context = {
'details': details,
'credits': credits,
"rus": rus,
}
return render(request, "kinopoiskapi/single.html", context)
def search_movie(query):
tmdb = TMDb()
tmdb.api_key = 'PLEASE GENERATE UR OWN API KEY, ALL INFO IN README FILE'
movie = Movie()
result = movie.search(query)
number_of_movies = len(result)
if number_of_movies == 0:
print("SORRY, I CAN'T FIND ANYTHING, PLEASE TRY ANOTHER PHRASE")
else:
random_movie_title = choice(result).title
print(
f'I have found {number_of_movies} movies, here is a random choice for you:'
)
print(f'Title: {random_movie_title}')
for res in result:
if res.title == random_movie_title:
if res.overview == "":
print('Sorry, no plot available :c')
else:
print(f'Movie id: {res.id}')
print(f'Plot: {res.overview}')
print(f'Released in {res.release_date}')
similar = movie.similar(res.id)
for sim in similar:
print(
f'Similar movie: {sim} (movie id: {sim.id}), released in {sim.release_date}'
)
break
break
def popular_movie(request):
if request.method == 'GET':
return render(request, 'search_popular.html')
elif request.method == 'POST':
tmdb = TMDb()
tmdb.api_key = os.environ['KEY-MDB']
movie = Movie()
popular = movie.popular()
db, token, uid = initializationDb()
db.child("movie_popular").remove(token)
for p in popular:
data = {
"id": p.id,
"title": p.title,
"overview": p.overview,
"poster_path": p.poster_path,
"release_date": p.release_date,
"popularity": p.popularity,
"original_title": p.original_title,
"vote_count": p.vote_count,
"vote_average": p.vote_average
}
db.child(uid).child("movie_popular").child(p.id).set(data, token)
response = {"status": 200, "message": "Success Save"}
return JsonResponse(response)
def add_poster(self, movie_title):
import requests
from PyQt5.QtGui import QIcon, QPixmap
from tmdbv3api import TMDb
from tmdbv3api import Movie
tmdb = TMDb()
tmdb.api_key = '1437062848d1dda19bd3907cf120e9f4'
tmdb.language = 'en'
#tmdb.debug = True
movie = Movie()
m = movie.search(movie_title)
for i in m:
continue_path = i.poster_path
if continue_path != "None":
continue_path = i.poster_path
#print(continue_path)
break
url = 'http://image.tmdb.org/t/p/w185'
combine = url + continue_path
#readlink
href = combine
r = requests.get(href, stream=True)
pixmap = QPixmap()
pixmap.loadFromData(r.content)
self.poster.setPixmap(pixmap)
self.poster.setScaledContents(True) #fullsizepic
self.poster.show()
def __init__(self):
# key = self.load_api_key()
tmdb = TMDb()
tmdb.api_key = '76796d972576af7067d952e53839883b'
tmdb.language = 'en'
tmdb.debug = True
self.tmdb = tmdb
def getMovies(self):
tmdb = TMDb()
tmdb.api_key = '1dc5bcb73c0781470cb348d5e02a05a5'
tmdb.language = 'en'
tmdb.debug = False
movie = Movie()
self.movie = movie
self.popular = movie.popular()
self.now = movie.now_playing()
self.top = movie.top_rated()
discover = Discover()
self.movie_discovered = discover.discover_movies(
{'sort_by': 'vote_average.desc'})
lists = [self.top, self.now, self.popular, self.movie_discovered]
self.all_movies = []
for li in lists:
for m in li:
exist = False
for r in self.all_movies:
if r.id == m.id:
exist = True
if (not exist):
self.all_movies.append(m)
def discoverMedia(self, start_date, end_date):
sd_str = datetime.strftime(start_date, '%Y-%m-%d')
ed_str = datetime.strftime(end_date, '%Y-%m-%d')
tmdb = TMDb()
tmdb.api_key = tmdb_key
tmdb.language = 'en'
discover = Discover()
movies = discover.discover_movies({
'primary_release_date.gte': sd_str,
'primary_release_date.lte': ed_str
})
for res in movies:
try:
Media.objects.get(external_id=res.id)
continue
except Media.DoesNotExist as ex:
if res.release_date == '':
res.release_date = None
if res.poster_path == None:
poster = "https://lascrucesfilmfest.com/wp-content/uploads/2018/01/no-poster-available-737x1024.jpg"
else:
poster = "https://www.themoviedb.org/t/p/w600_and_h900_bestv2" + res.poster_path
Media.objects.create(
title = res.title,
description = res.overview,
poster_url = poster,
release_date = res.release_date,
media_type= "Movie",
external_id= res.id
)
series = discover.discover_tv_shows({
'first_air_date.gte': sd_str,
'first_air_date.lte': ed_str
})
for res in series:
if res.first_air_date == '':
res.first_air_date = None
if res.poster_path == None:
poster = "https://lascrucesfilmfest.com/wp-content/uploads/2018/01/no-poster-available-737x1024.jpg"
else:
poster = "https://www.themoviedb.org/t/p/w600_and_h900_bestv2" + res.poster_path
try:
Media.objects.get(external_id=res.id)
continue
except Media.DoesNotExist as ex:
Media.objects.create(
title = res.name,
description = res.overview,
poster_url = poster,
release_date = res.first_air_date,
media_type= "TV",
external_id= res.id
)
def start(self):
movie = Movie()
if self.enviroment == "development":
self.enviroment="localhost"
else:
self.enviroment="docker_redis"
self.redis_server = redis.StrictRedis(host=self.enviroment, port=6379, db=0)
tmdb = TMDb()
tmdb.api_key = self.api_key
self.getPopular(movie)
def query_api(self, name):
tmdb = TMDb()
tmdb.api_key = tmdb_key
tmdb.language = 'en'
#search movies
movie = Movie()
search_movie = movie.search(name)
for res in search_movie:
try:
Media.objects.get(external_id=res.id)
continue
except Media.DoesNotExist as ex:
if res.release_date == '':
res.release_date = None
if res.poster_path == None:
poster = "https://lascrucesfilmfest.com/wp-content/uploads/2018/01/no-poster-available-737x1024.jpg"
else:
poster = "https://www.themoviedb.org/t/p/w600_and_h900_bestv2" + res.poster_path
Media.objects.create(
title = res.title,
description = res.overview,
poster_url = poster,
release_date = res.release_date,
media_type= "Movie",
external_id= res.id
)
#search TV
tv = TV()
search_tv = tv.search(name)
for res in search_tv:
if res.first_air_date == '':
res.first_air_date = None
if res.poster_path == None:
poster = "https://lascrucesfilmfest.com/wp-content/uploads/2018/01/no-poster-available-737x1024.jpg"
else:
poster = "https://www.themoviedb.org/t/p/w600_and_h900_bestv2" + res.poster_path
try:
Media.objects.get(external_id=res.id)
continue
except Media.DoesNotExist as ex:
Media.objects.create(
title = res.name,
description = res.overview,
poster_url = poster,
release_date = res.first_air_date,
media_type= "TV",
external_id= res.id
)
def imdb_get_movies(config_path, plex, data):
title_ids = data[1]
print("| {} Movies found on IMDb".format(len(title_ids)))
tmdb = TMDb()
tmdb.api_key = config_tools.TMDB(config_path).apikey
movie = Movie()
imdb_map = {}
matched_imdb_movies = []
missing_imdb_movies = []
current_length = 0
current_count = 0
plex_tools.create_cache(config_path)
plex_movies = plex.Library.all()
for m in plex_movies:
current_count += 1
print_display = "| Processing: {}/{} {}".format(current_count, len(plex_movies), m.title)
print(adjust_space(current_length, print_display), end="\r")
current_length = len(print_display)
if 'plex://' in m.guid:
item = m
# Check cache for imdb_id
imdb_id = plex_tools.query_cache(config_path, item.guid, 'imdb_id')
if not imdb_id:
imdb_id, tmdb_id = plex_tools.alt_id_lookup(plex, item)
print(adjust_space(current_length, "| Cache | + | {} | {} | {} | {}".format(item.guid, imdb_id, tmdb_id, item.title)))
plex_tools.update_cache(config_path, item.guid, imdb_id=imdb_id, tmdb_id=tmdb_id)
elif 'themoviedb://' in m.guid:
if not tmdb.api_key == "None":
tmdb_id = m.guid.split('themoviedb://')[1].split('?')[0]
tmdbapi = movie.details(tmdb_id)
imdb_id = tmdbapi.imdb_id if hasattr(tmdbapi, 'imdb_id') else None
else:
imdb_id = None
elif 'imdb://' in m.guid:
imdb_id = m.guid.split('imdb://')[1].split('?')[0]
else:
imdb_id = None
if imdb_id and imdb_id in title_ids:
imdb_map[imdb_id] = m
else:
imdb_map[m.ratingKey] = m
print(adjust_space(current_length, "| Processed {} Movies".format(len(plex_movies))))
for imdb_id in title_ids:
movie = imdb_map.pop(imdb_id, None)
if movie:
matched_imdb_movies.append(plex.Server.fetchItem(movie.ratingKey))
else:
missing_imdb_movies.append(imdb_id)
return matched_imdb_movies, missing_imdb_movies
def initTmdb(api_key):
""" Returns a TMDB object initialized with the given api key
Args:
api_key (str) : TMDB api key
Returns:
tmdb : TMDB object
"""
tmdb = TMDb()
tmdb.api_key = api_key
tmdb.language = 'en'
return tmdb
def index(request):
tmdb3 = TMDb()
tmdb3.api_key = 'bf4a7e22bb42072d024a9c1b6f88597f'
movie = Movie()
popular = movie.popular()
for p in popular:
print(p.title)
print(p.poster_path)
print("===================BREAKLINE=====================")
context = {'popular': popular}
return render(request, "kinopoiskapi/kinopoisk.html", context)
def ViewGroup(request, pk):
#When a groups is clicked on - all the details
#pk is group id
#Recommender is in group_recommender.py
template_name = 'movies/group_details.html'
tmdb = TMDb()
tmdb.api_key = '69c1026aa20e6449c7a0f74f69dffd7d'
tmdb.language = 'en'
people = GroupUsers.objects.filter(group_id=pk)
group_name = GroupInfo.objects.filter(group_id=pk)
group_movies = GroupMovieList.objects.filter(group_id=pk)
m = []
vote_score = []
test = []
#Getting movies for watch list
for movie in group_movies:
vote_score.append(movie.vote)
my_movies = Movie.objects.filter(movie_id=movie.movie_id)
for mov in my_movies:
tmdbId = mov.tmdbId
movs = tmdb_movie()
m.append(movs.details(tmdbId))
#Appending the vote count to the TMDB api link of top movies
for index, i in enumerate(m):
test.append((i, vote_score[index]))
#Getting recommendations for group
merging = []
for user in people:
u_id = user.user_id
user_info = UserProfile.objects.filter(id=u_id)
for users in user_info:
user_age = users.Age
user_occupation = users.Occupation
rec_movs = group_rec(user_age, user_occupation)
rec_movs = rec_movs.index.values.tolist()
merging.extend(rec_movs)
all_mov = [word for word, word_count in Counter(merging).most_common(10)]
id = pk
args = {
'id': id,
'test': test,
'people': people,
'group_name': group_name,
'group_movies': group_movies,
'm': m,
'merging': merging,
'all_mov': all_mov
}
return render(request, template_name, args)
def Top10(request):
#Display top 10 rated movies
template_name = 'movies/movie_list.html'
top_movies = TopMovies.objects.all()
tmdb = TMDb()
tmdb.api_key = '69c1026aa20e6449c7a0f74f69dffd7d'
tmdb.language = 'en'
movie = tmdb_movie()
m = []
for mov in top_movies:
m.append(movie.details(mov.tmdbId))
args = {'top_movies': top_movies, 'm': m}
return render(request, template_name, args)
def IMDBtoTMDB(args):
if args.tmdb != "AUTO-DETECT":
return
format = ""
movie = Movie()
tv = TV()
tmdb = TMDb()
tmdb.api_key = args.tmdbapi
if (args.type == "TV"):
format = 'tv_results'
if (args.type == "Movie"):
format = 'movie_results'
tmdb = movie.external(f"{args.imdb}", f'imdb_id')
if len(tmdb.get(format)) != 0:
args.tmdb = tmdb.get(format)[0].get("id", "")
def imdb_get_movies(config_path, plex, data):
tmdb = TMDb()
movie = Movie()
tmdb.api_key = config_tools.TMDB(config_path).apikey
imdb_url = data
if imdb_url[-1:] == " ":
imdb_url = imdb_url[:-1]
imdb_map = {}
library_language = plex.Library.language
try:
r = requests.get(imdb_url,
headers={'Accept-Language': library_language})
except requests.exceptions.MissingSchema:
return
tree = html.fromstring(r.content)
title_ids = tree.xpath("//div[contains(@class, 'lister-item-image')]"
"//a/img//@data-tconst")
if title_ids:
for m in plex.Library.all():
if 'themoviedb://' in m.guid:
if not tmdb.api_key == "None":
tmdb_id = m.guid.split('themoviedb://')[1].split('?')[0]
tmdbapi = movie.details(tmdb_id)
imdb_id = tmdbapi.imdb_id
else:
imdb_id = None
elif 'imdb://' in m.guid:
imdb_id = m.guid.split('imdb://')[1].split('?')[0]
else:
imdb_id = None
if imdb_id and imdb_id in title_ids:
imdb_map[imdb_id] = m
else:
imdb_map[m.ratingKey] = m
matched_imbd_movies = []
missing_imdb_movies = []
for imdb_id in title_ids:
movie = imdb_map.pop(imdb_id, None)
if movie:
matched_imbd_movies.append(
plex.Server.fetchItem(movie.ratingKey))
else:
missing_imdb_movies.append(imdb_id)
return matched_imbd_movies, missing_imdb_movies
def scrape_images(filepath, save_to='media/images/'):
"""
Takes path to a csv file as argument and uses
TMDB API to download images by searching
for title
"""
BASE_IMG_URL = 'https://image.tmdb.org/t/p/w500'
tmdb = TMDb()
tmdb.api_key = TMDB_API_KEY
tmdb.language = 'en'
tmdb.debug = True
with open(filepath, 'r') as f:
reader = csv.DictReader(f)
movie = Movie()
tv = TV()
for i, row in enumerate(reader):
title = row['title']
print(f'{i} Title: {title}')
if row['type'] == 'TV Show':
res = tv.search(title)
else:
res = movie.search(title)
if len(res) == 0:
print('No results found')
continue
elif len(res) > 1:
print('Length of results: ', len(res))
print(res)
# Check to see if image is available
try:
image_url = BASE_IMG_URL + res[0].poster_path
except TypeError as e:
print('No image available')
continue
image_response = requests.get(image_url)
if image_response.status_code == 200:
with open(save_to + row['show_id'] + '.jpg', 'wb') as f:
f.write(image_response.content)
else:
print(f'Error retreiving image for: {title}')
print(f'Status code: {image_response.status_code}')
time.sleep(0.1)
def init():
movieName = input("\nMovie Name?")
tmdb = TMDb()
tmdb.api_key = "10163a322f4558e7cc6411377702d81d"
movie = Movie()
try:
search = movie.search(movieName)
if search is not None:
for e in search:
movieID = e.id
break
else:
movieID = None
m = movie.details(movieID)
initial_budget = m.budget
revenue = m.revenue
title = m.original_title
print("-Full name: " + title)
if (initial_budget is not 0):
print("-Intial Budget: " + (str(int(initial_budget))))
else:
print(
"NO INITIAL BUDGET REPORTED. DO NOT USE THIS ENTRY FOR TRAINING DATA."
)
if (revenue is not 0):
print("-Revenue: " + (str(int(revenue))))
else:
print(
"NO REVENUE REPORTED. DO NOT USE THIS ENTRY FOR TRAINING DATA."
)
exit()
except:
print("\nBad movie entry?")
return title, initial_budget, revenue
def buscar():
if request.method == 'POST':
title = request.form['title']
error = None
if not title:
error = 'El Titulo es requerido.'
if error is not None:
flash(error)
return redirect(url_for('blog.index'))
else:
from tmdbv3api import TMDb, TV, Movie, Season
tmdb = TMDb()
tmdb.api_key = "e00b72174e4ae097af808f34a8f220fc"
movie = Movie()
show = movie.search(title)
return render_template('blog/buscar.html', posts=show)
def imdb_get_movies(data):
imdb_url = data
# movieLibrary = plex.library.section("Movies")
library_language = plex.library.section("Movies").language
r = requests.get(imdb_url, headers={'Accept-Language': library_language})
tree = html.fromstring(r.content)
title_name = tree.xpath(
"//div[contains(@class, 'lister-item-content')]//h3[contains(@class, "
"'lister-item-header')]//a/text()")
title_years = tree.xpath(
"//div[contains(@class, 'lister-item-content')]//h3[contains(@class, "
"'lister-item-header')]//span[contains(@class, 'lister-item-year')]/text()"
)
title_ids = tree.xpath(
"//div[contains(@class, 'lister-item-image')]//a/img//@data-tconst")
tmdb = TMDb()
tmdb.api_key = config['tmdb']['apikey']
movie = Movie()
imdb_map = {}
matched_movies = []
for m in plex.library.section("Movies").all():
if 'themoviedb://' in m.guid:
if not tmdb.api_key == "None":
tmdb_id = m.guid.split('themoviedb://')[1].split('?')[0]
tmdbapi = movie.details(tmdb_id)
imdb_id = tmdbapi.imdb_id
else:
imdb_id = None
elif 'imdb://' in m.guid:
imdb_id = m.guid.split('imdb://')[1].split('?')[0]
else:
imdb_id = None
if imdb_id and imdb_id in title_ids:
imdb_map[imdb_id] = m
else:
imdb_map[m.ratingKey] = m
if imdb_id in title_ids:
matched_movies.append(m)
return matched_movies
def movie_list(request):
if request.method == 'GET':
form = ReleaseForm()
return render(request, 'movie_list.html', {'form': form})
elif request.method == 'POST':
form = ReleaseForm(request.POST)
if form.is_valid():
release_date_gte = request.POST.get('start', '2017-11-01')
release_date_lte = request.POST.get('end', '2017-12-01')
tmdb = TMDb()
tmdb.api_key = os.environ['KEY-MDB']
discover = Discover()
movies = discover.discover_movies({
'primary_release_date.gte':
release_date_gte,
'primary_release_date.lte':
release_date_lte,
})
db, token, uid = initializationDb()
for movie in movies:
data = {
"id": movie.id,
"title": movie.title,
"overview": movie.overview,
"poster_path": movie.poster_path,
"release_date": movie.release_date,
"popularity": movie.popularity,
"original_title": movie.original_title,
"vote_count": movie.vote_count,
"vote_average": movie.vote_average
}
db.child(uid).child("movie_list").child(movie.id).set(
data, token)
response = {"status": 200, "message": "Success Save"}
return JsonResponse(response)
else:
response = {"status": 401, "message": "Invalid Input"}
return JsonResponse(response)
def show_addmovie(self, inputdata):
from tmdbv3api import TMDb, Movie
tmdb = TMDb()
tmdb.api_key = '1437062848d1dda19bd3907cf120e9f4'
tmdb.language = 'en'
if inputdata == "":
msg = QtWidgets.QMessageBox()
msg.setIcon(QtWidgets.QMessageBox.Information)
msg.setText("{0}".format("กรุณากรอกข้อมูล"))
msg.setWindowTitle("Messages")
msg.exec_()
else:
movie = Movie()
search = movie.search(inputdata)
countrow = len(search)
self.tableAddmovie.setRowCount(countrow)
i = 0
for res in search:
movie_title = res.title
self.tableAddmovie.setItem(
i, 0, QtWidgets.QTableWidgetItem(movie_title))
i = i + 1
def getAdditionalData(self, movieId):
if "Url" not in self.movieID_to_info[movieId]:
tmdb = TMDb()
tmdb.api_key = '66a11b9611008995220d8300279b6011'
tmdb.language = 'en'
tmdb.debug = True
base = "https://image.tmdb.org/t/p/w200"
url = ""
title = self.movieID_to_info[movieId]["Title"][:-6]
search = Movie().search(title)
if search != []:
url = search[0].poster_path
else:
search = TV().search(title)
if search != []:
url = search[0].poster_path
self.movieID_to_info[movieId]["Url"] = base + url
return self.getChartData(movieId)
def search_movie_api(request):
movie_title = request.POST.get("movie_title")
tmdb = TMDb()
tmdb.api_key = 'd624f6311529ea50a6238e7d7296610a'
tmdb.language = 'ja-JA'
movie = Movie()
search = movie.search(movie_title)
movie_genres = MovieGenreM.objects
movie_list = []
for res in search:
genre_names = None
for genre_id in res.genre_ids:
movie_genre = movie_genres.get(movie_genre_id=genre_id)
if genre_names:
genre_names = genre_names + ',' + movie_genre.movie_genre_name
else:
genre_names = movie_genre.movie_genre_name
d = {
'id': res.id,
'title': res.title,
'release_date': res.release_date,
'genre_ids': res.genre_ids,
'genre_names': genre_names,
'summary': res.overview.replace('"', '').replace("'", "")
}
movie_list.append(d)
movie_list.sort(key=lambda x: x['release_date'])
movie_list_json = json.dumps(movie_list)
return HttpResponse(movie_list_json)
from django.shortcuts import render
from tmdbv3api import TMDb, Movie, Discover
import json
from django.views.decorators.csrf import csrf_exempt
from django.http import JsonResponse
# Create your views here.
tmdb = TMDb()
tmdb.api_key = 'db5fb45ba4e01969dd293a217985b358'
genres = {'28': 'Action', '12': 'Adventure', '16': 'Animation', '35': 'Comedy',
'80': 'Crime', '99': 'Documentary', '18': 'Drama', '10751': 'Family',
'14': 'Fantasy', '36': 'History', '27': 'Horror', '10402': 'Music',
'9648': 'Mystery', '10749': 'Romance', '878': 'ScienceFiction',
'10770': 'TVMovie', '53': 'Thriller', '10752': 'War', '37': 'Western'}
def serialize_movie_array(m, limit):
k = []
for i in m:
if i['original_language'] == "en" or i ['original_language'] == "hi":
i = dict(i)
if len(i['title'])>30:
i['title'] = i['title'][:30] + "..."
genres_str = ""
if len(i["genre_ids"])>3:
i["genre_ids"] = i["genre_ids"][:3]
for j in i["genre_ids"]:
genres_str += genres[str(j)] + ", "
genres_str = genres_str[:-2]
mdict = {'title':i['title'], 'image': 'https://image.tmdb.org/t/p/w500'+str(i['poster_path']),
'genre':genres_str,"id": i["id"], 'rating':i['vote_average'], 'overview': i['overview']}
# TMDb API
from tmdbv3api import TMDb
from tmdbv3api import Movie
from tmdbv3api import TV
# For loading JSON file
import json
# Open the JSON file
with open('./everything.json', encoding='utf-8') as fh:
file = json.load(fh)
tmdb = TMDb()
tmdb.api_key = 'a9545ec1bd745e79c447cdadf22cb82c'
tmdb.language = 'en'
tmdb.debug = True
tv = TV()
movie = Movie()
data = []
for i in range(1):
print(obj['title'])
if (obj['type'] == "TV Show"):
show = tv.search(obj['title'])
try:
print(show[0].name)
print(show[0].poster_path)
"""Powered by deep-translator and TMDB
Design by David Zhou For Raspberry Pi 4B and dCloud XT(X86)
PS: Paddle and Papago is not working with python 3.8, so use fallback mode"""
if __name__ =='__main__':
from deep_translator import GoogleTranslator
userinput = userinputfr = str(input("请输入英文进行翻译: "))
from tmdbv3api import TV
from tmdbv3api import Movie
from tmdbv3api import TMDb
tmdb = TMDb()
tmdb.api_key = 'your TMDB API here'
tmdb.language = 'zh'
tv = TV()
movie = Movie()
movies = movie.search(userinput)
show = tv.search(userinput)
print('\n')
for result in movies:
print(result.title)
quit()
for result in show:
print(result.name)
quit()
translated1 = GoogleTranslator(source='en', target='ja').translate(userinput)
translated2 = GoogleTranslator(source='ja', target='zh').translate(translated1)
print("中文:",translated2)
from flask import Flask, jsonify, render_template, request
from flask_caching import Cache
import os, optparse, sys
import json
import requests
from tmdbv3api import TMDb
from tmdbv3api import Movie
from redis import Redis
app = Flask(__name__)
environment=os.getenv("ENVIRONMENT","development")
tmdb = TMDb()
tmdb.api_key = '9083cbdd7f380052de7a54baf7d4983b'
response = requests.get('https://api.themoviedb.org/3/trending/movie/week?api_key=9083cbdd7f380052de7a54baf7d4983b')
data = response.json()
with open('Trending_Movies_API.json', 'w', encoding= 'utf-8') as f:
json.dump(data, f, ensure_ascii= False, indent=4)
class db:
key = "9083cbdd7f380052de7a54baf7d4983b"
redisserver = NONE
environment = ""
def __init__(self, key, environment):
self.key = key
self.environment = environment
def redisinit(self):
from discord.ext import commands
from tmdbv3api import TMDb
from tmdbv3api import Movie
import asyncio
from aio_timers import Timer
#import config
import os
client = commands.Bot(command_prefix='%')
tmdb = TMDb()
#tmdb.api_key = config.API_KEY
tmdb.api_key = os.environ['API_KEY']
tmdb.language = 'en'
tmdb.debug = True
movie = Movie()
@client.event
async def on_ready():
print('Selam! Teşrifatçı geldi, biletleri kesiyorum.')
@client.command
async def help(ctx):
await ctx.send(
for g in movie.genres:
genre += '#' + g['name'].replace(' ', '') + ' '
image = movie.poster_path
if image:
image_path = pictures_path + image
urllib.urlretrieve(config.TMDB_BASE_IMAGE_PATH + image, image_path)
status = '%s - %s #movies %s' % (movie.title, movie.url, genre.lower())
try:
api.update_with_media(image_path, status=status)
except Exception as e:
print(e.message)
os.remove(image_path)
print('Status updated: ' + status.encode('utf-8'))
if __name__ == '__main__':
tmdb = TMDb(api_key=None)
tmdb.api_key = config.TMDB_API_KEY
reddit = praw.Reddit(client_id=config.REDDIT_CLIENT_ID,
client_secret=config.REDDIT_CLIENT_SECRET,
user_agent=config.REDDIT_USER_AGENT)
pictures_path = expanduser(config.PICTURES_PATH)
auth = tweepy.OAuthHandler(config.CONSUMER_KEY, config.CONSUMER_SECRET)
auth.set_access_token(config.ACCESS_KEY, config.ACCESS_SECRET)
api = tweepy.API(auth, wait_on_rate_limit=True, wait_on_rate_limit_notify=True)
Bot()
schedule.every(60).minutes.do(Bot())
while 1:
schedule.run_pending()
time.sleep(1)
