migrated letterboxd-grid files

Author: miabobia

.gitignore

@@ -157,4 +157,6 @@ cython_debug/
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
+#.idea/
+
+tmdb_auth.py

config.json

@@ -0,0 +1,9 @@
+{
+"resize_factor": 0.2,
+"image_gap": 10,
+"info_box_width": 500,
+"username_box_height": 50,
+"movie_info_font_size": 12,
+"username_font_size": 20,
+"font_color": [255, 255, 255]
+}

fetch_data.py

@@ -0,0 +1,94 @@
+"""
+eventually API calls will be in place here to extract data
+"""
+
+from bs4 import BeautifulSoup
+import requests
+from datetime import datetime
+import re
+from tmdb_fetch import get_director
+import aiohttp
+import asyncio
+import aiofiles
+from moviecell import MovieCell
+
+async def download(name_url: tuple[str], session):
+    url = name_url[1]
+    filename = name_url[0]
+    async with session.get(url) as response:
+        async with aiofiles.open(filename, "wb") as f:
+            await f.write(await response.read())
+
+async def download_all(name_urls: list[tuple]):
+    async with aiohttp.ClientSession() as session:
+        await asyncio.gather(
+            *[download(name_url, session=session) for name_url in name_urls]
+        )
+
+def rss_feed_exists(page_content: bytes) -> bool:
+    
+    return "<title>Letterboxd - Not Found</title>" in page_content.decode("utf-8")
+
+def scrape(user: str, month: int) -> list:
+    # maybe we split this up into two funcs
+
+    url = f'https://letterboxd.com/{user}/rss/'
+    headers = {'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.95 Safari/537.36'}
+    r = requests.get(url, headers=headers)
+
+    if rss_feed_exists(r.content):
+        raise Exception("ERROR: Username does not exist")
+    
+
+
+    soup = BeautifulSoup(r.content, 'xml')
+
+    items = soup.find_all('item')
+
+    def is_movie(item) -> bool:
+        return  str(item.find('link')).find(f'https://letterboxd.com/{user}/list/') == -1 
+
+    def watched_this_month(item) -> bool:
+        return get_watched_date(item).month == month
+
+    def get_watched_date(item) -> datetime:
+        date_split = re.split(pattern='<|>', string=str(item.find("letterboxd:watchedDate")))[2].split('-')
+        date = datetime(year=int(date_split[0]), month=int(date_split[1]), day=int(date_split[2]))
+        return date
+    
+    def get_movie_title(item) -> str:
+        return re.split(pattern='<|>', string=str(item.find("letterboxd:filmTitle")))[2]
+
+    def get_movie_rating(item) -> int:
+        rating_tag = item.find("letterboxd:memberRating")
+        if not rating_tag: return -1
+        return float(re.split(pattern='<|>', string=str(rating_tag))[2])
+
+    def get_poster_url(item) -> str:
+        # attrs are broken inside description tag so we have to do this a little more manually
+        url_slice = [m.start() for m in re.finditer('"', str(item.find('description')))]
+        return str(item.find('description'))[url_slice[0]+1:url_slice[1]]
+
+    def get_tmdb_id(item) -> int:
+        return int(re.split(pattern='<|>', string=str(item.find("tmdb:movieId")))[2])
+
+    def title_to_image_path(path: str):
+        return 'images/' + path.replace(' ', '-') + '.png'
+
+    # sorting movies by date
+    items = sorted(filter(is_movie, items), key=lambda x: get_watched_date(x), reverse=True)
+    # getting movies watched this month
+    items = list(filter(watched_this_month, items))
+
+    # reverse these? ^^    
+    movie_titles = list(map(get_movie_title, items))
+    movie_ratings = list(map(get_movie_rating, items))
+    movie_directors = list(map(get_director, map(get_tmdb_id, items)))
+    movie_poster_paths = list(map(title_to_image_path, movie_titles))
+
+    # download posters
+    asyncio.run(download_all(zip(movie_poster_paths, map(get_poster_url, items))))
+    
+    # bundling up movies as dataclass now
+
+    return [MovieCell(*movie_data) for movie_data in zip(movie_titles, movie_directors, movie_ratings, movie_poster_paths)]

file_management.py

@@ -0,0 +1,12 @@
+import os
+from glob import glob
+import uuid
+def file_cleanup():
+    files = glob('images/*.png')
+    for f in files:
+        os.remove(f)
+
+def file_saver(username: str, image: "Image") -> str:
+    file_name = f"{username}_{uuid.uuid4()}.png"
+    image.save(f"images/{file_name}")
+    return file_name

font/JuliaMono-Bold.ttf

