Pybites Platform

Back ← Previous Next →

Movie data analysis

Pybites

Level: Intermediate (score: 3)

In this Bite we are going to parse a csv movie dataset to identify the directors with the highest rated movies.

Write get_movies_by_director: use csv.DictReader to convert movie_metadata.csv into a (default)dict of lists of Movie namedtuples. Convert/filter the data:
- Only extract director_name, movie_title, title_year and imdb_score, ignoring movies without all of these fields.
- Type conversions: title_year -> int / imdb_score -> float
- Discard any movies older than 1960.
Here is an extract:
```
....
{ 'Woody Allen': [
    Movie(title='Midnight in Paris', year=2011, score=7.7),
    Movie(title='The Curse of the Jade Scorpion', year=2001, score=6.8),
    Movie(title='To Rome with Love', year=2012, score=6.3),  ....
    ], ...
}
```
Write the calc_mean_score helper that takes a list of Movie namedtuples and calculates the mean IMDb score, returning the score rounded to 1 decimal place.
Complete get_average_scores which takes the directors data structure returned by get_movies_by_director (see 1.) and returns a list of tuples (director, average_score) ordered by highest score in descending order. Only take directors into account with >= MIN_MOVIES

See the tests for more info. This could be tough one, but we really hope you learn a thing or two. Good luck and keep calm and code in Python!

Code
Tests

import csv
from collections import defaultdict, namedtuple
import os
from urllib.request import urlretrieve

BASE_URL = 'https://bites-data.s3.us-east-2.amazonaws.com/'
TMP = os.getenv("TMP", "/tmp")

fname = 'movie_metadata.csv'
remote = os.path.join(BASE_URL, fname)
local = os.path.join(TMP, fname)
urlretrieve(remote, local)

MOVIE_DATA = local
MIN_MOVIES = 4
MIN_YEAR = 1960

Movie = namedtuple('Movie', 'title year score')

def get_movies_by_director():
    """Extracts all movies from csv and stores them in a dict,
    where keys are directors, and values are a list of movies,
    use the defined Movie namedtuple"""
    pass

def calc_mean_score(movies):
    """Helper method to calculate mean of list of Movie namedtuples,
       round the mean to 1 decimal place"""
    pass

def get_average_scores(directors):
    """Iterate through the directors dict (returned by get_movies_by_director),
       return a list of tuples (director, average_score) ordered by highest
       score in descending order. Only take directors into account
       with >= MIN_MOVIES"""
    pass

from collections import defaultdict

import pytest

from directors import (get_movies_by_director, get_average_scores,
                       calc_mean_score, Movie)

@pytest.fixture(scope="module")
def movies():
    return get_movies_by_director()

@pytest.fixture(scope="module")
def scores(movies):
    return get_average_scores(movies)

def test_get_movies_by_director(movies):
    assert 'Sergio Leone' in movies
    assert len(movies['Sergio Leone']) == 4
    assert len(movies['Peter Jackson']) == 12

def test_director_movies_data_structure(movies):
    assert type(movies) in (dict, defaultdict)
    assert type(movies['Peter Jackson']) == list
    assert type(movies['Peter Jackson'][0]) == Movie

def test_calc_mean_score(movies):
    movies_sergio = movies['Sergio Leone']
    movies_nolan = movies['Christopher Nolan']
    assert calc_mean_score(movies_sergio) == 8.5
    assert calc_mean_score(movies_nolan) == 8.4

def test_get_average_scores_top_directors(scores):
    expected = [('Sergio Leone', 8.5),
                ('Christopher Nolan', 8.4),
                ('Quentin Tarantino', 8.2),
                ('Hayao Miyazaki', 8.2),
                ('Frank Darabont', 8.0),
                ('Stanley Kubrick', 8.0),
                ('James Cameron', 7.9),
                ('Joss Whedon', 7.9)]
    assert scores[0:8] == expected

@pytest.mark.parametrize("director", [
    'Quentin Tarantino', 'Hayao Miyazaki',
    'Frank Darabont', 'Stanley Kubrick',
    'James Cameron', 'Joss Whedon',
    'Alejandro G. Iñárritu',
])
def test_director_in_top_scores(director, scores):
    # order / score might slightly change depending the way the mean
    # is calculated so only test director names in top scores
    top_scores = scores[2:13]
    directors = {score[0] for score in top_scores}
    assert director in directors

def test_ignore_older_movies(movies):
    """Lowell Sherman's Black and White is from 1933 and should
       be skipped"""
    assert len(movies["Lowell Sherman"]) == 0