episoder 0.11.0__py3-none-any.whl

episoder/sources/epguides.py

@@ -0,0 +1,174 @@
+# 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 datetime import datetime, date
+from logging import getLogger
+from re import search
+from typing import Optional
+
+from bs4 import BeautifulSoup, element
+from requests import Response, Session
+
+from episoder.database import Episode, Show
+from episoder.episoder import Database
+from .parser import Parser
+
+
+class Epguides(Parser):
+    """Parser for episodes from epguides.com"""
+
+    def __init__(self, session: Session) -> None:
+        self._logger = getLogger('Epguides')
+        self._session = session
+
+    def __str__(self) -> str:
+        return 'epguides.com parser'
+
+    def __repr__(self) -> str:
+        return 'Epguides()'
+
+    def accept(self, url: str) -> bool:
+        return 'epguides.com/' in url
+
+    def _guess_encoding(self, response: Response) -> str:
+        raw = response.raw.read()
+        text = raw.decode('iso-8859-1')
+
+        if 'charset=iso-8859-1' in text:
+            return 'iso-8859-1'
+
+        return 'utf8'
+
+    def parse(self, show: Show, db: Database) -> None:
+        response = self._session.get(show.url, timeout=10)
+        response.encoding = self._guess_encoding(response)
+
+        for line in response.text.split('\n'):
+            self._parse_line(line, show, db)
+
+        show.updated = datetime.now()
+        db.commit()
+
+    def _html_episode_title(self, soup: BeautifulSoup) -> str:
+        cell = soup.find('td', class_='eptitle')
+        if isinstance(cell, element.Tag):
+            link = cell.find('a')
+            if isinstance(link, element.Tag):
+                return link.text.strip()
+        return ''
+
+    def _update_show_title(self, show: Show, line: str) -> None:
+        # Name of the show
+        res = search(r'<title>(.*)</title>', line)
+        if res:
+            title = res.groups()[0]
+            show.name = title.split(' (a ')[0]
+
+    def _update_show_status(self, show: Show, line: str) -> None:
+        # Current status (running / ended)
+        res = search(r'<span class="status">(.*)</span>', line)
+        if res:
+            text = res.groups()[0]
+            if 'current' in text:
+                show.status = Show.RUNNING
+            else:
+                show.status = Show.ENDED
+        elif search(r'aired.*to.*[\d+]', line):
+            show.status = Show.ENDED
+
+        # Current status in new HTML version
+        res = search(r'Status: (.*)<br', line)
+        if res:
+            text = res.groups()[0]
+            if 'ended' in text:
+                show.status = Show.ENDED
+            else:
+                show.status = Show.RUNNING
+
+    def _get_date(self, val: str) -> date:
+        day = val.replace('/', ' ')
+        then = datetime.strptime(day, '%d %b %y')
+        return then.date()
+
+    def _load_html_episode(self, line: str) -> Optional[Episode]:
+        soup = BeautifulSoup(line, 'html.parser')
+        cells = soup.find_all('td', class_='epinfo')
+
+        # We expect 3 cells, otherwise we refuse to go on
+        if len(cells) < 3:
+            return None
+
+        # total episode number
+        total_episodes = cells[0].text.split('.', 1)[0]
+        try:
+            total = int(total_episodes)
+        except ValueError:
+            # Some shows have specials (numbered separately)
+            total = -1
+
+        # season and episode number
+        details = cells[1].text.split('-')
+        if len(details) < 2:
+            return None
+
+        [season, epnum] = details
+
+        # episode title
+        title = self._html_episode_title(soup)
+
+        # original air date
+        day = cells[2].text
+        if not day:
+            # Drop episodes without date
+            return None
+
+        then = self._get_date(day)
+
+        # prodnum is None, we don't have those
+        return Episode(title, season, epnum, then, None, total)
+
+    def _load_text_episode(self, line: str) -> Optional[Episode]:
+        # Known formatting supported by this fine regex:
+        # 4.     1-4        19 Jun 02  <a [..]>title</a>
+        #   1.  19- 1   01-01    5 Jan 88  <a [..]>title</a>
+        # 23     3-05       27/Mar/98  <a [..]>title</a>
+        # 65.   17-10       23 Apr 05  <a [..]>title</a>
+        # 101.   5-15       09 May 09  <a [..]>title</a>
+        # 254.    - 5  05-254   15 Jan 92  <a [..]>title</a>
+        res = search(r'^ *(\d+)\.? +(\d*)- ?(\d+) +([a-zA-Z0-9-]*)'
+                     r' +(\d{1,2}[ /][A-Z][a-z]{2}[ /]\d{2}) *<a.*>(.*)</a>',
+                     line)
+
+        if not res:
+            return None
+
+        (total, season, epnum, prodnum, day, title) = res.groups()
+        then = self._get_date(day)
+        return Episode(title, season or 0, epnum, then, prodnum, total)
+
+    def _parse_line(self, line: str, show: Show, db: Database) -> None:
+        self._update_show_title(show, line)
+        self._update_show_status(show, line)
+
+        if search(r'<td class=.epinfo', line):
+            episode = self._load_html_episode(line)
+        else:
+            episode = self._load_text_episode(line)
+
+        if episode:
+            self._logger.debug('Found episode %s', episode.title)
+            db.add_episode(episode, show)

