def __init__(self, bot):
self.bot = bot
config = Config.get_config()
try:
self.omdb = OMDBClient(apikey=config.get("omdbKey", None))
except Exception as ex:
self.bot.unload_extension("cogs.utils.movie")
def _get_omdb_data(self):
for rec in self:
# Get OMDB Data
try:
from omdb import OMDBClient
client = OMDBClient(apikey=rec.api_key.name)
items = []
if client:
for i in range(1, rec.pages + 1):
page_items = client.get(
media_type=rec.type_id.name,
search=rec.name,
year=rec.year if rec.year else None,
season=rec.season if rec.season else None,
episode=rec.episode if rec.episode else None,
fullplot=rec.fullplot,
tomatoes=rec.tomatoes,
timeout=rec.timeout,
page=i)
if page_items:
items += page_items
return items
except:
raise UserError(
"There are Issue When Connect With OMDB Api and Get Data.")
def call_omdb(tag):
client = OMDBClient(apikey=OMDB_KEY)
response = client.title(tag, media_type='movie')
try:
return response['title'], response
except KeyError:
raise NotFound(f"no movie matching \"{tag}\" found")
def get_data(title="Game of Thrones"):
client = OMDBClient(apikey="cc71ac81")
client.set_default("tomatoes", True)
xml_content = client.get(title=title)
response = requests.get(xml_content["poster"])
img = Image.open(BytesIO(response.content))
img.save("static/{}.png".format(title.lower()), format="png")
return xml_content
def emoji_ratings(self) -> Dict[str, str]:
global omdb
if omdb is None:
omdb = OMDBClient(apikey=settings.OMDB_API_KEY)
id, title = self.id, None if self.id else self.title
movie = omdb.get(imdbid=id, title=title)
if movie:
ratings = movie.get("ratings")
e_ratings = reduce(emojify_sources, ratings, {})
return e_ratings
def get_api_data(self, movie_id):
"""
Get API data for movie
:param movie_id: imdb id
"""
client = OMDBClient(apikey=self.api_key)
movie_info = client.get(imdbid=movie_id)
# Download and store poster
movie_poster_url = movie_info['poster']
urllib.urlretrieve(movie_poster_url,
"pepper_html/imdb/images/movie_poster.jpg")
self.movie_data = movie_info
def generate_poster_url_dict(imdb_ids):
"""
:param imdb_ids: list of movie ids
:return: list of urls to corresponding posters.
"""
client = OMDBClient(apikey=os.environ.get('OMDB_API_KEY'))
poster_url_list = []
for imdb_id in imdb_ids:
data = client.get(imdbid=imdb_id)
poster_url = data['poster']
print(poster_url)
poster_url_list.append(poster_url)
return poster_url_list
def search_movie():
''' Searches for a movie to add to the list '''
form = SearchForMovie()
if form.validate_on_submit():
results = []
client = OMDBClient(apikey=Omdb.OMDB_KEY)
search = client.search_movie(form.search.data)
for s in search:
title = s['title']
year = s['year']
movie = client.get(title=title, year=year, fullplot=False)
results.append(movie)
return render_template('search.html', results=results, form=form)
return render_template('search.html', form=form)
def init_client(key=_OMDB_KEY):
"""
Call this once at the beginning
:param key: API key for OMDB
:return: None
"""
global OMDB_CLI
OMDB_CLI = OMDBClient(apikey=key)
def init_project(static_folder, *args):
runtime_folder = get_runtime_folder()
if not os.path.exists(runtime_folder):
os.mkdir(runtime_folder)
runtime_stream_folder = get_runtime_stream_folder()
if not os.path.exists(runtime_stream_folder):
os.mkdir(runtime_stream_folder)
epg_tmp_folder = get_epg_tmp_folder()
if not os.path.exists(epg_tmp_folder):
os.mkdir(epg_tmp_folder)
_app = Flask(__name__, static_folder=static_folder)
for file in args:
_app.config.from_pyfile(file, silent=False)
_app.wsgi_app = ProxyFix(_app.wsgi_app)
Bootstrap(_app)
_db = PyModm(_app)
_mail = Mail(_app)
_socketio = SocketIO(_app, async_mode='gevent')
_login_manager = LoginManager(_app)
_login_manager.login_view = 'HomeView:signin'
# socketio
@_socketio.on('connect')
def connect():
pass
@_socketio.on('disconnect')
def disconnect():
pass
# defaults flask
_host = '0.0.0.0'
_port = 8080
server_name = _app.config.get('SERVER_NAME_FOR_POST')
sn_host, sn_port = None, None
if server_name:
sn_host, _, sn_port = server_name.partition(':')
host = sn_host or _host
port = int(sn_port or _port)
_servers_manager = ServiceManager(host, port, _socketio)
omdb_api_key = _app.config.get('OMDB_KEY')
_omdb = OMDBClient(apikey=omdb_api_key)
return _app, _mail, _login_manager, _servers_manager, _omdb, _db
def init_project(static_folder, *args):
runtime_folder = get_runtime_folder()
if not os.path.exists(runtime_folder):
os.mkdir(runtime_folder)
runtime_stream_folder = get_runtime_stream_folder()
if not os.path.exists(runtime_stream_folder):
os.mkdir(runtime_stream_folder)
epg_tmp_folder = get_epg_tmp_folder()
if not os.path.exists(epg_tmp_folder):
os.mkdir(epg_tmp_folder)
app = Flask(__name__, static_folder=static_folder)
for file in args:
app.config.from_pyfile(file, silent=False)
app.wsgi_app = ProxyFix(app.wsgi_app)
bootstrap = Bootstrap(app)
db = MongoEngine(app)
mail = Mail(app)
socketio = SocketIO(app)
login_manager = LoginManager(app)
login_manager.login_view = 'HomeView:signin'
# socketio
@socketio.on('connect')
def connect():
pass
@socketio.on('disconnect')
def disconnect():
pass
# defaults flask
_host = '0.0.0.0'
_port = 8080
server_name = app.config.get('SERVER_NAME_FOR_POST')
sn_host, sn_port = None, None
if server_name:
sn_host, _, sn_port = server_name.partition(':')
host = sn_host or _host
port = int(sn_port or _port)
servers_manager = ServiceManager(host, port, socketio)
omdb_api_key = app.config.get('OMDB_KEY')
omdb = OMDBClient(apikey=omdb_api_key)
return app, bootstrap, db, mail, login_manager, servers_manager, omdb
def membersearchmovie(request, type_id, user_id):
movietitle = request.GET.get('movietitle')
if not movietitle:
return render(request, 'error/error.html')
movie = models.movie.objects.filter(title=movietitle)
if not movie:
API_KEY = '66a8c2f3'
client = OMDBClient(apikey=API_KEY)
movie_data = client.get(movietitle)
allmovie = []
for movie in movie_data:
new_movie = Imdb_Movie(title=movie['title'],
poster=movie['poster'],
watchlink="https://www.imdb.com/title/" +
movie['imdb_id'])
allmovie.append(new_movie)
cd = {'allmovie': allmovie}
return render(request, 'error/error2.html', cd)
else:
moviefound = models.movie.objects.get(title=movietitle)
return HttpResponseRedirect('/movie/' + str(moviefound.id) + '/type/' +
str(type_id) + '/id/' + str(user_id) + '/')
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 get_ratings(title="Game of Thrones"):
try:
# check if we already have the ratings of the listing
data = np.load("data/{}.npy".format(title.lower()))
print("Loaded data from disk")
return data, title
except:
client = OMDBClient(apikey="cc71ac81")
client.set_default("tomatoes", True)
# ratings for season 1
xml_content = client.get(title=title, season=1)
num_episodes = len(xml_content["episodes"])
# total number of seasons
total_seasons = int(xml_content["total_seasons"])
print("Total seasons: {}".format(total_seasons))
list = []
listoflists = []
for item in xml_content["episodes"]:
list.append(item["imdb_rating"])
listoflists.append(list)
print(listoflists)
# get the ratings of other seasons
for i in range(2, total_seasons + 1):
list = []
xml_content = client.get(title=title, season=i)
for item in xml_content["episodes"]:
list.append(item["imdb_rating"])
listoflists.append(list)
print(listoflists)
maxlen = 0
for item in listoflists:
if len(item) > maxlen:
maxlen = len(item)
for item in listoflists:
while len(item) < maxlen:
item.append(None)
data = np.array(listoflists).transpose()
np.place(data, data == "N/A", None)
print(data)
data = data.astype(np.float)
print("Loaded data from omdb")
np.save("data/{}".format(title.lower()), data)
return data, title
def omdb_data(arguments):
movie_name, year = arguments
client = OMDBClient(apikey=OMDB_API_KEY)
try:
result = client.get(title=movie_name, year=year, fullplot=True, tomatoes=True)
except HTTPError as e:
print(e)
client.set_default("apikey", OMDB_API_KEY_fallback)
result = client.get(title=movie_name, year=year, fullplot=True, tomatoes=True)
result_to_keep = {}
for key in requested_flat_fields:
result_to_keep[key] = result.get(key, None)
for nested_field in requested_nested_fields:
requested_nested_list = requested_nested_fields[nested_field]
nested_list = result.get(nested_field, None)
if nested_list:
for nested_dict in nested_list:
source = nested_dict.get("source", None)
if source:
value = nested_dict.get("value", None)
if source in requested_nested_list:
source_formatted = to_snake_case(source)
key = f"{nested_field}_{source_formatted}"
result_to_keep[key] = value
requested_sources = requested_nested_fields[nested_field]
for requested_source in requested_sources:
source_formatted = to_snake_case(requested_source)
key = f"{nested_field}_{source_formatted}"
if not key in result_to_keep:
result_to_keep[key] = None
else:
requested_sources = requested_nested_fields[nested_field]
for requested_source in requested_sources:
source_formatted = to_snake_case(requested_source)
key = f"{nested_field}_{source_formatted}"
result_to_keep[key] = None
return t.Row(*list(result_to_keep.keys()))(*list(result_to_keep.values()))
client = wolframalpha.Client('your-key')
import dialogflow_v2 as dialogflow
dialogflow_session_client = dialogflow.SessionsClient()
PROJECT_ID = "all-bot-yhniuh"
from gnewsclient import gnewsclient
nclient = gnewsclient.NewsClient(max_results=3)
from omdb import OMDBClient
mclient = OMDBClient(apikey="your-key")
from pymongo import MongoClient
mongo_client = MongoClient("mongodb+srv://vishav:[email protected]/test?retryWrites=true&w=majority")
db = mongo_client.get_database('all_data')
def get_movie(parameters):
mclient.topic = parameters.get('movie_name')
from flask import Flask, render_template, request, jsonify
from interface import interface
from jsonify import common
from Engine.booktest import BookEngine
from omdb import OMDBClient
from Engine.movietestRun import MovieEngine
from flask.helpers import url_for
app = Flask(__name__, static_folder='static')
ob = interface(BookEngine(), MovieEngine())
client = OMDBClient(apikey='e181a4c1')
def checkurlcontent(title):
res = url_for('static', filename='images/nan.jpg')
set_path = res
try:
res = client.get(title, year=dict(
common.get(title)).get('Year'))[:1][0].get('poster')
except Exception as x:
if x:
pass
return res if res != 'N/A' else set_path
@app.route('/')
def index():
return render_template('main.html')
import re
from omdb import OMDBClient
from wickie.settings import OMDB_API_KEY
r_imdb_url = r"https?://(w{3}.)?imdb.com/title/(tt[0-9]*)/?"
client = OMDBClient(apikey=OMDB_API_KEY)
def extract_id(url):
match = re.match(r_imdb_url, url)
if match:
return match.groups()[-1]
return None
import sys
import json
# To access the OMDb API, we can create an ``OMDBClient`` instance:
from omdb import OMDBClient
# must use OMDb API parameters
client = OMDBClient(apikey='8ce3c73f')
print("Success, API is connected")
# Default for Rotten Tomato rating...
client.set_default('tomatoes', True)
cmd_Argument = sys.argv[1:]
try:
# print(cmd_Argument)
if cmd_Argument:
print("The command line argument is : %s" % (cmd_Argument))
# User Input
# movie_name = str(input("Please enter movie name : "))
# movie_year = input("Enter year as well : ")
res1 = client.request(t=cmd_Argument,
plot='full',
tomatoes='true',
timeout=50) # year = movie_year
xml_content = res1.content
my_json = xml_content.decode('utf8') # .replace("'", '"')
print('* ' * 20)
from functools import reduce
from re import findall
from typing import Dict
from omdb import OMDBClient
from giru.settings import OMDB_API_KEY
omdb = OMDBClient(apikey=OMDB_API_KEY)
RATING_EMOJI = {
'Rotten Tomatoes': '🍅',
'Internet Movie Database': '🍿',
'Metacritic': 'Ⓜ️'
}
def emojify_sources(s: Dict[str, str], rating: Dict[str, str]):
source, value = rating.get('source'), rating.get('value')
matches = findall(r"([\d.]+).*", value)
if len(matches):
value = matches[0]
s[RATING_EMOJI.get(source, source)] = value
return s
class Movie:
def __init__(self, id=None, title=None):
assert id or title, "Must have a title or id"
def get_movie(title):
client = OMDBClient(apikey=omdb_key)
response = client.get(title=title, timeout=5, tomatoes='true')
return response
class Movie(commands.Cog):
def __init__(self, bot):
self.bot = bot
config = Config.get_config()
try:
self.omdb = OMDBClient(apikey=config.get("omdbKey", None))
except Exception as ex:
self.bot.unload_extension("cogs.utils.movie")
@commands.command()
async def movie(self, ctx, *name: str):
""": IMDb movie search
movie title
"""
try:
search = self.omdb.search_movie(name)
except Exception as ex:
await ctx.channel.send(
f"Daily limit reached. Unfortunately the free omdb API only supports 1000 requests per day."
)
return
selected_movie = None
if len(search) > 1:
if (len(search) > 10
): # api should only give 10 movies, but let's just limit it
search = search[:10]
res = ""
numbers = list()
for index, movie in enumerate(search):
numbers.append(str(index) + "⃣")
res += f"{numbers[index]} {movie.get('title', None)} ({movie.get('year', None)})\n"
res += ""
embed = discord.Embed(title="Please choose a movie",
description=res)
mes = await ctx.channel.send(embed=embed)
for index in range(0, len(search)):
await mes.add_reaction(f"{str(index)+'⃣'}")
def check(reaction, user):
return reaction.message.id == mes.id and user == ctx.message.author
reaction, user = await self.bot.wait_for("reaction_add",
check=check,
timeout=60.0)
number = numbers.index(reaction.emoji)
selected_movie = search[number]
else:
selected_movie = search[0]
movie = self.omdb.request(i=selected_movie.get("imdb_id", None))
movie = json.loads(movie.content)
error = ""
plot = None
if movie["Plot"] != "N/A":
plot = movie["Plot"]
awards = None
if movie["Awards"] != "N/A":
awards = movie["Awards"]
poster = None
if movie["Poster"] != "N/A":
poster = movie["Poster"]
embed = discord.Embed(
title=movie.get("Title", None),
description=plot,
url=f'https://www.imdb.com/title/{movie.get("imdbID",None)}',
)
embed.add_field(name="Year", value=movie.get("Year", None))
if poster is not None:
embed.set_thumbnail(url=poster)
embed.add_field(name="Genre", value=movie.get("Genre", None))
embed.add_field(name="Actors", value=movie.get("Actors", None))
embed.add_field(name="Director", value=movie.get("Director", None))
if awards is not None:
embed.add_field(name="Awards", value=awards)
embed.add_field(name="IMDb Rating",
value=movie.get("imdbRating", None))
for r in movie.get("Ratings", list()):
embed.add_field(name=r.get("Source", None),
value=r.get("Value", None))
if "mes" in locals():
try:
await mes.clear_reactions()
except Exception:
error = "⚠️ *Need manage_messages permission for full functionality.*"
await mes.edit(content=error, embed=embed)
else:
await ctx.channel.send(embed=embed)
import sys
import requests
from imdb import IMDb
from omdb import OMDBClient
client = OMDBClient(apikey="8381a16b")
ia = IMDb()
def get_film(name_of_the_film):
"""
Current function creating and updating txt file.
:param name_of_film:user must input film name
"""
name_of_the_film = ia.search_movie(name_of_the_film)[0]
film = ia.get_movie(ia.get_imdbID(name_of_the_film))
film_countries = ','.join(film['country'])
directors = []
list_of_directors_objects = film['directors']
for director in list_of_directors_objects:
directors.append(director.get('name'))
director = ",".join(directors)
genres = ",".join(film['genres'])
actors = []
list_of_actors = film['cast']
