VideoManager: Automatically rename movie files and download subtitles

$VideoManager.md

Works with everything, better suited for RARBG releases.

Installation

pip install subliminal colorama

Quick usage:

• Throw manager.py to the working folder and just write python manager.py
  • Cleans files that are not movies or subtitles
  • For each movie, renames the subtitle found to match the videofile
  • If no subtitle found it downloads it
  • Renames the folder to "Movie (year) [quality]

Complete Features and options

• -h, --help show this help message and exit
• --dry-run Only show what would be done without modifying files
• --no-keyboard-input, -k Dont ask for keyboard input
• `--check CHECK Quantity of files to check in a folder

manager.py

import os
import re
import shutil
import subliminal, babelfish
import argparse
from colorama import Fore, Style

GOOD_CODEC = "RARBG"

# MovieName (year) quality {version}
# Brackets around quality means GOOD CODEC
# {version} optional (like directors cut)
REGEX = r'(.*)\s(\((19|20)\d{2}\))\s(\[?(720p|1080p|480p)\]?)(\s\{.*\})?'
movieRegex = re.compile(REGEX)

FILES_TO_DELETE = ["rarbg.com.mp4", "rarbg.mp4"]
EXT_TO_DELETE = ["nfo","sub", "idx", "jpg", "png", "txt"]
VIDEO_EXTENSIONES = ["mp4", "mkv", "avi", "mpeg", "mov"]
BAD_SPECS = ["YIFY", "Ganool", "Ozlem", "fgt", "MKVCage", "usabit", "vppv", "etrg", "sujaidr"]
DIR_NAME_IMPURITIES = ["x264", "H264", "BrRip", "BluRay", "720", "1080", "720p", "1080p", "WEBRip", BAD_SPECS]

def get_trash(directory):
	to_del = []
	for archivo in os.listdir(directory):
		path = os.path.join(directory, archivo)
		if os.path.isdir(path):
			if archivo.lower() != "subs":
				to_del.append(archivo)
		elif archivo.lower() in FILES_TO_DELETE or archivo.split('.')[-1] in EXT_TO_DELETE:
			to_del.append(archivo)
	return to_del

def delete_trash(directory, to_del, dry_run):
	if not to_del: return False
	for archivo in os.listdir(directory):
		path = os.path.join(directory, archivo)
		if archivo in to_del:
			if not dry_run:
				if os.path.isdir(path):	shutil.rmtree(path)
				else: os.remove(path)
				print(Fore.RED + "\t* Deleted: {}".format(archivo))
			else:
				print(Fore.RED + "\t* DRY RUN: Should delete {}".format(archivo))
	return True

def _get_new_name_input(directory, no_input):
	name = directory
	if not no_input: name = input(Fore.RED + "\t* New name for directory?\n")
	if not name: name = directory
	return name

def get_new_name(directory, flags):
	tag_nombre, tag_anio, tag_calidad, tag_cut = "","","",""
	tags = re.split('[.]| ',directory)
	if len(tags)<3:
		if flags.get('dry_run'):
			print(Fore.RED + "\t* DRY RUN: Auto-Rename not possible")
			return directory
		return _get_new_name_input(directory, flags.get('no_input'))
	for i, tag in enumerate(tags):
		if "720p" in tag or "1080p" in tag or "480p" in tag:
			tag_calidad = tag
			continue
		if "{" in tag:
			tag_start = tag
			for tag_close in tags[i:]:
				if "}" in tag_close:
					tags_temp = tags[tags.index(tag_start):tags.index(tag_close)+1]
					tag_cut = ' '.join(tags_temp)
					continue
		tag_temp = re.sub('[[]|[]]|[(]|[)]','',tag)
		if tag_temp.isdigit() and int(tag_temp) in range(1900, 2030):
			tag_anio = tags[i] = tag_temp
	if not tag_calidad or not tag_anio:
		if flags.get('dry_run'):
			print(Fore.RED + "\t* DRY RUN: Auto-Rename not possible")
			return directory
		return _get_new_name_input(directory, flags.get('no_input'))
	tags = tags[:tags.index(tag_calidad)+1]
	tag_nombre = ' '.join(tags[:tags.index(tag_anio)])
	if tags[tags.index(tag_anio)+1] != tag_calidad:
		tag_cut = ' '.join(tags[tags.index(tag_anio)+1:tags.index(tag_calidad)])
	if tag_cut:
		if "{" not in tag_cut: tag_cut = str("{{{}}}".format(tag_cut))
		tag_cut = " "+tag_cut.lstrip()
	if "(" not in tag_anio:
		tag_anio = str("({})".format(tag_anio))
	if GOOD_CODEC in directory and "[" not in tag_calidad:
		tag_calidad = str("[{}]".format(tag_calidad))
	nombre_nuevo =  "{} {} {}{}".format(tag_nombre,tag_anio,tag_calidad,tag_cut)
	return nombre_nuevo

def rename_dir(directory, new_name, dry_run):
	if new_name != directory:
		if not dry_run:
			os.rename(directory, new_name)
			print(Fore.GREEN + "\t* Renamed to: {}".format(new_name))
		else:
			print(Fore.GREEN + "\t* DRY RUN: Should have been renamed to: {}".format(new_name))
	return True

"""**********   SUBTITLES   ************"""
def extract_subs(directory, dry_run):
	sub_folder,sub,movie_name = "", "", ""
	for dir in os.listdir(directory):
		if dir.lower() == 'subs': sub_folder = dir
	sub_folder_path = os.path.join(directory,sub_folder)
	for f in os.listdir(directory):
		for ext in VIDEO_EXTENSIONES:
			if ext.lower() in f.lower():
				movie_name = os.path.splitext(os.path.basename(f))[0]
	for archivo in os.listdir(sub_folder_path):
		if '.srt' in archivo:
			if not sub: sub = archivo
	if not dry_run:
		if sub_folder:
			if sub:
				sub_path = os.path.join(sub_folder_path, sub)
				shutil.copy(sub_path, directory)
				print(Fore.GREEN + "\t* Extracted: {}".format(sub))
			shutil.rmtree(sub_folder_path)
			print(Fore.RED + "\t* Deleted: {}".format(sub_folder))
	else:
		if sub_folder:
			if sub: print(Fore.GREEN + "\t* DRY RUN: Should have extracted {}".format(sub))
			print(Fore.RED + "\t* DRY RUN: Should have deleted {}".format(sub_folder))
	return sub, movie_name

def rename_sub(directory, sub, movie, dry_run):
	sub_new = movie + '.en.srt'
	sub_path = os.path.join(directory,sub)
	sub_new_path = os.path.join(directory,sub_new)
	if sub_new not in os.listdir(directory):
		if not dry_run:
			os.rename(sub_path, sub_new_path)
			print(Fore.GREEN + "\t* {} -> {}".format(sub, sub_new))
		else:
			print(Fore.GREEN + "\t* DRY RUN: Should have renamed {} -> {}".format(sub, sub_new))
	return sub_new

def clean_subs(directory, sub, dry_run):
	for archivo in os.listdir(directory):
		if ".srt" in archivo and archivo != sub and '.es.' not in archivo:
			path = os.path.join(directory, archivo)
			if not dry_run:
				os.remove(path)
				print(Fore.RED + "\t* Deleted: {}".format(archivo))
			else:
				print(Fore.RED + "\t* DRY RUN: Should have deleted {}".format(archivo))


def download_sub(directory, dry_run):
	if not dry_run:
		try:
			video = (subliminal.scan_videos(directory))[0]
			best_subtitles = subliminal.download_best_subtitles([video],{babelfish.Language('eng'), babelfish.Language('spa')})[video]
			for sub in best_subtitles:
				sub.content.split(b'\n')[2]
				subliminal.save_subtitles(video, [sub])
				print(Fore.GREEN + "\t* Subtitle downloaded and saved from {}".format(sub.provider_name))
		except:
			print(Fore.RED + "\t* Error downloading subtitles")
	else:
		print(Fore.GREEN + "\t* DRY RUN: Should have downloaded subtitles")


"""**********   CHECK   ************"""
def check_dir(quantity_check):
	Style.RESET_ALL
	print()
	no_relation_directories = []
	empty_directories = []
	no_directories = []
	big_directories =[]
	bad_name =[]
	for directory in os.listdir():
		if not os.path.isdir(directory):
			no_directories.append(directory)
			continue
		if len(os.listdir(directory))==0:
			empty_directories.append(directory)
			continue
		if len(os.listdir(directory))==3:
			files = os.listdir(directory)
			name1 = os.path.basename(files[0]).split('.')[0]
			name2 = os.path.basename(files[1]).split('.')[0]
			name3 = os.path.basename(files[2]).split('.')[0]
			if name1 != name2 and name2 != name3: no_relation_directories.append(directory)
		if len(os.listdir(directory))>quantity_check:
			big_directories.append(directory)
		mo = movieRegex.search(directory)
		if not mo or mo.group() != directory:
			bad_name.append(directory)
	Style.RESET_ALL
	if len(no_directories)>1:	print("Archivos sueltos:\n\t* {}".format('\n\t* '.join(no_directories)))
	if big_directories: print("Carpetas con mas de {} archivos:\n\t* {}".format(quantity_check,'\n\t* '.join(big_directories)))
	if empty_directories: print("Carpetas sin archivos:\n\t* {}".format('\n\t* '.join(empty_directories)))
	if no_relation_directories:	print("Carpetas donde el subtitulo y la pelicula no comparten nombre de archivo:\n\t* {}".format('\n\t* '.join(no_relation_directories)))
	if bad_name: print("Carpetas que no cumplen con el nombramiento:\n\t* {}".format('\n\t* '.join(bad_name)))

"""**********   MAIN   ************"""
def main():
	parser = argparse.ArgumentParser()
	parser.add_argument('--dry-run', help='Only show what would be done without modifying files', action='append_const', const=("dry_run",True), dest='flags')
	parser.add_argument('--no-keyboard-input','-y',help='Dont ask for keyboard input', action='append_const', const=("no_input",True), dest='flags')
	parser.add_argument('--check', type=int, default=3,	help='Quantity of files to check in a folder')
	parser.add_argument('--check-only', action='store_true',	help='Only check folder status')

	args = parser.parse_args()
	flags = dict(args.flags) if args.flags else {}
	
	if (args.check_only):
		check_dir(args.check)
		return

	for file in os.listdir():
		if os.path.isdir(file) or file == __file__: continue
		movie_name = os.path.splitext(os.path.basename(file))[0]
		if not flags.get('dry_run'): 
			os.makedirs(movie_name, exist_ok=True)
			shutil.move(file, movie_name)
			print(Fore.GREEN + "* Folder created for {} and file moved".format(file))
		else: print(Fore.GREEN + "* DRY RUN: Should have created folder for {} and moved the file".format(file))
				
	for directory in os.listdir():
		if not os.path.isdir(directory): continue
		print(Style.RESET_ALL + directory)

		to_del = get_trash(directory)
		delete_trash(directory, to_del, flags.get('dry_run'))
		sub, movie_name = extract_subs(directory, flags.get('dry_run'))
		if sub:
			current_sub = rename_sub(directory, sub, movie_name, flags.get('dry_run'))
			clean_subs(directory, current_sub, flags.get('dry_run'))
		else:
			download_sub(directory,flags.get('dry_run'))
		new_name = get_new_name(directory, flags)
		rename_dir(directory, new_name, flags.get('dry_run'))
	
	check_dir(args.check)

main()