episoder 0.11.0__py3-none-any.whl

episoder/main.py

@@ -0,0 +1,469 @@
+#!/usr/bin/env python
+
+# episoder, https://code.ott.net/episoder
+#
+# Copyright (C) 2004-2024 Stefan Ott. All rights reserved.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import logging
+
+from argparse import ArgumentParser
+from datetime import date, timedelta
+from os import environ, path
+from re import match
+from sys import stderr
+from traceback import print_exc
+
+from episoder.database import Show
+from episoder.episoder import Database
+from episoder.sources import parser_for, setup_sources
+from episoder.sources.thetvdb import TVDBShowNotFoundError
+from episoder.output import ConsoleRenderer, EmailNotifier
+from episoder.output import NewEpisodesNotification
+from episoder.version import __version__
+
+
+class EpisoderOptions:
+
+    def __init__(self):
+
+        self._parser = ArgumentParser()
+        self._add_options()
+        self._args = None
+        self._log = logging.getLogger("EpisoderOptions")
+        self.loglevel = logging.WARNING
+
+    def _add_options(self):
+
+        yesterday = date.today() - timedelta(1)
+
+        self._parser.set_defaults(func=None)
+        commands = self._parser.add_subparsers(help="commands")
+
+        # options for adding shows
+        parser = commands.add_parser("add", help="Add a show")
+        parser.add_argument("show", action="store",
+                            help="show to add (TVDB ID or epguides.com URL)")
+        parser.set_defaults(func="add")
+
+        # options for removing shows
+        parser = commands.add_parser("remove",
+                                     help="Remove a show from the database")
+        parser.add_argument("show", action="store", type=int,
+                            help="the show ID to remove")
+        parser.set_defaults(func="remove")
+
+        # options for enabling shows
+        parser = commands.add_parser("enable",
+                                     help="Enable updates for a show")
+        parser.add_argument("show", action="store", type=int,
+                            help="the show ID to enable updates for")
+        parser.set_defaults(func="enable")
+
+        # options for disabling shows
+        parser = commands.add_parser("disable",
+                                     help="Disable updates for a show")
+        parser.add_argument("show", action="store", type=int,
+                            help="the show ID to disable updates for")
+        parser.set_defaults(func="disable")
+
+        # options for showing episodes
+        parser = commands.add_parser("list",
+                                     help="Show upcoming episodes")
+        parser.add_argument("-C", "--nocolor", action="store_true",
+                            help="do not use colors")
+        parser.add_argument("-d", metavar="YYYY-MM-DD|n", dest="date",
+                            default=yesterday.strftime("%Y-%m-%d"),
+                            help="only show episodes after this date "
+                            "/ n days back")
+        parser.add_argument("-n", "--days", type=int, default=2,
+                            help="number of future days to show (default: 2)")
+        parser.add_argument("-i", "--nodate", action="store_true",
+                            help="ignore date, show all episodes")
+        parser.add_argument("-s", dest="search",
+                            help="search episodes")
+        parser.set_defaults(func="episodes")
+
+        # options for searching shows
+        parser = commands.add_parser("search",
+                                     help="Find shows on TVDB")
+        parser.add_argument("keyword", action="store",
+                            help="search string")
+        parser.set_defaults(func="search")
+
+        # options for listing shows
+        parser = commands.add_parser("shows",
+                                     help="List shows in the database")
+        parser.add_argument("-a", "--active", action="store_true",
+                            help="only lists shows that are running/suspended")
+        parser.set_defaults(func="shows")
+
+        # options for database update
+        parser = commands.add_parser("update",
+                                     help="Update the database")
+        parser.add_argument("-d", metavar="YYYY-MM-DD|n", dest="date",
+                            default=yesterday.strftime("%Y-%m-%d"),
+                            help="remove episodes prior to this date "
+                            "or n days back")
+        parser.add_argument("-f", "--force", action="store_true",
+                            help="force update, disregard last update time")
+        parser.add_argument("-i", "--nodate", action="store_true",
+                            help="ignore date, do not remove old episodes")
+        parser.add_argument("-s", "--show", metavar="id", type=int,
+                            help="only update the show with this id")
+        parser.add_argument("-n", "--num", metavar="num", type=int,
+                            help="update no more than num shows at a time")
+        parser.set_defaults(func="update")
+
+        # options for email notify
+        parser = commands.add_parser("notify",
+                                     help="Send e-mail notifications "
+                                     "about new episodes")
+        parser.add_argument("-d", metavar="YYYY-MM-DD|n", dest="date",
+                            default=yesterday.strftime("%Y-%m-%d"),
+                            help="only show episodes prior to this date "
+                            "or n days back")
+        parser.add_argument("-n", "--days", type=int, default=2,
+                            help="number of future days to show (default: 2)")
+        parser.add_argument("-s", "--show", metavar="id", type=int,
+                            help="only notify for the show with this id")
+        parser.add_argument("--dryrun", action="store_true",
+                            default=False, help="pretend, do not send email")
+        parser.set_defaults(func="notify")
+
+        # global options
+        group = self._parser.add_mutually_exclusive_group()
+
+        self._parser.add_argument("-c", metavar="file", action="store",
+                                  default=path.join(environ["HOME"],
+                                                    ".episoder"),
+                                  help="use configuration from file")
+        group.add_argument("-v", "--verbose", action="store_true",
+                           help="verbose operation")
+        group.add_argument("-d", "--debug", action="store_true",
+                           help="debug (very verbose) operation")
+        self._parser.add_argument("-l", metavar="file", dest="logfile",
+                                  action="store",
+                                  help="log to file instead of stdout")
+        self._parser.add_argument("-V", "--version", action="version",
+                                  version=f"episoder {__version__}",
+                                  help="show version information")
+
+    def _replace_parsed_date(self, args):
+
+        if args.date.isdigit():
+            daysback = int(args.date)
+            args.date = date.today() - timedelta(daysback)
+        elif match("^[0-9]{4}(-[0-9]{2}){2}$", args.date):
+            (year, month, day) = args.date.split("-")
+            args.date = date(int(year), int(month), int(day))
+        else:
+            self._parser.error(f"{args.date}: Wrong date format")
+
+    def _setup_logging(self):
+
+        if self._args.debug:
+            self.loglevel = logging.DEBUG
+        elif self._args.verbose:
+            self.loglevel = logging.INFO
+
+        level = self.loglevel
+        logfile = self._args.logfile
+
+        if logfile:
+            logging.basicConfig(level=level, filename=logfile)
+        else:
+            logging.basicConfig(level=level)
+
+    def parse_args(self):
+
+        self._args = self._parser.parse_args()
+
+        # this happens automatically in python 2 but not in 3.4
+        if self._args.func is None:
+            self._parser.print_usage()
+            stderr.write("error: too few arguments\n")
+            exit(1)
+
+        # turn our date string into a proper date object
+        if hasattr(self._args, "date"):
+            self._replace_parsed_date(self._args)
+
+        self._setup_logging()
+
+    def load_rcfile(self, file_):
+
+        def strip_comments(line):
+
+            return line.split("#")[0]
+
+        def valid(line):
+
+            return "=" in line
+
+        self._log.info("Loading config file")
+        lines = file_.readlines()
+        lines = [x.decode("utf8").strip() for x in lines]
+        lines = map(strip_comments, lines)
+        lines = filter(valid, lines)
+        return dict(line.split("=") for line in lines)
+
+    def load_config(self):
+
+        if path.exists(self.args.c):
+            with open(self.args.c, "rb") as file_:
+                cfg = self.load_rcfile(file_)
+                self._log.debug("Settings loaded: %s", cfg)
+        else:
+            stderr.write("No config file found, using defaults\n")
+            cfg = {}
+
+        if "src" in cfg:
+            stderr.write("Please remove src= lines from config\n")
+
+        self._args.agent = cfg.get("agent", "episoder/" + __version__)
+
+        datafile = path.join(environ["HOME"], ".episodes")
+        self._args.datafile = cfg.get("data", datafile)
+        self._args.dateformat = cfg.get("dateformat", "%a, %b %d, %Y")
+        format_ = "%airdate %show %seasonx%epnum"
+        self._args.format = cfg.get("format", format_)
+        self._args.tvdb_key = cfg.get("tvdb_key", "8F15287C4B23B36E")
+        self._args.email_to = cfg.get("email_to")
+        self._args.email_username = cfg.get("email_username")
+        self._args.email_password = cfg.get("email_password")
+        self._args.email_server = cfg.get("email_server", "localhost")
+        self._args.email_port = int(cfg.get("email_port", 587))
+        self._args.email_tls = bool(cfg.get("email_tls", 0))
+
+        self._log.info("Loaded configuration")
+
+    def _get_args(self):
+
+        return self._args
+
+    args = property(_get_args)
+
+
+class Episoder:
+
+    def __init__(self, args):
+
+        self._args = args
+        self._log = logging.getLogger("Episoder")
+
+    def update(self):
+
+        database = Database(self._args.datafile)
+        database.migrate()
+
+        if self._args.show:
+            show = database.get_show_by_id(self._args.show)
+
+            if not show:
+                self._log.error("Show not found")
+                return
+
+            shows = [show]
+        elif self._args.force:
+            shows = database.get_enabled_shows()
+        else:
+            shows = database.get_expired_shows()
+
+        for show in shows[0:self._args.num]:
+
+            try:
+                parser = parser_for(show.url)
+                parser.parse(show, database)
+            except:
+                self._log.error("Error parsing %s", show)
+                print_exc()
+                database.rollback()
+
+            if not self._args.nodate:
+                basedate = self._args.date
+                show.remove_episodes_before(database, basedate)
+
+        if not shows:
+            self._log.info("None of your shows need to be updated")
+
+    def add(self):
+
+        url = self._args.show
+
+        database = Database(self._args.datafile)
+        database.migrate()
+
+        show = database.get_show_by_url(url)
+
+        if show:
+            stderr.write("A show with that url already exists\n")
+            return
+
+        if not parser_for(url):
+            stderr.write(f"Invalid show url/id: {url}\n")
+            return
+
+        show = Show("Unknown Show", url=url)
+
+        database.add_show(show)
+        database.commit()
+
+    def remove(self):
+
+        database = Database(self._args.datafile)
+        database.migrate()
+        database.remove_show(self._args.show)
+        database.commit()
+
+    def _set_show_enabled(self, database, enabled):
+
+        show_id = self._args.show
+        show = database.get_show_by_id(show_id)
+
+        if not show:
+            stderr.write(f"There is no show with id={show_id}\n")
+            return
+
+        show.enabled = enabled
+        database.commit()
+
+    def enable(self):
+
+        database = Database(self._args.datafile)
+        database.migrate()
+        self._set_show_enabled(database, True)
+
+    def disable(self):
+
+        database = Database(self._args.datafile)
+        database.migrate()
+        self._set_show_enabled(database, False)
+
+    def shows(self):
+
+        database = Database(self._args.datafile)
+        database.migrate()
+
+        status_strings = ["?Invalid", "Running", "Suspended", "Ended"]
+        enabled_strings = ["Disabled", "Enabled"]
+
+        for show in database.get_shows():
+
+            if self._args.active and show.status == Show.ENDED:
+                continue
+
+            status = status_strings[show.status or 0]
+            enabled = enabled_strings[show.enabled]
+
+            print(f"[{show.id:4d}] {show.url}")
+            print(f"       {show.name}, {status}, {enabled}")
+            print(f"       Last update: {show.updated}")
+            print(f"       Episodes: {len(show.episodes)}")
+
+    def notify(self):
+
+        opt = self._args
+
+        if opt.email_to is None:
+            stderr.write("No e-mail address configured\n")
+            return
+
+        database = Database(opt.datafile)
+        database.migrate()
+
+        startdate = opt.date
+        n_days = opt.days
+
+        all_episodes = database.get_episodes(startdate, n_days)
+        fresh = [e for e in all_episodes if not e.notified]
+
+        if len(fresh) < 1:
+            self._log.info("No new episodes")
+            return
+
+        msg = NewEpisodesNotification(fresh, opt.format, opt.dateformat)
+        notifier = EmailNotifier(opt.email_server, opt.email_port)
+
+        if opt.email_username:
+            notifier.login(opt.email_username, opt.email_password)
+        if opt.email_tls:
+            notifier.use_tls = True
+
+        msg.send(notifier, opt.email_to)
+        database.commit()
+
+    def episodes(self):
+
+        database = Database(self._args.datafile)
+        out = ConsoleRenderer(self._args.format, self._args.dateformat)
+
+        if self._args.nodate:
+            startdate = date(1900, 1, 1)
+            n_days = 109500  # should be fine until late 21xx :)
+        else:
+            startdate = self._args.date
+            n_days = self._args.days
+
+        if self._args.search:
+            episodes = database.search(self._args.search)
+        else:
+            episodes = database.get_episodes(startdate, n_days)
+
+        out.render(episodes, self._args.date, not self._args.nocolor)
+
+    def search(self):
+
+        tvdb = parser_for('123')  # numeric IDs are TVDB entries
+
+        try:
+            print("ID\tName\n-------\t--------------------")
+            for show in tvdb.lookup(self._args.keyword):
+                print(f"{show.url}\t{show.name}")
+
+        except TVDBShowNotFoundError:
+            print("Nothing found")
+
+    def check_data_file(self):
+
+        filename = self._args.datafile
+        if not path.exists(filename):
+            return
+
+        with open(filename, "rb") as file:
+            data = file.read(6)
+
+        if data != b"SQLite":
+            message = "%s: Please remove old data file\n"
+            stderr.write(message % filename)
+            exit(4)
+
+
+def main():
+
+    options = EpisoderOptions()
+    options.parse_args()
+    options.load_config()
+
+    setup_sources(options.args.agent, options.args.tvdb_key)
+
+    episoder = Episoder(options.args)
+    episoder.check_data_file()
+    func = getattr(episoder, options.args.func)
+    func()
+
+
+if __name__ == "__main__":
+    main()

