flickpick 0.0.3__py3-none-any.whl

flickpick/__init__.py

@@ -0,0 +1,108 @@
+"""flickpick: a personal movie recommender (Python half: build pipeline and scorer).
+
+Build an artifact set, then recommend from a ratings export:
+
+>>> from flickpick import read_artifacts, read_ratings, recommend, Query  # doctest: +SKIP
+>>> a = read_artifacts('path/to/artifacts')  # doctest: +SKIP
+>>> recommend(a, read_ratings('my_ratings.csv'), Query(mood='slow-burn sci-fi'))  # doctest: +SKIP
+
+From the shell: ``python -m flickpick build --sample`` then
+``python -m flickpick recommend --ratings my_ratings.csv --mood "..."``.
+The formats and the scoring contract are in ``docs/artifact-format.md`` and
+``docs/core-contract.md``.
+
+``import flickpick`` stays light (numpy only): the names from ``build``, ``ease`` and
+``science``, which pull in pandas and scipy, are imported on first access.
+"""
+
+from importlib import import_module
+
+from flickpick.artifacts import (
+    CF,
+    ArtifactFormatError,
+    Artifacts,
+    read_artifacts,
+    validate_artifacts,
+    write_artifacts,
+)
+from flickpick.defaults import DFLT, Defaults
+from flickpick.importers import (
+    detect_format,
+    parse_flickpick,
+    parse_imdb,
+    parse_letterboxd,
+    parse_movielens,
+    parse_ratings,
+    read_ratings,
+)
+from flickpick.ratings import Rating, resolve_ratings
+from flickpick.score import (
+    Query,
+    Recommendation,
+    Weights,
+    embed_query,
+    format_recommendations,
+    recommend,
+    score_cf,
+    score_semantic,
+)
+
+__all__ = [
+    "CF",
+    "ArtifactFormatError",
+    "Artifacts",
+    "read_artifacts",
+    "validate_artifacts",
+    "write_artifacts",
+    "build_artifacts",
+    "DFLT",
+    "Defaults",
+    "ease_dense",
+    "fit_ease",
+    "sparsify_topk",
+    "detect_format",
+    "parse_flickpick",
+    "parse_imdb",
+    "parse_letterboxd",
+    "parse_movielens",
+    "parse_ratings",
+    "read_ratings",
+    "Rating",
+    "resolve_ratings",
+    "agreement",
+    "cross_validated_fit",
+    "holdout_evaluate",
+    "ranking_metrics",
+    "Query",
+    "Recommendation",
+    "Weights",
+    "embed_query",
+    "format_recommendations",
+    "recommend",
+    "score_cf",
+    "score_semantic",
+]
+
+#: public names whose modules import pandas or scipy: name -> module, loaded on access
+_LAZY = {
+    "build_artifacts": "flickpick.build",
+    "ease_dense": "flickpick.ease",
+    "fit_ease": "flickpick.ease",
+    "sparsify_topk": "flickpick.ease",
+    "agreement": "flickpick.science",
+    "cross_validated_fit": "flickpick.science",
+    "holdout_evaluate": "flickpick.science",
+    "ranking_metrics": "flickpick.science",
+}
+
+
+def __getattr__(name: str):
+    if name in _LAZY:
+        value = getattr(import_module(_LAZY[name]), name)
+        globals()[name] = value  # later lookups skip this hook
+        return value
+    raise AttributeError(f"module 'flickpick' has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return sorted({*globals(), *_LAZY})

flickpick/__main__.py

@@ -0,0 +1,15 @@
+# PYTHON_ARGCOMPLETE_OK
+"""CLI entry point: ``python -m flickpick {build,recommend,evaluate} --help``."""
+
+import cw
+
+from flickpick.tools import CLI_CONFIG, CLI_FUNCS, cli_egress
+
+
+def main():
+    """Dispatch the tool functions to the command line."""
+    raise SystemExit(cw.dispatch(CLI_FUNCS, config=CLI_CONFIG, egress=cli_egress))
+
+
+if __name__ == "__main__":
+    main()

flickpick/artifacts.py

@@ -0,0 +1,264 @@
+"""Write and read an artifact set as specified in ``docs/artifact-format.md``.
+
+An artifact set is one directory: ``manifest.json``, ``catalog.json``, the sparse EASE
+matrix as three CSR arrays (``cf_indptr.i32``, ``cf_indices.i32``, ``cf_values.f32``)
+and, optionally, ``embeddings.f32``. Binaries are little-endian, row-major, headerless;
+their shapes are recorded in ``manifest["files"]`` and checked on read.
+
+>>> import numpy as np, tempfile
+>>> rows = [{**dict.fromkeys(CATALOG_FIELDS), 'idx': i, 'imdb_id': f'tt000000{i}',
+...          'title': f'Film {i}', 'genres': [], 'n_ratings': 1} for i in range(2)]
+>>> a = Artifacts(
+...     manifest=mk_manifest(name='toy', n_items=2, sources=[], cf={'method': 'ease'}),
+...     catalog=rows,
+...     cf=CF(np.array([0, 1, 1]), np.array([1]), np.array([0.5])),
+... )
+>>> d = tempfile.mkdtemp()
+>>> _ = write_artifacts(a, d)
+>>> read_artifacts(d).cf.values.tolist()
+[0.5]
+"""
+
+import json
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from functools import cached_property
+from pathlib import Path
+
+import numpy as np
+
+FORMAT_VERSION = 1
+MANIFEST_FILE = "manifest.json"
+CATALOG_FILE = "catalog.json"
+
+#: name in ``manifest["files"]`` -> (file name, numpy little-endian dtype, dtype label)
+BINARY_FILES = {
+    "cf_indptr": ("cf_indptr.i32", "<i4", "int32"),
+    "cf_indices": ("cf_indices.i32", "<i4", "int32"),
+    "cf_values": ("cf_values.f32", "<f4", "float32"),
+    "embeddings": ("embeddings.f32", "<f4", "float32"),
+}
+
+CATALOG_FIELDS = (
+    "idx",
+    "imdb_id",
+    "tmdb_id",
+    "ml_id",
+    "qid",
+    "title",
+    "year",
+    "genres",
+    "n_ratings",
+    "mean_rating",
+    "semantic_text",
+)
+
+
+class ArtifactFormatError(ValueError):
+    """An artifact set does not match ``docs/artifact-format.md``."""
+
+
+@dataclass
+class CF:
+    """The sparsified EASE item-item matrix B in CSR form (rows = source items)."""
+
+    indptr: np.ndarray
+    indices: np.ndarray
+    values: np.ndarray
+
+    def to_scipy(self, n_items: int):
+        """The same matrix as a ``scipy.sparse.csr_matrix`` of shape (n, n)."""
+        from scipy.sparse import csr_matrix
+
+        return csr_matrix(
+            (self.values, self.indices, self.indptr), shape=(n_items, n_items)
+        )
+
+
+@dataclass
+class Artifacts:
+    """One loaded artifact set: manifest, catalogue, CF matrix, optional embeddings."""
+
+    manifest: dict
+    catalog: list[dict]
+    cf: CF
+    embeddings: np.ndarray | None = field(default=None)
+
+    @property
+    def n_items(self) -> int:
+        """Number of items (rows of every file)."""
+        return len(self.catalog)
+
+    @cached_property
+    def n_ratings(self) -> np.ndarray:
+        """Population rating counts, as an array in ``idx`` order."""
+        return np.array([row["n_ratings"] for row in self.catalog], dtype=np.int64)
+
+    @cached_property
+    def imdb_to_idx(self) -> dict[str, int]:
+        """IMDb id -> row index."""
+        return {row["imdb_id"]: row["idx"] for row in self.catalog}
+
+
+def mk_manifest(
+    *,
+    name: str,
+    n_items: int,
+    sources: list[dict],
+    cf: dict,
+    embedding: dict | None = None,
+    built_at: str | None = None,
+) -> dict:
+    """A manifest without ``files`` (``write_artifacts`` fills that in)."""
+    return {
+        "format_version": FORMAT_VERSION,
+        "built_at": built_at
+        or datetime.now(timezone.utc).isoformat(timespec="seconds"),
+        "name": name,
+        "n_items": int(n_items),
+        "sources": list(sources),
+        "cf": dict(cf),
+        "embedding": None if embedding is None else dict(embedding),
+    }
+
+
+def _binary_arrays(a: Artifacts) -> dict[str, np.ndarray]:
+    arrays = {
+        "cf_indptr": a.cf.indptr,
+        "cf_indices": a.cf.indices,
+        "cf_values": a.cf.values,
+    }
+    if a.embeddings is not None:
+        arrays["embeddings"] = a.embeddings
+    return arrays
+
+
+def validate_artifacts(a: Artifacts) -> Artifacts:
+    """Raise ``ArtifactFormatError`` unless every shape and the catalogue agree."""
+    m, n = a.manifest, a.n_items
+
+    def check(ok, msg):
+        if not ok:
+            raise ArtifactFormatError(msg)
+
+    check(
+        m.get("format_version") == FORMAT_VERSION,
+        f"format_version is {m.get('format_version')!r}; this reader supports "
+        f"{FORMAT_VERSION}",
+    )
+    check(
+        m.get("n_items") == n,
+        f"manifest n_items={m.get('n_items')} but the catalogue has {n} rows",
+    )
+    check(
+        [row.get("idx") for row in a.catalog] == list(range(n)),
+        "catalogue rows must be in idx order with idx = 0..n_items-1",
+    )
+    for i, row in enumerate(a.catalog):
+        missing = set(CATALOG_FIELDS) - set(row)
+        check(not missing, f"catalogue row {i} lacks {sorted(missing)}")
+    indptr, indices, values = a.cf.indptr, a.cf.indices, a.cf.values
+    check(
+        indptr.shape == (n + 1,),
+        f"cf_indptr has shape {indptr.shape}, expected ({n + 1},)",
+    )
+    nnz = int(indptr[-1]) if len(indptr) else 0
+    check(
+        indices.shape == (nnz,) and values.shape == (nnz,),
+        f"cf_indices {indices.shape} and cf_values {values.shape} must both have "
+        f"length indptr[-1] = {nnz}",
+    )
+    check(len(indptr) == 0 or int(indptr[0]) == 0, "cf_indptr[0] must be 0")
+    check(bool(np.all(np.diff(indptr) >= 0)), "cf_indptr must be non-decreasing")
+    check(
+        nnz == 0 or (indices.min() >= 0 and indices.max() < n),
+        f"cf_indices must lie in [0, {n})",
+    )
+    spec = m.get("embedding")
+    if spec is None:
+        check(a.embeddings is None, "embeddings present but manifest.embedding is null")
+    else:
+        check(
+            a.embeddings is not None,
+            "manifest.embedding is set but embeddings are missing",
+        )
+        expected = (n, int(spec["dim"]))
+        check(
+            a.embeddings.shape == expected,
+            f"embeddings have shape {a.embeddings.shape}, expected {expected}",
+        )
+    return a
+
+
+def _write_json(path: Path, obj) -> None:
+    path.write_text(
+        json.dumps(obj, ensure_ascii=False, separators=(",", ":")), encoding="utf-8"
+    )
+
+
+def write_artifacts(a: Artifacts, out_dir) -> Path:
+    """Write ``a`` to ``out_dir`` (created if needed) and return the directory path.
+
+    The manifest's ``files`` entry is (re)computed from the arrays.
+    """
+    out = Path(out_dir).expanduser()
+    out.mkdir(parents=True, exist_ok=True)
+    files = {}
+    for name, arr in _binary_arrays(a).items():
+        filename, dtype, label = BINARY_FILES[name]
+        np.ascontiguousarray(arr, dtype=dtype).tofile(out / filename)
+        files[name] = {"path": filename, "dtype": label, "shape": list(arr.shape)}
+    manifest = {**a.manifest, "files": files}
+    validate_artifacts(Artifacts(manifest, a.catalog, a.cf, a.embeddings))
+    _write_json(out / CATALOG_FILE, a.catalog)
+    (out / MANIFEST_FILE).write_text(
+        json.dumps(manifest, ensure_ascii=False, indent=2), encoding="utf-8"
+    )
+    return out
+
+
+def _read_binary(root: Path, name: str, files: Mapping) -> np.ndarray:
+    if name not in files:
+        raise ArtifactFormatError(f"manifest.files has no entry {name!r}")
+    entry = files[name]
+    _, dtype, label = BINARY_FILES[name]
+    if entry.get("dtype") != label:
+        raise ArtifactFormatError(
+            f"{name}: dtype {entry.get('dtype')!r}, expected {label!r}"
+        )
+    path = root / entry["path"]
+    if not path.is_file():
+        raise ArtifactFormatError(f"{name}: file not found: {path}")
+    arr = np.fromfile(path, dtype=dtype)
+    shape = tuple(entry["shape"])
+    if arr.size != int(np.prod(shape)):
+        raise ArtifactFormatError(
+            f"{name}: {arr.size} values on disk but the manifest "
+            f"says shape {list(shape)}"
+        )
+    return arr.reshape(shape).astype(dtype[1:], copy=False)
+
+
+def read_artifacts(source) -> Artifacts:
+    """Load and validate the artifact set in directory ``source``."""
+    root = Path(source).expanduser()
+    manifest_path = root / MANIFEST_FILE
+    if not manifest_path.is_file():
+        raise FileNotFoundError(
+            f"No {MANIFEST_FILE} in {root}. Build an artifact set first: "
+            "python -m flickpick build --sample"
+        )
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    catalog = json.loads((root / CATALOG_FILE).read_text(encoding="utf-8"))
+    files = manifest.get("files", {})
+    cf = CF(
+        *(
+            _read_binary(root, n, files)
+            for n in ("cf_indptr", "cf_indices", "cf_values")
+        )
+    )
+    embeddings = None
+    if manifest.get("embedding") is not None:
+        embeddings = _read_binary(root, "embeddings", files)
+    return validate_artifacts(Artifacts(manifest, catalog, cf, embeddings))

flickpick/build.py

@@ -0,0 +1,180 @@
+"""The build pipeline: MovieLens tables -> catalogue, sparse EASE matrix, embeddings.
+
+``build_artifacts`` is pure (tables in, ``Artifacts`` out; the only side effect is
+running the embedding model). ``tools.build`` adds the download and the write.
+
+The CF set is the ``n_items`` most-rated films that have an IMDb id; ``idx`` orders them
+by rating count (descending, ties by MovieLens id). EASE is trained on ratings at or
+above ``like_threshold`` (on the 0-100 scale; 70 = 3.5 stars), binarised.
+"""
+
+import re
+from collections.abc import Callable
+
+import numpy as np
+import pandas as pd
+from scipy import sparse
+
+from flickpick.artifacts import Artifacts, mk_manifest
+from flickpick.data import MovieLens, movielens_source
+from flickpick.defaults import DFLT, STARS_TO_100
+from flickpick.ease import ease_dense, sparsify_topk
+from flickpick.embedding import embed_texts, embedding_spec
+from flickpick.ratings import imdb_id, split_title_year
+
+NO_GENRES = "(no genres listed)"
+GENRE_SEP = "|"
+TEXT_SEP = ", "
+MEAN_RATING_DECIMALS = 2
+_TRAILING_ARTICLE = re.compile(r"^(.*), (The|A|An)$")
+_PARENTHETICAL_SPLIT = re.compile(r"(\s*\([^()]*\))")
+
+
+def _front_article(text: str) -> str:
+    m = _TRAILING_ARTICLE.match(text.strip())
+    return f"{m.group(2)} {m.group(1)}" if m else text.strip()
+
+
+def clean_title(ml_title: str) -> tuple[str, int | None]:
+    """MovieLens ``"Matrix, The (1999)"`` -> ``("The Matrix", 1999)``.
+
+    Parenthesised alternate titles are kept (they help match other services' titles),
+    with their articles moved to the front too.
+
+    >>> clean_title('Seven (a.k.a. Se7en) (1995)')
+    ('Seven (a.k.a. Se7en)', 1995)
+    >>> clean_title('Shawshank Redemption, The (1994)')
+    ('The Shawshank Redemption', 1994)
+    """
+    title, year = split_title_year(ml_title)
+    parts = _PARENTHETICAL_SPLIT.split(title)
+    head, rest = parts[0], parts[1:]
+    rest = [
+        re.sub(r"\(([^()]*)\)", lambda m: f"({_front_article(m.group(1))})", p)
+        for p in rest
+    ]
+    return _front_article(head) + "".join(rest), year
+
+
+def parse_genres(text) -> list[str]:
+    """``"Action|Sci-Fi"`` -> ``["Action", "Sci-Fi"]``; ``"(no genres listed)"`` -> []."""
+    if text is None or pd.isna(text) or text == NO_GENRES:
+        return []
+    return [g for g in str(text).split(GENRE_SEP) if g]
+
+
+def _optional_int(x):
+    return None if x is None or pd.isna(x) else int(x)
+
+
+def select_items(ml: MovieLens, *, n_items: int) -> pd.DataFrame:
+    """One row per CF item (movieId, imdbId, tmdbId, title, genres, n_ratings, mean)."""
+    stats = ml.ratings.groupby("movieId")["rating"].agg(n_ratings="size", mean="mean")
+    items = (
+        stats.join(ml.links.set_index("movieId"), how="inner")
+        .join(ml.movies.set_index("movieId"), how="inner")
+        .dropna(subset=["imdbId"])
+        .reset_index()
+        .sort_values(["n_ratings", "movieId"], ascending=[False, True])
+    )
+    items = items.drop_duplicates(subset="imdbId", keep="first")
+    return items.head(n_items).reset_index(drop=True)
+
+
+def movie_tags(tags: pd.DataFrame, *, max_tags: int = DFLT.max_tags) -> dict[int, list]:
+    """movieId -> its distinct user tags (lower-cased), most applied first."""
+    t = tags.assign(tag=tags["tag"].astype(str).str.strip().str.lower())
+    t = t[t["tag"] != ""]
+    counts = t.groupby(["movieId", "tag"]).size().reset_index(name="n")
+    counts = counts.sort_values(["movieId", "n", "tag"], ascending=[True, False, True])
+    return {
+        int(mid): list(g["tag"].head(max_tags))
+        for mid, g in counts.groupby("movieId", sort=False)
+    }
+
+
+def catalog_rows(items: pd.DataFrame, tags_by_movie: dict) -> list[dict]:
+    """Catalogue rows (``docs/artifact-format.md``) in ``idx`` order."""
+    rows = []
+    for idx, it in enumerate(items.itertuples(index=False)):
+        title, year = clean_title(str(it.title))
+        genres = parse_genres(it.genres)
+        tags = tags_by_movie.get(int(it.movieId), [])
+        rows.append(
+            {
+                "idx": idx,
+                "imdb_id": imdb_id(int(it.imdbId)),
+                "tmdb_id": _optional_int(it.tmdbId),
+                "ml_id": int(it.movieId),
+                "qid": None,
+                "title": title,
+                "year": year,
+                "genres": genres,
+                "n_ratings": int(it.n_ratings),
+                "mean_rating": round(
+                    float(it.mean) * STARS_TO_100, MEAN_RATING_DECIMALS
+                ),
+                "semantic_text": TEXT_SEP.join([title, *genres, *tags]),
+            }
+        )
+    return rows
+
+
+def like_matrix(
+    ratings: pd.DataFrame, movie_ids, *, like_threshold: float = DFLT.like_threshold
+) -> sparse.csr_matrix:
+    """Binary users x items matrix of likes, columns in the order of ``movie_ids``."""
+    col = pd.Series(np.arange(len(movie_ids)), index=np.asarray(movie_ids))
+    liked = ratings[ratings["rating"] * STARS_TO_100 >= like_threshold]
+    liked = liked[liked["movieId"].isin(col.index)]
+    users, user_codes = np.unique(liked["userId"].to_numpy(), return_inverse=True)
+    cols = col.loc[liked["movieId"].to_numpy()].to_numpy()
+    data = np.ones(len(cols), dtype=np.float64)
+    return sparse.csr_matrix(
+        (data, (user_codes, cols)), shape=(len(users), len(movie_ids))
+    )
+
+
+def build_artifacts(
+    ml: MovieLens,
+    *,
+    n_items: int = DFLT.n_items,
+    topk: int = DFLT.topk,
+    lam: float = DFLT.ease_lambda,
+    like_threshold: float = DFLT.like_threshold,
+    embeddings: bool = True,
+    embedding_model: str = DFLT.embedding_model,
+    embed: Callable | None = None,
+    max_tags: int = DFLT.max_tags,
+) -> Artifacts:
+    """Build an in-memory artifact set from MovieLens tables.
+
+    ``embed`` (texts -> L2-normalised float32 array) replaces the default encoder,
+    which is ``embed_texts`` with ``embedding_model``.
+    """
+    items = select_items(ml, n_items=n_items)
+    catalog = catalog_rows(items, movie_tags(ml.tags, max_tags=max_tags))
+    X = like_matrix(ml.ratings, items["movieId"], like_threshold=like_threshold)
+    cf = sparsify_topk(ease_dense(X, lam=lam), topk=topk)
+    spec, vectors = None, None
+    if embeddings:
+        embed = embed or (lambda texts: embed_texts(texts, model=embedding_model))
+        vectors = np.asarray(
+            embed([r["semantic_text"] for r in catalog]), dtype=np.float32
+        )
+        spec = embedding_spec(model=embedding_model, dim=vectors.shape[1])
+    manifest = mk_manifest(
+        name=f"flickpick-{ml.name}-{len(catalog)}",
+        n_items=len(catalog),
+        sources=[movielens_source(ml.name)],
+        cf={
+            "method": "ease",
+            "topk": int(topk),
+            "lambda": float(lam),
+            "n_train_users": int(X.shape[0]),
+            "n_train_ratings": int(X.nnz),
+            "like_threshold": float(like_threshold),
+        },
+        embedding=spec,
+    )
+    return Artifacts(manifest=manifest, catalog=catalog, cf=cf, embeddings=vectors)

flickpick/data/examples/movie_ratings_various.csv

@@ -0,0 +1,117 @@
+movie_id,imdb_id,tmdb_id,rating,average_rating,title
+47,114369,807,95,81.88,Se7en (1995)
+50,114814,629,98,85.1,The Usual Suspects (1995)
+293,110413,101,99,81.83,Léon: The Professional (1994)
+296,110912,680,95,83.9,Pulp Fiction (1994)
+318,111161,278,99,88.29,The Shawshank Redemption (1994)
+527,108052,424,94,84.7,Schindler's List (1993)
+593,102926,274,95,83,The Silence of the Lambs (1991)
+858,68646,238,99,86.43,The Godfather (1972)
+1193,73486,510,99,84.14,One Flew Over the Cuckoo's Nest (1975)
+1196,80684,1891,94,82.29,The Empire Strikes Back (1980)
+1198,82971,85,97,81.91,Raiders of the Lost Ark (1981)
+1221,71562,240,99,85.38,The Godfather Part II (1974)
+1246,97165,207,94,78.97,Dead Poets Society (1989)
+1258,81505,694,99,80.76,The Shining (1980)
+2324,118799,637,96,83.14,Life Is Beautiful (1997)
+2571,133093,603,95,83.31,The Matrix (1999)
+2762,167404,745,96,80.09,The Sixth Sense (1999)
+2858,169547,14,95,81.85,American Beauty (1999)
+2959,137523,550,96,84.75,Fight Club (1999)
+2997,120601,492,97,78.66,Being John Malkovich (1999)
+4973,211915,194,99,81.58,Amélie (2001)
+5418,258463,2501,98,78.15,The Bourne Identity (2002)
+7361,338013,38,98,81.33,Eternal Sunshine of the Spotless Mind (2004)
+48516,407887,1422,99,82.68,The Departed (2006)
+58559,468569,155,98,83.77,The Dark Knight (2008)
+99114,1853728,68718,97,80.8,Django Unchained (2012)
+260,76759,11,90,81.72,Star Wars (1977)
+356,109830,13,92,81.44,Forrest Gump (1994)
+608,116282,275,91,82.34,Fargo (1996)
+1704,119217,489,89,82.33,Good Will Hunting (1997)
+2329,120586,73,94,82.58,American History X (1998)
+2692,130827,104,95,79.07,Run Lola Run (1998)
+4226,209144,77,92,82.71,Memento (2000)
+4963,240772,161,95,76.4,Ocean's Eleven (2001)
+34162,396269,9522,94,68.58,Wedding Crashers (2005)
+50872,382932,2062,93,76.85,Ratatouille (2007)
+111759,1631867,137113,94,79.39,Edge of Tomorrow (2014)
+134853,2096673,150540,93,78.16,Inside Out (2015)
+202439,6751668,496243,93,86.04,Parasite (2019)
+32,114746,63,84,77.93,Twelve Monkeys (1995)
+480,107290,329,80,74.06,Jurassic Park (1993)
+589,103064,280,83,79.44,Terminator 2: Judgment Day (1991)
+778,117951,627,84,80.27,Trainspotting (1996)
+1036,95016,562,82,78.96,Die Hard (1988)
+1089,105236,500,89,81.84,Reservoir Dogs (1992)
+1136,71853,762,84,82.59,Monty Python and the Holy Grail (1975)
+1213,99685,769,81,83.9,GoodFellas (1990)
+1214,78748,348,82,81.5,Alien (1979)
+1247,61722,37247,80,80.26,The Graduate (1967)
+1265,107048,137,82,78.16,Groundhog Day (1993)
+1625,119174,2649,83,77.42,The Game (1997)
+1732,118715,115,86,79.9,The Big Lebowski (1998)
+1961,95953,380,83,78.21,Rain Man (1988)
+2502,151804,1542,84,79.79,Office Space (1999)
+3578,172495,98,82,79.58,Gladiator (2000)
+4022,162222,8358,80,73.99,Cast Away (2000)
+4262,86250,111,81,78.83,Scarface (1983)
+5218,268380,425,81,70.62,Ice Age (2002)
+5989,264464,640,85,79.44,Catch Me If You Can (2002)
+6874,266697,24,84,77.21,Kill Bill: Vol. 1 (2003)
+7438,378194,393,84,76.55,Kill Bill: Vol. 2 (2004)
+30749,395169,205,83,79.17,Hotel Rwanda (2004)
+44555,405094,582,84,83.73,The Lives of Others (2006)
+63082,1010048,12405,83,76.45,Slumdog Millionaire (2008)
+68954,1049413,14160,82,79.14,Up (2009)
+69122,1119646,18785,83,72.18,The Hangover (2009)
+79132,1375666,27205,82,83.46,Inception (2010)
+106920,1798709,152601,85,77.93,Her (2013)
+152081,2948356,269149,83,76.92,Zootopia (2016)
+168250,5052448,419430,82,79.57,Get Out (2017)
+207313,8946378,546554,87,80.66,Knives Out (2019)
+225173,2948372,508442,83,77.88,Soul (2020)
+322321,12042730,687163,86,82.26,Project Hail Mary (2026)
+327081,33764258,1368337,82,80.04,The Odyssey (2026)
+508,107818,9800,72,75.96,Philadelphia (1993)
+541,83658,78,73,82.21,Blade Runner (1982)
+750,57012,935,70,83.85,Dr. Strangelove or: How I Learned to Stop Worrying and Love the Bomb (1964)
+912,34583,289,70,83.75,Casablanca (1943)
+1097,83866,601,73,74.74,E.T. the Extra-Terrestrial (1982)
+1203,50083,389,71,85.55,12 Angry Men (1957)
+1263,77416,11778,73,79.23,The Deer Hunter (1978)
+1270,88763,105,72,79.46,Back to the Future (1985)
+1527,119116,18,74,75.87,The Fifth Element (1997)
+3147,120689,497,70,80.94,The Green Mile (1999)
+3948,212338,1597,68,67.83,Meet the Parents (2000)
+3994,217869,9741,77,70.26,Unbreakable (2000)
+4027,190590,134,72,77.48,"O Brother, Where Art Thou? (2000)"
+4995,268978,453,73,79.27,A Beautiful Mind (2001)
+5618,245429,129,74,84.44,Spirited Away (2001)
+5669,310793,1430,72,73.38,Bowling for Columbine (2002)
+6502,289043,170,76,75.56,28 Days Later (2002)
+8874,365748,747,69,77.53,Shaun of the Dead (2004)
+8961,317705,9806,70,76.92,The Incredibles (2004)
+44191,434409,752,71,78.08,V for Vendetta (2006)
+45720,458352,350,74,70.85,The Devil Wears Prada (2006)
+48385,443453,496,73,68.62,Borat: Cultural Learnings of America for Make Benefit Glorious Nation of Kazakhstan (2006)
+49272,381061,36557,71,76.83,Casino Royale (2006)
+55247,758758,5915,69,76.84,Into the Wild (2007)
+59784,441773,9502,71,72.91,Kung Fu Panda (2008)
+68157,361748,16869,70,80.97,Inglourious Basterds (2009)
+72998,499549,19995,72,71.86,Avatar (2009)
+84152,1219289,51876,71,76.83,Limitless (2011)
+106782,993846,106646,74,79.06,The Wolf of Wall Street (2013)
+112552,2582802,244786,70,83.17,Whiplash (2014)
+112556,2267998,210577,75,79.17,Gone Girl (2014)
+1968,88847,2108,66,76.48,The Breakfast Club (1985)
+2115,87469,87,62,73.99,Indiana Jones and the Temple of Doom (1984)
+4816,196229,9398,61,64.92,Zoolander (2001)
+8464,390521,9372,60,68.73,Super Size Me (2004)
+32587,401792,187,60,74.97,Sin City (2005)
+33493,121766,1895,61,68.07,Star Wars: Episode III - Revenge of the Sith (2005)
+96079,1074638,37724,60,74.95,Skyfall (2012)
+116797,2084970,205596,63,79.9,The Imitation Game (2014)
+3949,180093,641,37,79.62,Requiem for a Dream (2000)
+5507,295701,7451,42,55.74,xXx (2002)
+8984,349903,163,45,67.11,Ocean's Twelve (2004)