episoder/sources/parser.py

@@ -0,0 +1,30 @@
+# 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 abc import ABC, abstractmethod
+
+from episoder.episoder import Database, Show
+
+
+class Parser(ABC):
+    @abstractmethod
+    def accept(self, url: str) -> bool:
+        """Test if this parser can load the given URL"""
+
+    @abstractmethod
+    def parse(self, show: Show, db: Database) -> None:
+        """Load episodes with this parser"""

episoder/sources/thetvdb.py

@@ -0,0 +1,231 @@
+# 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 abc import ABC, abstractmethod
+from json import dumps
+from logging import getLogger
+from datetime import datetime, date
+from typing import Dict, List, Tuple
+
+from requests import Session
+
+from episoder.database import Episode, Show
+from episoder.episoder import Database
+from .parser import Parser
+
+
+class TVDBState(ABC):
+    @abstractmethod
+    def login(self, key: str) -> None:
+        """Authenticate to the backend"""
+
+    @abstractmethod
+    def lookup(self, text: str) -> List[Show]:
+        """Find show(s) by name"""
+
+    @abstractmethod
+    def parse(self, show: Show, db: Database) -> None:
+        """Load episodes with this parser"""
+
+
+class InvalidLoginError(Exception):
+    pass
+
+
+class TVDBShowNotFoundError(Exception):
+    pass
+
+
+class TVDBNotLoggedInError(Exception):
+    pass
+
+
+class TVDB(Parser):
+    """Parser for episodes from thetvdb.com"""
+
+    def __init__(self, session: Session, api_key: str) -> None:
+        self._session = session
+        self._api_key = api_key
+        self._state: TVDBState = TVDBOffline(self, session)
+
+    def __str__(self) -> str:
+        return str(self._state)
+
+    def __repr__(self) -> str:
+        return f'TVDB {repr(self._state)}'
+
+    def lookup(self, text: str) -> List[Show]:
+        self._state.login(self._api_key)
+        return self._state.lookup(text)
+
+    def parse(self, show: Show, db: Database) -> None:
+        self._state.login(self._api_key)
+        self._state.parse(show, db)
+
+    def change(self, state: TVDBState) -> None:
+        self._state = state
+
+    def accept(self, url: str) -> bool:
+        return url.isdigit()
+
+
+class TVDBOffline(TVDBState):
+    def __init__(self, tvdb: TVDB, session: Session) -> None:
+        self._tvdb = tvdb
+        self._log = getLogger('TVDB (offline)')
+        self._session = session
+
+    def __str__(self) -> str:
+        return 'thetvdb.com parser (ready)'
+
+    def __repr__(self) -> str:
+        return '<TVDBOffline>'
+
+    def _post_login(self, data: Dict[str, str]) -> str:
+        url = 'https://api.thetvdb.com/login'
+        head = {'Content-type': 'application/json'}
+        body = dumps(data).encode('utf8')
+        response = self._session.post(url, body, headers=head, timeout=10)
+        data = response.json()
+
+        if response.status_code == 401:
+            raise InvalidLoginError(data.get('Error'))
+
+        self._log.info('Successful login')
+        return data['token']
+
+    def lookup(self, _: str) -> List[Show]:
+        raise TVDBNotLoggedInError()
+
+    def login(self, key: str) -> None:
+        body = {'apikey': key}
+        token = self._post_login(body)
+        self._tvdb.change(TVDBOnline(token, self._session))
+
+    def parse(self, _: Show, __: Database) -> None:
+        raise TVDBNotLoggedInError()
+
+
+class TVDBOnline(TVDBState):
+    def __init__(self, token: str, session: Session) -> None:
+        self._token = token
+        self._log = getLogger('TVDB (online)')
+        self._session = session
+
+    def __str__(self) -> str:
+        return 'thetvdb.com parser (authorized)'
+
+    def __repr__(self) -> str:
+        return '<TVDBOnline>'
+
+    def _get(self, url: str, params: Dict) -> Dict:
+        url = f'https://api.thetvdb.com/{url}'
+        head = {'Content-type': 'application/json',
+                'Authorization': f'Bearer {self._token}'}
+
+        response = self._session.get(url, headers=head, params=params,
+                                     timeout=10)
+        data = response.json()
+
+        if response.status_code == 404:
+            raise TVDBShowNotFoundError(data.get('Error'))
+
+        return data
+
+    def _get_episodes(self, show: Show,
+                      page: int) -> Tuple[List[Episode], Dict]:
+        show_id = int(show.url)
+        opts = {'page': page}
+        result = self._get(f'series/{show_id}/episodes', opts)
+        return (result.get('data') or [], result.get('links', {}))
+
+    def lookup(self, text: str) -> List[Show]:
+        def mkshow(entry: Dict) -> Show:
+            name = entry.get('seriesName')
+            url = str(entry.get('id')).encode('utf8').decode('utf8')
+            return Show(name, url=url)
+
+        matches = self._get('search/series', {'name': text})
+        return list(map(mkshow, matches.get('data', {})))
+
+    def login(self, _: str) -> None:
+        pass
+
+    def _fetch_episodes(self, show: Show, page: int) -> List[Episode]:
+        def airdate(row: Dict) -> date:
+            aired = row.get('firstAired', '1970-01-01')
+
+            if aired == '0000-00-00':
+                return datetime(1970, 1, 1)
+
+            return datetime.strptime(aired, '%Y-%m-%d').date()
+
+        def mkepisode(row: Dict) -> Episode:
+            num = int(row.get("airedEpisodeNumber", "0") or 0)
+            name = row.get('episodeName') or 'Unnamed episode'
+            season = int(row.get('airedSeason', '0') or 0)
+            aired = airdate(row)
+            pnum = 'UNK'
+
+            self._log.debug('Found episode %s', name)
+            return Episode(name, season, num, aired, pnum, 0)
+
+        def is_valid(row: Dict) -> bool:
+            return row.get("firstAired") not in [None, ""]
+
+        (data, links) = self._get_episodes(show, page)
+        valid = filter(is_valid, data)
+        episodes = [mkepisode(row) for row in valid]
+
+        # handle pagination
+        next_ = links.get("next") or 0
+        if next_ > page:
+            try:
+                more = self._fetch_episodes(show, next_)
+                episodes.extend(more)
+            except TVDBShowNotFoundError:
+                msg = "Error parsing %s: failed to load page %d"
+                self._log.error(msg, show.name, next_)
+
+        return episodes
+
+    def parse(self, show: Show, db: Database) -> None:
+        result = self._get(f'series/{int(show.url)}', {})
+        data = result.get('data', {})
+
+        # update show data
+        show.name = data.get('seriesName', show.name)
+        show.updated = datetime.now()
+
+        self._log.debug("Updating show '%s'", show.name)
+
+        if data.get('status') == 'Continuing':
+            show.status = Show.RUNNING
+        else:
+            show.status = Show.ENDED
+
+        # load episodes
+        try:
+            episodes = self._fetch_episodes(show, 1)
+        except TVDBShowNotFoundError:
+            return
+
+        for (idx, episode) in enumerate(sorted(episodes)):
+            episode.totalnum = idx + 1
+            db.add_episode(episode, show)
+
+        db.commit()

episoder/sources/tvcom.py

@@ -0,0 +1,43 @@
+# 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 re import match
+
+from episoder.database import Show
+from episoder.episoder import Database
+from .parser import Parser
+
+
+class TVCom(Parser):
+    """Parser for episodes from tv.com"""
+
+    def __init__(self) -> None:
+        self._log = logging.getLogger('TVCom')
+
+    def __str__(self) -> str:
+        return 'dummy tv.com parser to detect old urls'
+
+    def __repr__(self) -> str:
+        return 'TVCom()'
+
+    def accept(self, url: str) -> bool:
+        exp = 'http://(www.)?tv.com/.*'
+        return match(exp, url) is not None
+
+    def parse(self, show: Show, _: Database) -> None:
+        self._log.error("The url %s is no longer supported", show.url)

episoder/version.py

@@ -0,0 +1,18 @@
+# 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/>.
+
+__version__ = "0.11.0"