Enriching my Film Journal with the IMDB API

from pynput import keyboard

starting_list = [
    'Indiana Jones The Last Crusade',
    'Prisoners',
    'Semi Pro',
    'Indiana Jones Temple of Doom',
    'L.A. Confidential',
    'Kick-Ass',
    'Bad Boys',
    'Princess Mononoke',
    'Once Upon a Time in Hollywood',
    'You Don\'t Mess With The Zohan',
    'Uncut Gems',
    'Syndoche New York',
]

latest_key = None
question_number = 1

def get_arrow_input():
    def on_release(key):
        if key in [key.left, key.right]:
            global latest_key
            latest_key = f"{key}"
            # Stop listener
            return False

    # Collect events until released
    with keyboard.Listener(on_release=on_release) as listener:
        listener.join()

def bubble_sort(array):
    question_number = 1
        
    # loop through each element of array
    for i in range(len(array)):
                
        # keep track of swapping
        swapped = False
        
        # loop to compare array elements
        for j in range(0, len(array) - i - 1):

            print(f"Q{question_number}: [{array[j]}] or [{array[j + 1]}]?")
            get_arrow_input()
            choice = "left" if latest_key == "Key.left" else "right"

            # compare two adjacent elements
            # change > to < to sort in descending order
            if choice == "right":

                # swapping occurs if elements
                # are not in the intended order
                temp = array[j]
                array[j] = array[j+1]
                array[j+1] = temp

                swapped = True

            question_number += 1
                    
        # no swapping means the array is already sorted
        # so no need for further comparison
        if not swapped:
            break

    return array

sorted_list = bubble_sort(starting_list)
print(sorted_list)

def partition(arr, low, high):
    i = (low-1)
    pivot = arr[high]

    global question_number
 
    for j in range(low, high):
 
        # If current element is smaller than or
        # equal to pivot

        print(f"Q{question_number}: [{arr[j]}] or [{pivot}]?")
        question_number += 1
        get_arrow_input()

        if latest_key == "Key.left":
 
            # increment index of smaller element
            i = i+1
            arr[i], arr[j] = arr[j], arr[i]
 
    arr[i+1], arr[high] = arr[high], arr[i+1]
    return (i+1)
 
# The main function that implements quick sort
# arr[] --> Array to be sorted
# low  --> Starting index
# high  --> Ending index
def quick_sort(arr, low, high):
    if len(arr) == 1:
        return arr
    if low < high:
 
        # pi is partitioning index, arr[p] is now
        # at right place
        pi = partition(arr, low, high)
 
        # Separately sort elements before
        # partition and after partition
        quick_sort(arr, low, pi-1)
        quick_sort(arr, pi+1, high)

quick_sort(starting_list, 0, len(starting_list)-1)
print(starting_list)

def binary_search(arr, val, start, end):
    # we need to distinguish whether we should insert
    # before or after the left boundary.
    # imagine [0] is the last step of the binary search
    # and we need to decide where to insert -1

    global question_number

    if start == end:

        print(f"Q{question_number}: [{arr[start]}] or [{val}]?")
        question_number += 1
        get_arrow_input()

        if latest_key == "Key.right":
            return start
        else:
            return start+1
  
    # this occurs if we are moving beyond left\'s boundary
    # meaning the left boundary is the least position to
    # find a number greater than val
    if start > end:
        return start
  
    mid = int((start+end)/2)

    print(f"Q{question_number}: [{arr[mid]}] or [{val}]?")
    question_number += 1
    get_arrow_input()

    if latest_key == "Key.left":
        return binary_search(arr, val, mid+1, end)
    elif latest_key == "Key.right":
        return binary_search(arr, val, start, mid-1)
    else:
        return mid


#sorted_list = []
for index, value in enumerate(starting_list):

    try:
        print(f'Film [{index+1}/{len(starting_list)}]')
        index = binary_search(sorted_list, value, 0, len(sorted_list)-1)
        sorted_list = sorted_list[:index] + [value] + sorted_list[index:]
    except:
        print("Encountered an error!! Whoopsie")
        print(sorted_list)

print(sorted_list)

import imdb
import json
from datetime import datetime
 
# creating instance of IMDb
ia = imdb.IMDb()

# Information to fetch
info_to_fetch = [
    'runtimes',
    'year',
    'genres',
    'rating'
]

# Some info we want to keep as a list, otherwise take first value.
info_as_lists = [
    'genres'
]