episoder/output.py

@@ -0,0 +1,186 @@
+# episoder, https://code.ott.net/episoder
+#
+# Copyright (C) 2004-2024 Stefan Ott. All rights reserved.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from sys import stdout
+from datetime import date, timedelta
+from smtplib import SMTP
+
+
+class FormattingRenderer:
+
+    def __init__(self, fmt, dateformat):
+
+        self._format = fmt
+        self._dateformat = dateformat
+
+    def format(self, episode):
+
+        string = self._format
+
+        airdate = episode.airdate.strftime(self._dateformat)
+        string = string.replace("%airdate", airdate)
+        string = string.replace("%show", str(episode.show.name))
+        string = string.replace("%season", str(episode.season))
+        string = string.replace("%epnum", f"{episode.episode:02d}")
+        string = string.replace("%eptitle", str(episode.title))
+        string = string.replace("%totalep", str(episode.totalnum))
+        string = string.replace("%prodnum", str(episode.prodnum))
+
+        return string
+
+
+class ConsoleRenderer(FormattingRenderer):
+
+    RED = "\033[31;1m"
+    CYAN = "\033[36;1m"
+    GREY = "\033[30;0m"
+    GREEN = "\033[32;1m"
+    YELLOW = "\033[33;1m"
+
+    def __init__(self, fmt, dateformat, dest=stdout):
+
+        super().__init__(fmt, dateformat)
+        self._dest = dest
+
+    def __str__(self):
+
+        return "ConsoleRenderer"
+
+    def __repr__(self):
+
+        return f'ConsoleRenderer("{self._format}", "{self._dateformat}", <..>)'
+
+    def _render_color(self, text, col):
+
+        self._dest.write(f"{col}{text}{ConsoleRenderer.GREY}\n")
+
+    def _render_no_color(self, string, _):
+
+        self._dest.write(f"{string}\n")
+
+    def _render(self, episode, render, color):
+
+        render(self.format(episode), color)
+
+    def render(self, episodes, today, use_colors=True):
+
+        yesterday = today - timedelta(1)
+        tomorrow = today + timedelta(1)
+
+        if use_colors:
+            render = self._render_color
+        else:
+            render = self._render_no_color
+
+        for episode in episodes:
+
+            if episode.airdate == yesterday:
+                color = ConsoleRenderer.RED
+            elif episode.airdate == today:
+                color = ConsoleRenderer.YELLOW
+            elif episode.airdate == tomorrow:
+                color = ConsoleRenderer.GREEN
+            elif episode.airdate > tomorrow:
+                color = ConsoleRenderer.CYAN
+            else:
+                color = ConsoleRenderer.GREY
+
+            self._render(episode, render, color)
+
+
+class NewEpisodesNotification(FormattingRenderer):
+
+    def __init__(self, episodes, fmt, datefmt):
+
+        super().__init__(fmt, datefmt)
+        self._episodes = episodes
+
+    def __str__(self):
+
+        return f"Notification: {len(self._episodes)} new episode(s)"
+
+    def __repr__(self):
+
+        eps = f"<({len(self._episodes)} x Episode)"
+        fmt = 'NewEpisodesNotification(%s, "%s", "%s")'
+        return fmt % (eps, self._format, self._dateformat)
+
+    def get(self):
+
+        return "".join("%s\n" % self.format(e) for e in self._episodes)
+
+    def send(self, notifier, to, pretend=False):
+
+        body = "Your upcoming episodes:\n\n"
+
+        for episode in self._episodes:
+            body += f"{self.format(episode)}\n"
+
+            if not pretend:
+                episode.notified = date.today()
+
+        notifier.send(body, to, pretend)
+
+
+class EmailNotifier:
+
+    def __init__(self, server, port, smtp=SMTP):
+
+        self._server = server
+        self._port = port
+        self._smtp = smtp
+        self._user = None
+        self._password = None
+
+        self.use_tls = False
+
+    def __str__(self):
+
+        return "EmailNotifier"
+
+    def __repr__(self):
+
+        fmt = 'EmailNotifier("%s", %d, %s)'
+        return fmt % (self._server, self._port, str(self._smtp))
+
+    def _get_header(self, to, subject):
+
+        return f"From: {to}\nTo: {to}\nSubject: {subject}"
+
+    def login(self, user, password):
+
+        self._user = user
+        self._password = password
+
+    def send(self, body, to, pretend=False):
+
+        header = self._get_header(to, "Upcoming TV episodes")
+        message = f"{header}\n{body}"
+
+        if pretend:
+            print(message)
+            return
+
+        server = self._smtp(self._server, self._port)
+
+        if self.use_tls:
+            server.starttls()
+        if self._user:
+            server.login(self._user, self._password)
+
+        server.sendmail(to, to, message)
+        server.quit()

episoder/sources/__init__.py

@@ -0,0 +1,47 @@
+# episoder, https://code.ott.net/episoder
+#
+# Copyright (C) 2004-2024 Stefan Ott. All rights reserved.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from typing import Optional, List
+import requests
+
+from .epguides import Epguides
+from .thetvdb import TVDB
+from .tvcom import TVCom
+from .parser import Parser
+
+session = requests.Session()
+
+PARSERS: List[Parser] = []
+
+
+def setup_sources(user_agent: str, tvdb_api_key: str) -> None:
+    session.headers.update({'User-Agent': user_agent})
+
+    while len(PARSERS) > 0:
+        PARSERS.pop()
+
+    PARSERS.append(TVDB(session, tvdb_api_key))
+    PARSERS.append(Epguides(session))
+    PARSERS.append(TVCom())
+
+
+def parser_for(url: str) -> Optional[Parser]:
+    """Find the right parser for the given URL"""
+    for parser in PARSERS:
+        if parser.accept(url):
+            return parser
+    return None