@@ -0,0 +1,33 @@
+"""
+Functions for getting grid size for image_builder
+"""
+
+def get_factors(n: int) -> tuple:
+	return [(i, n // i) for i in range(1, int(n**0.5)+1) if n % i == 0]
+
+def reorder_pair(pair: tuple) -> tuple:
+	return (max(pair), min(pair))
+
+def factor_to_ratio(pair: tuple) -> float:
+	return pair[0]/pair[1]
+
+def valid_ratio_exists(ratios: list, max_ratio: float, min_ratio: float) -> bool:
+	for ratio in ratios:
+		if ratio >= min_ratio and ratio <= max_ratio:
+			return True
+	return False
+
+def get_grid_size(n: int) -> tuple:
+	MIN_RATIO = 1
+	MAX_RATIO = 2.5
+
+	while True:
+		factors = list(map(reorder_pair, get_factors(n)))
+		print(factors)
+		factor_ratios = list(map(factor_to_ratio, factors))
+		
+		if not valid_ratio_exists(factor_ratios, MAX_RATIO, MIN_RATIO):
+			n+=1
+			continue
+		dist_list = list(map(lambda x: abs(x - (MIN_RATIO + MAX_RATIO)/2), factor_ratios))
+		return factors[dist_list.index(min(dist_list))]

grid_shape.py

@@ -0,0 +1,132 @@
+"""
+Functions for building movie grid image.
+To build call build(list[MovieCell], username: str)
+"""
+
+from PIL import Image, ImageDraw, ImageFont
+from grid_shape import get_grid_size
+import json
+from functools import partial
+import datetime
+
+def trans_paste(fg_img, bg_img, alpha=1.0, box=(0, 0)):
+    fg_img_trans = Image.new("RGBA", fg_img.size)
+    fg_img_trans = Image.blend(fg_img_trans,fg_img, alpha)
+    bg_img.paste(fg_img_trans,box,fg_img_trans)
+    return bg_img
+
+def resize_image(im: Image, w_factor: float, h_factor: float) -> Image:
+	new_size = (int(im.size[0] * w_factor), int(im.size[1] * h_factor))
+	return im.resize(size=new_size)
+
+def build_thumbnail(cell: "MovieCell", resize_factor: float) -> Image:
+	return resize_image(Image.open(cell.im_path), resize_factor, resize_factor)
+
+def build_background(thumbnail_width: int, thumbnail_height: int,
+					 grid_width: int, grid_height: int, text_width: int,
+					 username_box_height: int, image_gap: int) -> Image:
+	return Image.new(
+		mode='RGBA', 
+		size=(thumbnail_width * grid_width + image_gap * (grid_width + 1) + text_width,
+			thumbnail_height * grid_height + image_gap * (grid_height + 1) + username_box_height),
+		color=(50, 50, 50))
+
+def get_max_text_size(text_drawer: ImageDraw, font: ImageFont, text_list: list) -> int:
+	WIDTH_LIMIT = 500
+	max_width = -1
+	for text in text_list:
+		max_width = max(text_drawer.textsize(text, font))
+	return min(max_width, WIDTH_LIMIT)
+
+def build_movie_text(movie_cell: "MovieCell") -> str:
+	mv_text = f'{movie_cell.title} - {movie_cell.director}'
+	if len(mv_text) > 68:
+		director = movie_cell.director.split(' ')
+		director[-1] = director[-1][0]
+		mv_text = f'{movie_cell.title} - {' '.join(map(str, director)) }'
+	return mv_text
+
+def get_text_dimensions(text_string: str, font: ImageFont.truetype):
+    # https://stackoverflow.com/a/46220683/9263761
+    _, descent = font.getmetrics()
+
+    text_width = font.getmask(text_string).getbbox()[2]
+    text_height = font.getmask(text_string).getbbox()[3] + descent
+
+    return (text_width, text_height)
+
+def load_config(path: str) -> list:
+	config: dict
+	with open(path, 'r') as f:
+		config = json.load(f)
+	return (
+		    config['resize_factor'],
+			config['image_gap'], 
+			config['info_box_width'],
+			config['username_box_height'],
+			config['movie_info_font_size'],
+			config['username_font_size'],
+			config['font_color']
+			)
+
+
+def build(movie_cells: list["MovieCell"], username: str, config_path: str) -> Image.Image:
+
+    # loading config file
+    resize_factor, image_gap, info_box_width, \
+	username_box_height, movie_info_font_size, \
+	username_font_size, font_color = load_config(config_path)
+
+    # create dynamically sized grid
+    grid_width, grid_height = get_grid_size(len(movie_cells))
+	
+    # creating thumbnails
+    thumbnails = list(map(partial(build_thumbnail, resize_factor=resize_factor), movie_cells))
+    thumb_width, thumb_height = thumbnails[0].size
+
+    # create background
+    bg = build_background(thumb_width, thumb_height, grid_width, grid_height,
+						  info_box_width, username_box_height, image_gap)
+    
+    # defining fonts
+    info_font = ImageFont.truetype('./font/JuliaMono-Bold.ttf', movie_info_font_size, encoding='utf-8')
+    username_font = ImageFont.truetype('./font/JuliaMono-Bold.ttf', username_font_size, encoding='utf-8')
+    text_drawer = ImageDraw.Draw(bg)
+	
+    # writing username and date to image
+    my_date = datetime.datetime.now()
+    username_str = f'{username} - {my_date.strftime("%B")} {my_date.strftime("%Y")}'
+    username_width, username_height = get_text_dimensions(username_str, username_font)
+    username_x = bg._size[0]//2 - username_width//2
+    username_y = username_box_height//2 - username_height//2
+
+    text_drawer.text((username_x, username_y), username_str, font=username_font,fill=tuple(font_color))
+
+    cell_index = 0
+	
+    # paste thumbnails, text, and stars to background
+    for i in range(grid_width):
+        for j in range(grid_height):
+            if cell_index >= len(movie_cells): break
+
+            # thumbnails
+            im_x = i * thumb_width + image_gap * (i+1)
+            im_y = j * thumb_height + image_gap * (j+1) + username_box_height
+
+            bg.paste(thumbnails[cell_index], (im_x, im_y))
+
+            # text
+            txt_x = grid_width * thumb_width + image_gap * (grid_width+1)
+            txt_y = (j % grid_width) * thumb_height + image_gap * ((j % grid_width) + 1) + (i*20) + username_box_height
+
+            txt_str = build_movie_text(movie_cells[cell_index])
+            print(f'{txt_str} -> {len(txt_str)}')
+
+            text_drawer.text((txt_x, txt_y), txt_str, font=info_font, fill=tuple(font_color))
+
+            # bg.paste(star, (im_x, im_y + star.size[1] - star.size[1]))
+
+            # bg = trans_paste(star, bg, alpha=1.0, box=(im_x, im_y + star.size[1] - star.size[1]))
+            cell_index += 1
+
+    return bg

image_builder.py

@@ -0,0 +1,71 @@
+from datetime import datetime
+from fetch_data import scrape
+from time import time
+from file_management import file_cleanup, file_saver
+from image_builder import build
+from ratio_tester import get_moviecells
+from flask import Flask, redirect, url_for, request, make_response, send_file
+import os
+
+app = Flask(__name__)
+IMAGES_DIRECTORY = './images'
+
+# @app.route('/fetch/<filename>', methods=['GET', 'POST'])
+def return_mosaic(filename: str):
+	print('return mosaic started')
+	try:
+		file_path = os.path.join(IMAGES_DIRECTORY, filename)
+		print(f'OS FILE PATH: {file_path}')
+		if os.path.isfile(file_path):
+			return send_file(file_path, as_attachment=True)
+		else:
+			return make_response(f'File {filename} not found.', 404)
+	except Exception as e:
+		return make_response(f'Error: {str(e)}'), 500
+	
+
+
+@app.route('/getimage', methods=['POST', 'GET'])
+def homepage():
+	if request.method == 'POST':
+		username = request.form['nm']
+		try:
+			movie_cells = scrape(username, datetime.now().month)
+		except Exception("ERROR: Username does not exist"):
+			print('EXCEPTING')
+			return make_response(f'Username {username} does not exist.', 404)
+		
+
+		image = build(movie_cells, username, 'config.json')
+		file_path = file_saver(username, image)
+		return return_mosaic(file_path)
+	else:
+		username = request.form['nm']
+		image = build(scrape(username, datetime.now().month), username, 'config.json')
+		file_path = file_saver(username, image)
+		return return_mosaic(file_path)
+		return redirect(url_for(f'fetch', filename=file_path))
+# def get_image():
+# 	username = 'scooterwhiskey'
+# 	return build(scrape(username, datetime.now().month), username, 'config.json')
+
+
+if __name__ == '__main__':
+	# image_path = 'images/705221-furiosa-a-mad-max-saga-0-1000-0-1500-crop.jpg'
+	t0 = time()
+	# username = 'scooterwhiskey'
+	# cells = scrape(username, datetime.now().month)
+
+	# for cell in cells:
+	# 	print(vars(cell))
+
+	# replace cells with get_moviecells(n) for testing with dummy data
+	# build(cells, username, 'config.json').show()
+	
+	app.run(debug=True)
+	# delete stored files
+	file_cleanup()
+	t1 = time()
+
+	print(f'PROGRAM FINISHED IN {t1-t0}')
+		

main.py

@@ -0,0 +1,11 @@
+"""
+Dataclass for storing movie data taken from fetch_data.py
+"""
+from dataclasses import dataclass
+
+@dataclass
+class MovieCell:
+    title: str
+    director: str
+    rating: int
+    im_path: str

moviecell.py

@@ -0,0 +1,10 @@
+from moviecell import MovieCell
+
+
+def get_moviecells(n: int) -> list[MovieCell]:
+    return [MovieCell(
+        title='The Fifth Element',
+        director='Jeff Green',
+        rating=3.5,
+        im_path='images/The-Fifth-Element.png'
+    ) for _ in range(n)]