def getAwards(self):
title = self.title
client = omdb.OMDBClient(apikey=os.environ['OMDB_API_KEY'])
movieData = client.get(title=title)
imdbID = movieData['imdb_id']
imdbAwardsURL = "https://www.imdb.com/title/{}/awards?ref_=tt_awd".format(
movieData['imdb_id'])
r = requests.get(imdbAwardsURL)
soup = bs4.BeautifulSoup(r.text, 'lxml')
table = soup.find('table', attrs={'class': 'awards'})
rows = table.find_all('tr')
winline = table.find('td', attrs={'class': 'title_award_outcome'})
numWins = 0
if "Winner" in winline.text:
numWins = int(winline['rowspan'])
else:
return False
data = []
for row in rows:
cols = row.find_all('td')
cols = [ele.text.strip() for ele in cols]
data.append([ele for ele in cols if ele]) # Get rid of empty
temp = []
temp.append(data[0][1])
for i in range(1, numWins):
temp.append(data[i][0])
awardsList = "\n\n".join(temp)
return awardsList
def test_set_default(client):
req = {'title': 'True Grit'}
data = client.get(**req)
# default request returns movie with this year
assert data['year'] == '2010'
# change the default year and re-request
client.set_default('year', '1969')
data = client.get(**req)
# default year is now used
assert data['year'] == '1969'
# can also set defaults at client instantiation time
client = omdb.OMDBClient(year='1969',
apikey=client.default_params['apikey'])
data = client.get(**req)
assert data['year'] == '1969'
# defaults can be overridden
req = {'title': 'True Grit', 'year': '2010'}
data = client.get(**req)
assert data['year'] == '2010'
def __init__(self):
# Set up basic omdb library
self.api_key = '57f4b0ed'
omdb.set_default('apikey', self.api_key)
self.omdb_client = omdb.OMDBClient(apikey=self.api_key)
self.main_url = 'http://www.omdbapi.com/?apikey=%s&' % (self.api_key)
self.db = DB()
def _omdb_client():
import omdb
global _OMDB
if _OMDB is None:
LOGGER.debug('Making client with API key: %s', config.OMDB_API_KEY)
_OMDB = omdb.OMDBClient(apikey=config.OMDB_API_KEY)
return _OMDB
def __init__(self, title=None, posterURL=None):
"""
Constructor
"""
logging.info("Entering OpenMovie CTOR")
# Save class data members
self.title = title
self.posterURL = posterURL
self.posterFileName = None
# os.mkdir will throw an exception if the directory already
# exists, so catch it and move on
try:
os.mkdir("Posters")
except:
pass
client = omdb.OMDBClient(apikey=os.environ['OMDB_API_KEY'])
try:
self.movie = client.get(title=title)
except:
logging.error("Could not get {} from omdb".format(title))
print("Could not get {} from omdb".format(title))
# adding a bunch of empty lists
self.monthlyBudget = []
self.monthlyRevenue = []
self.monthlyMaxRevenue = []
self.monthlyMovieCount = []
self.monthlyMovieTitles = []
self.monthlyRevenueMean = []
self.monthlyRevenueMedian = []
self.monthlyRevenueStd = []
self.monthlyBudgetMean = []
self.monthlyBudgetMedian = []
self.monthlyBudgetStd = []
self.annualRevenue = []
self.annualRevenueMean = []
self.annualRevenueMedian = []
self.annualRevenueStd = []
self.annualBudget = []
self.annualBudgetMean = []
self.annualBudgetMedian = []
self.annualBudgetStd = []
logging.info("Exiting OpenMovie CTOR. MOVIE TITLE: {}".format(
self.title))
return
def get_movie_names_for(srch_term): import omdb from .secretfile import omdbapikey #this is my own api for omdb #will not work outside django client = omdb.OMDBClient(apikey=omdbapikey) data = client.search_movie(srch_term) movie_names_with_id = dict() for i in range(len(data)): instance = data[i] movie_names_with_id[instance['title']] = instance['imdb_id'] return movie_names_with_id
def __init__(self, title=None):
self.title = title
self.client = omdb.OMDBClient(apikey=os.environ['OMDB_API_KEY'])
self.posterFileName = None
try:
os.mkdir("Posters")
except:
pass
try:
self.movie = self.client.get(title=title)
except Exception:
logging.error("FAILED to get movie {}".format(title))
print(traceback.format_exc())
logging.error(traceback.format_exc())
return
def __init__(self, title=""):
"""
The constructor initializes the three fields and also creates the directory that the poster files will be stored in.
"""
self.posterFileName = ""
self.title = title
# connect to omdb
self.client = omdb.OMDBClient(apikey=os.environ['OMDB_API_KEY'])
# get data
try:
self.movie = self.client.get(title=title)
except:
return
# the directory is created in a try catch block since after first being created it will throw an exception when mkdir is called again.
try:
os.mkdir("Posters")
except:
pass
return
def __init__(self, title=None, tomatoes=False):
self.title = title
self.client = omdb.OMDBClient(apikey=os.environ['OMDB_API_KEY'])
self.posterFileName = None
self.awardsDict = {}
self.monthlyBudget = []
self.monthlyRevenue = []
self.monthlyMaxRevenue = []
self.monthlyMovieCount = []
self.monthlyMovieTitles = []
self.monthlyRevenueMean = []
self.monthlyRevenueMedian = []
self.monthlyRevenueStd = []
self.monthlyBudgetMean = []
self.monthlyBudgetMedian = []
self.monthlyBudgetStd = []
self.annualBudgetMean = []
self.annualBudgetMedian = []
self.annualBudgetStd = []
self.annualRevenueMean = []
self.annualRevenueMedian = []
self.annualRevenueStd = []
try:
os.mkdir("Posters")
except:
pass
try:
self.movie = self.client.get(title=title, tomatoes=tomatoes)
except Exception:
logging.error("FAILED to get movie {}".format(title))
print(traceback.format_exc())
logging.error(traceback.format_exc())
return
def get(self, request):
movies_client = omdb.OMDBClient(apikey=settings.OMDB_API_KEY)
title = request.GET.get('title', '')
page = int(request.GET.get('page', 1))
movies = movies_client.search_series(title, page=page)
movies_to_return = []
for movie in movies:
instance, _ = Movie.objects.update_or_create(
imdb_id=movie['imdb_id'],
defaults={
'title':
movie['title'],
'poster_url':
movie['poster']
if self._is_poster_url_valid(movie['poster']) else None
})
movies_to_return.append(instance)
return Response(data=MovieSerializer(
movies_to_return, many=True, context={
'request': request
}).data)
import omdb
from django.conf import settings
from iioy.core.adapters import UnImplementableMethod
from iioy.movies.external.data_sources.base import BaseMovieAdapter, \
MovieRating
client = omdb.OMDBClient(apikey=settings.OMDB_API_KEY)
class OmdbMovieAdapter(BaseMovieAdapter):
source = 'omdb'
"""
NB: The OMDB api has many of these fields, but we rely on TMDB as the
source of truth and only use OMDB as supplemental.
"""
def __init__(self, tmdb_id, imdb_id):
self.tmdb_id = tmdb_id
self.imdb_id = imdb_id
self._data = None
@property
def data(self):
if self._data is None:
self._data = client.get(imdbid=self.imdb_id)
return self._data
get_title = UnImplementableMethod('Not used from OMDB.')
get_original_title = UnImplementableMethod('Not used from OMDB.')
get_tagline = UnImplementableMethod('Not used from OMDB.')
answer = {"Ala": 2, "ma": 2, "kota": 1, "psa": 1, ".": 2}
assert word_counter2("Ala ma kota. Ala ma psa.") == answer
import re
def validatePIN(PIN):
return bool(re.fullmatch("\d{4}", PIN))
assert validatePIN("1234") == True, "Wrong validation!"
assert validatePIN("12345") == False, "Wrong validation!"
assert validatePIN("a234") == False, "Wrong validation!"
def validate_input(word):
return bool(re.fullmatch("[a-z 0-9_]{5,20}", word))
assert validate_input("Summer Academmy") == False, "Bad validation!"
assert validate_input("Summer_Academmy") == False, "Bad validation!"
assert validate_input("summer_academmy") == True, "Bad validation!"
import omdb
client = omdb.OMDBClient(apikey="1ecdeb9a")
res = client.request(t='Grease', y='1978')
xml_content = res.content
print(xml_content)
import omdb
import re
# set up OMDB API to be used to pull data
client = omdb.OMDBClient(apikey='5203b3e3')
# code logic similar to movie extraction code
# search keywords
words = [
'Canada', 'University', 'Moncton', 'Halifax', 'Toronto', 'Vancouver'
'Alberta', 'Niagara'
]
data = [] # empty list to which movie_details obj will be added
print("Searching for movie data...")
# API call from http://www.omdbapi.com/
for z in range(1, 20):
for word in words:
movies = client.search(word, page=z)
for movie in movies:
movie_details = {
'title': movie['title'],
'poster': movie['poster'],
'imdb ID': movie['imdb_id'],
'year': movie['year'],
'type': movie['type']
}
data.append(movie_details)
# special tags regex reference: https://www.webdeveloper.com/d/199621-need-a-regex-to-exclude-all-but-a-za-z0-9s
if movie_details['type'] is not None:
def load_config(self, confdict):
self.api = omdb.OMDBClient(apikey=confdict["api_key"])
self.artkey = confdict['fanart_key']
self.artckey = confdict['fanart_ckey']
def _fetch_from_omdb(title):
client = omdb.OMDBClient(apikey=os.getenv('OMDB_API_KEY'))
return client.get(title=title, media_type='movie', timeout=5.0)
#! /usr/bin/env python3
import os
import re
import bs4
import omdb
import requests
if __name__ == "__main__":
title = "Gladiator"
title = "Clerks"
title = "Avatar"
title = "The Matrix"
title = "The Expendables"
client = omdb.OMDBClient(apikey=os.environ['OMDB_API_KEY'])
movie = client.get(title=title, tomatoes=False)
print(movie['imdb_id'])
imdb_url = "https://www.imdb.com/title/{}/awards?ref_=tt_awd".format(
movie['imdb_id'])
r = requests.get(imdb_url)
# print(r.text)
soup = bs4.BeautifulSoup(r.text, "lxml")
table = soup.find('table', attrs={'class': 'awards'})
data = []
rows = table.find_all('tr')
for row in rows:
cols = row.find_all('td')
cols = [ele.text.strip() for ele in cols]
def client(cache):
return omdb.OMDBClient(apikey=cache.get('omdbapikey', None))
def __init__(self, api_key=API_KEY):
self.api_key = api_key
omdb.set_default('tomatoes', True)
self.client = omdb.OMDBClient(apikey=API_KEY)
import omdb
import os
import dialogflow_v2 as dialogflow
import database
import requests
import urllib
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "moviesbot-secret.json"
dialogflow_session_client = dialogflow.SessionsClient()
PROJECT_ID = "moviesbot-uasafb"
API_KEY = '9c1e8a8b'
client = omdb.OMDBClient(apikey=API_KEY)
def get_new_movie(parameters):
print(parameters)
# print('dshgddhajk')
movie_title = parameters.get('movie_title')
year = parameters.get('year')
# language = parameters.get('language')
news = dict(client.get(title=movie_title, year=year, tomatoes=True))
if(news != {}):
print("inside if")
type1 = news['type']
poster_url = news['poster']
str1 = f"\n\nPlot:\n{news['plot']}\n\nThis {type1} has its release in " \
f"{news['year']} directed by {news['director']} with actors {news['actors']}" \
f" and got {news['awards']} It has a imdb rating of {news['imdb_rating']}."
# print(type1, poster_url, str1)
import omdb
from keys import *
# init
client = omdb.OMDBClient(apikey=movie_key)
search_keywords = ['Canada','University','Moncton','Halifax','Toronto','Vancouver''Alberta','Niagara']
movie_title = []
# # Reference taken from http://www.omdbapi.com/
for search_word in search_keywords:
# Can iterate to 100 pages but limited API calls per day
for pageCount in range(1,2):
movies = client.search(search_word, page=pageCount)
if movies == []:
continue
else:
movie_title.append(movies)
pass
movie_details = []
# Reference taken from http://www.omdbapi.com/
for movie in movie_title:
for obj in movie:
# invoked get api call for every movie title
movie_details.append(client.get(title=obj["title"]))
print(movie_details)
fileMenu.addAction(exitAction)
self.toolbar = self.addToolBar('Exit')
self.toolbar.addAction(exitAction)
self.central = UI_Widget()
self.setCentralWidget(self.central)
self.setWindowTitle('Statusbar')
self.show()
return
if __name__ == "__main__":
print("OMDB Example Code")
omdb_api_key = os.environ['OMDB_API_KEY']
print(omdb_api_key)
client = omdb.OMDBClient(apikey=omdb_api_key)
avatar = client.get(title='Avatar')
print(avatar)
avatar_post_url = avatar['poster']
r = requests.get(avatar_post_url)
# https://www.codementor.io/aviaryan/downloading-files-from-urls-in-python-77q3bs0un
open('avatar_poster.jpg', 'wb').write(r.content)
app = PyQt5.QtWidgets.QApplication(sys.argv)
gui = UI()
gui.show()
app.exec_()
from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework import status
from django.conf import settings
from .models import Movie, Comment
from .serializers import (
TitleSerializer,
MovieSerializer,
CommentSerializer,
GetTopQuerySerializer,
TopResponseSerializer,
)
OMDB_CLIENT = omdb.OMDBClient(apikey=settings.OMDBAPI_KEY)
@api_view(["GET", "POST"])
def get_post_movies(request):
if request.method == "GET":
movies = Movie.objects.all()
serializer = MovieSerializer(movies, many=True)
return Response(serializer.data)
elif request.method == "POST":
title_serializer = TitleSerializer(data=request.data)
if not title_serializer.is_valid():
return Response(title_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
title = title_serializer.data.get("title")
# if movie already in db return error msg
import omdb
from .secretfile import omdbapikey #this is my own api for omdb
#will not work outside django
client = omdb.OMDBClient(apikey=omdbapikey)
def by_imdb_id(imdb_id):
movie_info = client.imdbid(imdb_id)
tmpdict = dict()
if 'ratings' in movie_info.keys():
for item in movie_info['ratings']:
tmpdict[item['source']] = item[
'value'] #That simplifies ratings, will be easier to render in django template
movie_info['ratings'] = tmpdict
return movie_info
def main():
print(by_imdb_id("tt1226837"))
if __name__ == '__main__':
main()
def search(request):
movie_name = request.POST['movie']
client = omdb.OMDBClient(apikey=omdb_APIKEY)
#try:
movie_data = client.title(movie_name)
if movie_data != {}:
if mediaDatabase.objects.filter(title=movie_data['title']).exists():
print('movie already exists')
else:
data = mediaDatabase()
data.title = movie_data['title']
data.year = movie_data['year']
data.release_date = datetime.datetime.strptime(
movie_data['released'], "%d %b %Y")
data.rated = movie_data['rated']
runtime = int(movie_data['runtime'].split(' ')[0])
data.runtime = datetime.timedelta(days=0,
hours=runtime // 60,
minutes=runtime % 60)
data.genre = movie_data['genre']
data.director = movie_data['director']
data.writers = movie_data['writer']
data.cast = movie_data['actors']
data.plot = movie_data['plot']
movie_poster_url = movie_data['poster']
print(movie_poster_url)
#movie_backdrop_url = movie_data['backdrop']
#print(movie_data['imdb_id'])
data.poster = get_movie_poster(movie_poster_url,
movie_data['title'])
data.backdrop = get_tmdb_movie_backdrop(movie_data['imdb_id'],
movie_data['title'])
metascore = int(movie_data['metascore'])
data.ratings_metacritic = metascore
imdb_value = float(movie_data['imdb_rating'])
data.ratings_imdb = imdb_value
rt_value = movie_data['ratings'][1]
rt_value = int(rt_value['value'].split('%')[0])
data.ratings_rotten = rt_value
data.ratings_average = int(
(metascore + rt_value + (imdb_value * 10)) / 3)
if request.FILES:
uploaded_file = request.FILES['movie_file']
uploaded_file_name = fs.save(uploaded_file.name, uploaded_file)
print(uploaded_file_name)
data.movie_path = os.path.join(MOVIE_STORAGE_ROOT,
uploaded_file_name)
data.save()
#except:
# print('Check your internet connection')
return redirect('/')
