|
|
#!/usr/bin/python3
|
|
|
"""
|
|
|
Simple script that extracts information from Télé 7 jours and TMDB
|
|
|
to help select and plan the movies you want to record with your Freebox
|
|
|
"""
|
|
|
import argparse
|
|
|
import datetime
|
|
|
import json
|
|
|
import logging
|
|
|
import os
|
|
|
import re
|
|
|
import requests
|
|
|
import socket
|
|
|
import textwrap
|
|
|
import tmdbsimple
|
|
|
from pyfbx.pyfbx import Fbx
|
|
|
from bs4 import BeautifulSoup
|
|
|
from collections import deque
|
|
|
|
|
|
|
|
|
class Movie:
|
|
|
def __init__(self):
|
|
|
self.day = ''
|
|
|
self.title = ''
|
|
|
self.genre = ''
|
|
|
self.channel = ''
|
|
|
self.rating = ''
|
|
|
self.original_title = ''
|
|
|
self.overview = ''
|
|
|
self.good = False
|
|
|
self.tmdb_id = ''
|
|
|
self.url = ''
|
|
|
self.user_selected = False
|
|
|
self.date = 0
|
|
|
self.start_time = 0
|
|
|
self.end_time = 0
|
|
|
self.year = ''
|
|
|
|
|
|
def __str__(self):
|
|
|
return '{}: {} - {} ({})\n TMDB: {} - {} - {}\n @ {}\n {}'.format(
|
|
|
'Today' if self.day == '' else self.day,
|
|
|
self.title,
|
|
|
self.genre,
|
|
|
self.channel,
|
|
|
self.rating,
|
|
|
self.original_title,
|
|
|
self.year,
|
|
|
self.url,
|
|
|
self.overview
|
|
|
)
|
|
|
|
|
|
def __repr__(self):
|
|
|
return "Movie <{} (D:{} — Ch:{} – R:{})>".format(
|
|
|
self.title,
|
|
|
'Today' if self.day == '' else self.day,
|
|
|
self.channel,
|
|
|
self.rating
|
|
|
)
|
|
|
|
|
|
|
|
|
class TVGuideScraper:
|
|
|
TV_GUIDE_URL = 'https://www.programme-television.org/{}?bouquet=free'
|
|
|
|
|
|
def findAllMovies():
|
|
|
movies = []
|
|
|
days = deque(['lundi', 'mardi', 'mercredi',
|
|
|
'jeudi', 'vendredi', 'samedi', 'dimanche'])
|
|
|
offset = datetime.datetime.today().weekday()
|
|
|
days.rotate(-1-offset)
|
|
|
days.appendleft('')
|
|
|
date = datetime.date.today()
|
|
|
for day in days:
|
|
|
movies += TVGuideScraper._getMovies(day, date)
|
|
|
date += datetime.timedelta(days=1)
|
|
|
logging.debug('Found the following movies: {}'.format(movies))
|
|
|
return movies
|
|
|
|
|
|
@staticmethod
|
|
|
def _getMovies(day='', date=datetime.date.today()):
|
|
|
url = TVGuideScraper.TV_GUIDE_URL.format(day)
|
|
|
logging.info('Connecting to {}'.format(url))
|
|
|
r = requests.get(url)
|
|
|
r.raise_for_status()
|
|
|
html = BeautifulSoup(r.text, 'html.parser')
|
|
|
movies = []
|
|
|
for channel in html.select('.bloc_cnt'):
|
|
|
if len(channel.select('em')):
|
|
|
for movietag in channel.find_all(TVGuideScraper._tag_is_movie):
|
|
|
movie = Movie()
|
|
|
movie.title = \
|
|
|
movietag.select('.texte_titre a')[0]['title']
|
|
|
movie.genre = movietag.select('.texte_cat a')[0].string
|
|
|
movie.channel = channel.select('em')[0]\
|
|
|
.string.replace('Programme ', '')
|
|
|
movie.day = day.title()
|
|
|
movie.date = datetime.date.strftime(date, '%Y-%m-%d')
|
|
|
movie.start_time = datetime.datetime.strptime(
|
|
|
'{} {}'.format(
|
|
|
movie.date,
|
|
|
movietag.select('.horaire')[0].string
|
|
|
),
|
|
|
'%Y-%m-%d %H:%M'
|
|
|
)
|
|
|
duration = TVGuideScraper._parse_duration(
|
|
|
movietag.select('.texte_cat')[0]
|
|
|
.contents[1].strip(' \n\t()')
|
|
|
)
|
|
|
movie.end_time = movie.start_time + duration
|
|
|
|
|
|
logging.debug('Found movie: {0!r}'.format(movie))
|
|
|
movies.append(movie)
|
|
|
|
|
|
return movies
|
|
|
|
|
|
@staticmethod
|
|
|
def _tag_is_movie(tag):
|
|
|
"""
|
|
|
Helper to check if a tag is a movie
|
|
|
"""
|
|
|
return (
|
|
|
tag.has_attr('data-nature')
|
|
|
and
|
|
|
tag['data-nature'] == 'films-telefilms'
|
|
|
)
|
|
|
|
|
|
@staticmethod
|
|
|
def _parse_duration(text):
|
|
|
match = re.match(r"((?P<hours>\d+)h)?(?P<minutes>\d+)mn", text)
|
|
|
if not match:
|
|
|
error = "Could not parse duration '{}'".format(text)
|
|
|
logging.error(error)
|
|
|
raise ValueError(error)
|
|
|
hours = int(match.group('hours')) if match.group('hours') else 0
|
|
|
minutes = int(match.group('minutes'))
|
|
|
return datetime.timedelta(hours=hours, minutes=minutes)
|
|
|
|
|
|
|
|
|
class FreeboxMoviePlanner:
|
|
|
def __init__(self, movies, excluded_channels=[], excluded_directory=[]):
|
|
|
logging.debug('Opening config file: config.json')
|
|
|
with open('config.json') as config_file:
|
|
|
self.config = json.load(config_file)
|
|
|
if(len(self.config['freebox-session-token']) != 64):
|
|
|
self.createAuthenticationToken()
|
|
|
tmdbsimple.API_KEY = self.config['tmdb-api']
|
|
|
self.movies = movies
|
|
|
self.excluded_directory = excluded_directory
|
|
|
|
|
|
logging.info('Opening Freebox session')
|
|
|
self.freebox = Fbx()
|
|
|
self.freebox.mksession(
|
|
|
app_id='FreeboxMoviePlanner',
|
|
|
token=self.config['freebox-session-token']
|
|
|
)
|
|
|
self.getListOfAvailableChannels(excluded_channels)
|
|
|
self.excludeUnavailableChannels()
|
|
|
self.excludeTelevisionMovie()
|
|
|
self.findMoviesOnTMDB()
|
|
|
self.excludeBadRatings()
|
|
|
for directory in self.excluded_directory:
|
|
|
self.excludeLocalMovies(directory)
|
|
|
self.askForUserSelection()
|
|
|
self.excludeNotSelected()
|
|
|
self.programMovies()
|
|
|
self.checkForConflicts()
|
|
|
|
|
|
def createAuthenticationToken(self):
|
|
|
logging.info('Creating authentication token')
|
|
|
self.freebox = Fbx()
|
|
|
hostname = socket.gethostname()
|
|
|
print("You don't seem to have an authentication token.")
|
|
|
print("I will now atempt to create one.")
|
|
|
print("Please go to your Freebox and accept the authentication.")
|
|
|
token = self.freebox.register(
|
|
|
"FreeboxMoviePlanner", "FreeboxMoviePlanner", hostname
|
|
|
)
|
|
|
self.config['freebox-session-token'] = token
|
|
|
with open('config.json', 'w') as outfile:
|
|
|
json.dump(self.config, outfile, indent=4, sort_keys=True)
|
|
|
|
|
|
def __repr__(self):
|
|
|
result = 'FreeboxMoviePlanner <Movies:\n'
|
|
|
for movie in self.movies:
|
|
|
result += ' {!r}\n'.format(movie)
|
|
|
result += '>'
|
|
|
return result
|
|
|
|
|
|
def getListOfAvailableChannels(self, excluded_channels):
|
|
|
logging.info('Getting the list of available channels')
|
|
|
self.channels = {}
|
|
|
for channel in self.freebox.Tv.Getting_the_list_of_channels().values():
|
|
|
if channel['available']:
|
|
|
if channel['name'] in excluded_channels:
|
|
|
logging.debug(
|
|
|
"Excluding '{}'".format(channel['name'])
|
|
|
)
|
|
|
else:
|
|
|
self.channels[channel['name']] = channel['uuid']
|
|
|
else:
|
|
|
logging.debug("Dropping '{}'".format(channel['name']))
|
|
|
logging.debug('Got the following channels: {}'.format(self.channels))
|
|
|
|
|
|
def printAllMovies(self):
|
|
|
for movie in self.movies:
|
|
|
print('{!r}'.format(movie))
|
|
|
|
|
|
def askForUserSelection(self):
|
|
|
for movie in self.movies:
|
|
|
print()
|
|
|
print(movie)
|
|
|
reply = input("Interested? (y)es/(N)o/(q)uit: ")
|
|
|
if reply.upper() == "Y":
|
|
|
movie.user_selected = True
|
|
|
elif reply.upper() == "Q":
|
|
|
break
|
|
|
|
|
|
def findMoviesOnTMDB(self):
|
|
|
for movie in self.movies:
|
|
|
tmdb_details = self._findMovieOnTMDB(movie.title)
|
|
|
if tmdb_details:
|
|
|
movie.rating = tmdb_details['vote_average']
|
|
|
movie.original_title = \
|
|
|
tmdb_details['original_title']
|
|
|
movie.overview = '\n '.join(textwrap.wrap(
|
|
|
tmdb_details['overview'], 75)
|
|
|
)
|
|
|
movie.tmdb_id = tmdb_details['id']
|
|
|
movie.good = \
|
|
|
float(movie.rating) >= self.config['minimum-rating']
|
|
|
movie.url = 'https://www.themoviedb.org/movie/{}?language={}' \
|
|
|
.format(movie.tmdb_id, self.config['tmdb-language'])
|
|
|
try:
|
|
|
movie.year = datetime.datetime.strptime(
|
|
|
tmdb_details['release_date'], '%Y-%m-%d'
|
|
|
).year
|
|
|
except (ValueError, KeyError):
|
|
|
logging.warning(
|
|
|
"No release date for '{!r}'".format(movie)
|
|
|
)
|
|
|
pass
|
|
|
else:
|
|
|
logging.warning(
|
|
|
"'{!r}' not found on TMDB!".format(movie)
|
|
|
)
|
|
|
|
|
|
def _findMovieOnTMDB(self, movie):
|
|
|
logging.info("Searching for '{}' on TMDB".format(movie))
|
|
|
search = tmdbsimple.Search()
|
|
|
search.movie(query=movie, language=self.config['tmdb-language'])
|
|
|
if len(search.results):
|
|
|
logging.info("Found '{}'".format(
|
|
|
search.results[0]['title']
|
|
|
))
|
|
|
return search.results[0]
|
|
|
else:
|
|
|
logging.info("'{}' not found!".format(movie))
|
|
|
return []
|
|
|
|
|
|
def excludeBadRatings(self):
|
|
|
logging.info('Dropping movies with bad ratings: {}'.format(
|
|
|
[m for m in self.movies if not m.good]
|
|
|
))
|
|
|
self.movies = [m for m in self.movies if m.good]
|
|
|
logging.debug('Kept {}'.format(self.movies))
|
|
|
|
|
|
def excludeUnavailableChannels(self):
|
|
|
logging.info('Dropping movies on unavailable channels: {}'.format(
|
|
|
[m for m in self.movies if m.channel not in self.channels]
|
|
|
))
|
|
|
self.movies = [m for m in self.movies if m.channel in self.channels]
|
|
|
logging.debug('Kept {}'.format(self.movies))
|
|
|
|
|
|
def excludeTelevisionMovie(self):
|
|
|
logging.info('Dropping television movies')
|
|
|
self.movies = [
|
|
|
m for m in self.movies if not m.genre.startswith("Téléfilm")
|
|
|
]
|
|
|
|
|
|
def excludeLocalMovies(self, directory):
|
|
|
(_, _, filenames) = next(os.walk(directory))
|
|
|
clean = lambda t: re.sub(r"( :|\?)", "", t)
|
|
|
logging.warning('Dropping movies already recorded: {}'.format(
|
|
|
[m for m in self.movies if clean(m.title)+'.m2ts' in filenames]
|
|
|
))
|
|
|
self.movies = [
|
|
|
m for m in self.movies if clean(m.title)+'.m2ts' not in filenames
|
|
|
]
|
|
|
|
|
|
def excludeNotSelected(self):
|
|
|
self.movies = [m for m in self.movies if m.user_selected]
|
|
|
|
|
|
def programMovies(self):
|
|
|
for movie in self.movies:
|
|
|
logging.debug("Programming '{!r}'".format(movie))
|
|
|
data = {
|
|
|
'channel_uuid': self.channels[movie.channel],
|
|
|
'start': int(movie.start_time.timestamp()),
|
|
|
'end': int(movie.end_time.timestamp()),
|
|
|
'name': movie.title,
|
|
|
'margin_before': 60*self.config['margin-before'],
|
|
|
'margin_after': 60*self.config['margin-after']
|
|
|
}
|
|
|
self.freebox.Pvr.Create_a_precord(data)
|
|
|
print("Programmed '{!r}'".format(movie))
|
|
|
|
|
|
def checkForConflicts(self):
|
|
|
programmed_movies = self.freebox.Pvr.Getting_the_list_of_precords()
|
|
|
if programmed_movies:
|
|
|
conflicting_movies = [m for m in programmed_movies if m['conflict']]
|
|
|
if conflicting_movies:
|
|
|
print(
|
|
|
"\n"
|
|
|
"!!!!!!!!!\n"
|
|
|
"!Warning!\n"
|
|
|
"!!!!!!!!!\n"
|
|
|
"Conflicting records detected, please "
|
|
|
"check your Freebox interface\n"
|
|
|
"http://192.168.1.254/#Fbx.os.app.pvr.app"
|
|
|
)
|
|
|
logging.info("Conflicting records detected '{}'".format(
|
|
|
conflicting_movies
|
|
|
))
|
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
logging.basicConfig(
|
|
|
level=logging.WARNING,
|
|
|
format=' %(asctime)s - %(levelname)s - %(message)s'
|
|
|
)
|
|
|
parser = argparse.ArgumentParser(
|
|
|
description='Schedule movie recordings on your Freebox'
|
|
|
)
|
|
|
parser.add_argument(
|
|
|
'-d', '--day',
|
|
|
action='store_true',
|
|
|
help='Search movies for current day only instead of a full week'
|
|
|
)
|
|
|
parser.add_argument(
|
|
|
'-l', '--log',
|
|
|
action='store_true',
|
|
|
help='Display more log messages'
|
|
|
)
|
|
|
parser.add_argument(
|
|
|
'-e', '--exclude',
|
|
|
action='append',
|
|
|
default=[],
|
|
|
help='Exclude the following Channel'
|
|
|
)
|
|
|
parser.add_argument(
|
|
|
'-x', '--exclude-directory',
|
|
|
action='append',
|
|
|
default=[],
|
|
|
help='''Do not display movies available in the following directory.
|
|
|
This will prevent you from recording the same movie multiple
|
|
|
times.'''
|
|
|
)
|
|
|
args = parser.parse_args()
|
|
|
|
|
|
print("Working the magic, please wait…")
|
|
|
if args.log:
|
|
|
logging.getLogger().setLevel(logging.INFO)
|
|
|
if args.day:
|
|
|
movies = TVGuideScraper._getMovies()
|
|
|
else:
|
|
|
movies = TVGuideScraper.findAllMovies()
|
|
|
|
|
|
fmp = FreeboxMoviePlanner(
|
|
|
movies,
|
|
|
excluded_channels=args.exclude,
|
|
|
excluded_directory=args.exclude_directory
|
|
|
)
|
|
|
|