# Get film list
with open('2021_sorted.json') as json_file:
    film_list = json.load(json_file)

# Shorten list while testing
film_list = [
    'The Pianist'
]
film_list_len = len(film_list)

# Maintain list of films
film_records = []
for index, film_name in enumerate(film_list):

    print(f'[{index+1}/{film_list_len}]: Fetching IMDB data for [{film_name}]...')

    film_record = {
        'title': film_name
    }

    try:
        # Search for the movie
        search_results = ia.search_movie(film_name)

        if len(search_results) > 0:
            top_result = search_results[0]
            film_id = top_result.movieID

            film = ia.get_movie(film_id)

            # Check that info is available
            available_info = film.infoset2keys['main']
            
            # Fetch available info
            for info in info_to_fetch:
                if info in available_info:
                    fetched_info = film.get(info)

                    if isinstance(fetched_info, list) and info not in info_as_lists:
                        fetched_info = fetched_info[0]

                    print(f'    Found [{info}]: {fetched_info}')
                    film_record[info] = fetched_info
        else:
            print('    Film not found!')

    except Exception as error:
        print(error)
        print('    Ran into error trying to fetch data, skipping film...')

    film_records.append(film_record)

output_filename = f'imdb_data_{datetime.now().strftime("%Y%m%d_%H%M%S")}.json'

print(f'Saving film data to [{output_filename}]')
with open(output_filename, 'w') as output_file:
    json.dump(film_records, output_file, indent=4)

print(len(films_df))

total_runtime_mins = films_df['runtimes'].sum()

total_runtime_formatted = timedelta(minutes=total_runtime_mins)
print(total_runtime_formatted)

total_days_of_week = films_df['Date'].dt.day_name().value_counts()

print(total_days_of_week)

film_date_frequency = films_df['Date'].value_counts()
max_count = film_date_frequency.max()

print(film_date_frequency[film_date_frequency==max_count].sort_index())

film_title_frequency = films_df['Title'].value_counts()
max_count = film_title_frequency.max()

print(film_title_frequency[film_title_frequency==max_count].sort_index())

longest_film = films_df[films_df['runtimes'] == films_df['runtimes'].max()][['Title','runtimes']]

longest_film_title = longest_film['Title'].values[0]
longest_film_runtime = timedelta(minutes=longest_film['runtimes'].values[0])

print(f'Longest film was "{longest_film_title}" with runtime of {longest_film_runtime}')

shortest_film = films_df[films_df['runtimes'] == films_df['runtimes'].min()][['Title','runtimes']]

shortest_film_title = shortest_film['Title'].values[0]
shortest_film_runtime = timedelta(minutes=shortest_film['runtimes'].values[0])

print(f'Shortest film was "{shortest_film_title}" with runtime of {shortest_film_runtime}')

best_imdb_film = films_df[films_df['rating'] == films_df['rating'].max()][['Title','rating']]

best_imdb_film_title = best_imdb_film['Title'].values[0]
best_imdb_film_rating = best_imdb_film['rating'].values[0]

print(f'The highest rated film was "{best_imdb_film_title}" with rating of {best_imdb_film_rating}')

worst_imdb_film = films_df[films_df['rating'] == films_df['rating'].min()][['Title','rating']]

worst_imdb_film_title = worst_imdb_film['Title'].values[0]
worst_imdb_film_rating = worst_imdb_film['rating'].values[0]

print(f'The worst rated film was "{worst_imdb_film_title}" with rating of {worst_imdb_film_rating}')

print(films_df['Where'].value_counts())

print(films_df.groupby('Where').mean()['rating'].sort_values(ascending=False))

import plotly.express as px

rankings = films_df['2021 Rank'].copy()
normalized_rankings = (rankings-rankings.min())/(rankings.max()-rankings.min())

ratings = films_df['rating'].copy()
normalized_ratings = (ratings-ratings.min())/(ratings.max()-ratings.min())

films_df_with_normalised = films_df.copy()
films_df_with_normalised['normalized_rankings'] = normalized_rankings
films_df_with_normalised['normalized_ratings'] = normalized_ratings

fig = px.scatter(
    films_df_with_normalised,
    x='normalized_ratings',
    y='normalized_rankings',
    color='Where',
    hover_data=['Title'],
    trendline='ols',
    trendline_scope='overall',
    width=800,
    height=400)

fig.update_yaxes(autorange="reversed")
fig.show()