286 lines
8.3 KiB
Python
Executable File
286 lines
8.3 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""
|
|
Import movies from Letterboxd diary to Hugo draft posts.
|
|
|
|
Usage:
|
|
python scripts/import_letterboxd.py # Interactive mode - pick from recent
|
|
python scripts/import_letterboxd.py --latest # Import most recent entry
|
|
python scripts/import_letterboxd.py --list # Just list recent entries
|
|
"""
|
|
|
|
import argparse
|
|
import os
|
|
import re
|
|
import sys
|
|
from datetime import datetime
|
|
from pathlib import Path
|
|
from urllib.parse import urlparse
|
|
import xml.etree.ElementTree as ET
|
|
|
|
import requests
|
|
|
|
# Configuration
|
|
LETTERBOXD_USER = "marcusEID"
|
|
TMDB_API_KEY = "9e36fdcf70a4918e0dce327acc437dff" # From get_posters.py
|
|
RSS_URL = f"https://letterboxd.com/{LETTERBOXD_USER}/rss/"
|
|
|
|
# Paths (relative to script location)
|
|
SCRIPT_DIR = Path(__file__).parent
|
|
PROJECT_ROOT = SCRIPT_DIR.parent
|
|
CONTENT_DIR = PROJECT_ROOT / "content" / "posts"
|
|
IMAGES_DIR = PROJECT_ROOT / "static" / "images" / "posters"
|
|
|
|
# XML namespaces in Letterboxd RSS
|
|
NAMESPACES = {
|
|
"letterboxd": "https://letterboxd.com",
|
|
"tmdb": "https://themoviedb.org",
|
|
"dc": "http://purl.org/dc/elements/1.1/",
|
|
}
|
|
|
|
|
|
def fetch_rss():
|
|
"""Fetch and parse Letterboxd RSS feed."""
|
|
resp = requests.get(RSS_URL, timeout=10)
|
|
resp.raise_for_status()
|
|
return ET.fromstring(resp.content)
|
|
|
|
|
|
def parse_movies(root):
|
|
"""Extract movie entries from RSS (skip lists)."""
|
|
movies = []
|
|
for item in root.findall(".//item"):
|
|
# Skip lists (they don't have tmdb:movieId)
|
|
tmdb_id = item.find("tmdb:movieId", NAMESPACES)
|
|
if tmdb_id is None:
|
|
continue
|
|
|
|
title = item.find("letterboxd:filmTitle", NAMESPACES)
|
|
year = item.find("letterboxd:filmYear", NAMESPACES)
|
|
rating = item.find("letterboxd:memberRating", NAMESPACES)
|
|
watched = item.find("letterboxd:watchedDate", NAMESPACES)
|
|
rewatch = item.find("letterboxd:rewatch", NAMESPACES)
|
|
link = item.find("link")
|
|
|
|
movies.append({
|
|
"tmdb_id": tmdb_id.text,
|
|
"title": title.text if title is not None else "Unknown",
|
|
"year": year.text if year is not None else "",
|
|
"rating": rating.text if rating is not None else "",
|
|
"watched_date": watched.text if watched is not None else "",
|
|
"rewatch": rewatch.text if rewatch is not None else "No",
|
|
"letterboxd_url": link.text if link is not None else "",
|
|
})
|
|
|
|
return movies
|
|
|
|
|
|
def get_tmdb_details(tmdb_id):
|
|
"""Fetch movie details from TMDB including IMDB ID and poster."""
|
|
url = f"https://api.themoviedb.org/3/movie/{tmdb_id}"
|
|
params = {"api_key": TMDB_API_KEY}
|
|
resp = requests.get(url, params=params, timeout=10)
|
|
resp.raise_for_status()
|
|
data = resp.json()
|
|
|
|
return {
|
|
"imdb_id": data.get("imdb_id", ""),
|
|
"poster_path": data.get("poster_path", ""),
|
|
"overview": data.get("overview", ""),
|
|
}
|
|
|
|
|
|
def download_poster(poster_path, filename):
|
|
"""Download poster from TMDB to static/images/posters/."""
|
|
if not poster_path:
|
|
print(" No poster available")
|
|
return None
|
|
|
|
# Use w500 size for good quality without being huge
|
|
url = f"https://image.tmdb.org/t/p/w500{poster_path}"
|
|
resp = requests.get(url, timeout=10)
|
|
resp.raise_for_status()
|
|
|
|
IMAGES_DIR.mkdir(parents=True, exist_ok=True)
|
|
filepath = IMAGES_DIR / filename
|
|
filepath.write_bytes(resp.content)
|
|
print(f" Poster saved: {filepath.relative_to(PROJECT_ROOT)}")
|
|
return f"/images/posters/{filename}"
|
|
|
|
|
|
def slugify(title):
|
|
"""Convert title to URL-friendly slug."""
|
|
slug = title.lower()
|
|
slug = re.sub(r"[^a-z0-9\s-]", "", slug)
|
|
slug = re.sub(r"[\s_]+", "-", slug)
|
|
slug = re.sub(r"-+", "-", slug)
|
|
return slug.strip("-")
|
|
|
|
|
|
def rating_to_stars(rating):
|
|
"""Convert numeric rating to star display."""
|
|
if not rating:
|
|
return ""
|
|
r = float(rating)
|
|
full = int(r)
|
|
half = r - full >= 0.5
|
|
stars = "*" * full
|
|
if half:
|
|
stars += " 1/2"
|
|
return f"{stars} ({rating})"
|
|
|
|
|
|
def create_draft_post(movie, tmdb_details, poster_url):
|
|
"""Create a Hugo draft post for the movie."""
|
|
slug = slugify(movie["title"])
|
|
filename = f"{slug}.md"
|
|
filepath = CONTENT_DIR / filename
|
|
|
|
if filepath.exists():
|
|
print(f" Post already exists: {filepath.relative_to(PROJECT_ROOT)}")
|
|
return None
|
|
|
|
# Format the date for Hugo
|
|
now = datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
|
|
|
|
# Format watched date nicely
|
|
watched = movie["watched_date"]
|
|
if watched:
|
|
try:
|
|
dt = datetime.strptime(watched, "%Y-%m-%d")
|
|
watched_display = dt.strftime("%B %d, %Y")
|
|
except ValueError:
|
|
watched_display = watched
|
|
else:
|
|
watched_display = ""
|
|
|
|
imdb_id = tmdb_details.get("imdb_id", "")
|
|
rating_display = rating_to_stars(movie["rating"])
|
|
|
|
# Build the frontmatter and content
|
|
content = f'''---
|
|
title: '{movie["title"]}'
|
|
date: {now}
|
|
draft: true
|
|
series: "Frank's Couch"
|
|
summary: ""
|
|
imdb: "{imdb_id}"
|
|
poster: "{poster_url or ''}"
|
|
tags:
|
|
- gucci
|
|
- ghost theater
|
|
- marcel
|
|
- amc-south
|
|
- amc-lakeline
|
|
- anticipated
|
|
- no-expectations
|
|
- had pizza
|
|
---
|
|
{{{{< imdbposter >}}}}
|
|
|
|
| Date watched | {watched_display} |
|
|
|---------------------|-------------------|
|
|
| Show Time | |
|
|
| Theater | |
|
|
| Theater Number | |
|
|
| Pizza | |
|
|
| Tickets | |
|
|
| Letterboxd Rating | {rating_display} |
|
|
| Crew | |
|
|
|
|
{{{{< /imdbposter >}}}}
|
|
|
|
Write your review here...
|
|
|
|
'''
|
|
|
|
filepath.write_text(content)
|
|
print(f" Draft created: {filepath.relative_to(PROJECT_ROOT)}")
|
|
return filepath
|
|
|
|
|
|
def display_movies(movies, limit=10):
|
|
"""Display a list of recent movies."""
|
|
print(f"\nRecent movies from Letterboxd ({LETTERBOXD_USER}):\n")
|
|
for i, m in enumerate(movies[:limit], 1):
|
|
rewatch = " (rewatch)" if m["rewatch"] == "Yes" else ""
|
|
rating = f" - {m['rating']}*" if m["rating"] else ""
|
|
print(f" {i}. {m['title']} ({m['year']}){rating}{rewatch}")
|
|
print(f" Watched: {m['watched_date']}")
|
|
print()
|
|
|
|
|
|
def import_movie(movie):
|
|
"""Import a single movie: fetch details, download poster, create post."""
|
|
print(f"\nImporting: {movie['title']} ({movie['year']})")
|
|
|
|
# Get TMDB details
|
|
print(" Fetching TMDB details...")
|
|
tmdb = get_tmdb_details(movie["tmdb_id"])
|
|
|
|
# Download poster
|
|
poster_url = None
|
|
if tmdb["poster_path"]:
|
|
print(" Downloading poster...")
|
|
poster_filename = f"{slugify(movie['title'])}.jpg"
|
|
poster_url = download_poster(tmdb["poster_path"], poster_filename)
|
|
|
|
# Create draft post
|
|
print(" Creating draft post...")
|
|
filepath = create_draft_post(movie, tmdb, poster_url)
|
|
|
|
if filepath:
|
|
print(f"\nDone! Edit your draft at: {filepath.relative_to(PROJECT_ROOT)}")
|
|
if tmdb.get("imdb_id"):
|
|
print(f"IMDB: https://www.imdb.com/title/{tmdb['imdb_id']}/")
|
|
|
|
return filepath
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description="Import Letterboxd movies to Hugo")
|
|
parser.add_argument("--latest", action="store_true", help="Import most recent entry")
|
|
parser.add_argument("--list", action="store_true", help="Just list recent entries")
|
|
parser.add_argument("--count", type=int, default=10, help="Number of entries to show")
|
|
args = parser.parse_args()
|
|
|
|
print("Fetching Letterboxd RSS feed...")
|
|
try:
|
|
root = fetch_rss()
|
|
except Exception as e:
|
|
print(f"Error fetching RSS: {e}")
|
|
sys.exit(1)
|
|
|
|
movies = parse_movies(root)
|
|
if not movies:
|
|
print("No movies found in feed.")
|
|
sys.exit(1)
|
|
|
|
if args.list:
|
|
display_movies(movies, args.count)
|
|
sys.exit(0)
|
|
|
|
if args.latest:
|
|
import_movie(movies[0])
|
|
sys.exit(0)
|
|
|
|
# Interactive mode
|
|
display_movies(movies, args.count)
|
|
|
|
try:
|
|
choice = input("Enter number to import (or 'q' to quit): ").strip()
|
|
if choice.lower() == 'q':
|
|
sys.exit(0)
|
|
idx = int(choice) - 1
|
|
if 0 <= idx < len(movies):
|
|
import_movie(movies[idx])
|
|
else:
|
|
print("Invalid selection")
|
|
sys.exit(1)
|
|
except (ValueError, KeyboardInterrupt):
|
|
print("\nCancelled")
|
|
sys.exit(1)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|