episoder 0.11.1__tar.gz → 0.12.0__tar.gz

{episoder-0.11.1 → episoder-0.12.0}/.gitlab-ci.yml

@@ -1,5 +1,6 @@
 stages:
   - test
+  - lint
   - deploy
 
 .jammy_image: &jammy
@@ -39,6 +40,17 @@ stages:
         coverage_format: cobertura
         path: coverage.xml
 
+.lint_template: &lint
+  stage: lint
+  script:
+    - pylint --disable=missing-function-docstring
+          --disable=missing-class-docstring
+          --disable=missing-module-docstring
+          --disable=unknown-option-value
+          episoder/ test/ setup.py
+
+    - flake8 episoder/ test/ setup.py
+
 .deploy_setuptools_template: &deploy_setuptools
   stage: deploy
   script:
@@ -74,10 +86,12 @@ py310-jammy:test:
   <<: *test
 
 py310-jammy-setuptools:deploy:
+  needs: ["py310-jammy:test"]
   <<: *jammy
   <<: *deploy_setuptools
 
 py310-jammy-pip:deploy:
+  needs: ["py310-jammy:test"]
   <<: *jammy
   <<: *deploy_pip
 
@@ -85,13 +99,17 @@ py311-bookworm:test:
   <<: *bookworm
   <<: *test
 
+py311-bookworm:lint:
+  <<: *bookworm
+  <<: *lint
+
 py311-bookworm-setuptools:deploy:
-  needs: ["py311-bookworm:test"]
+  needs: ["py311-bookworm:lint"]
   <<: *bookworm
   <<: *deploy_setuptools
 
 py311-bookworm-pip:deploy:
-  needs: ["py311-bookworm:test"]
+  needs: ["py311-bookworm:lint"]
   <<: *bookworm
   <<: *deploy_pip_venv
 
@@ -99,13 +117,17 @@ py312-noble:test:
   <<: *noble
   <<: *test
 
+py312-noble:lint:
+  <<: *noble
+  <<: *lint
+
 py312-noble-setuptools:deploy:
-  needs: ["py312-noble:test"]
+  needs: ["py312-noble:lint"]
   <<: *noble
   <<: *deploy_setuptools
 
 py312-noble-pip:deploy:
-  needs: ["py312-noble:test"]
+  needs: ["py312-noble:lint"]
   <<: *noble
   <<: *deploy_pip_venv
 
@@ -113,12 +135,16 @@ py313-trixie:test:
   <<: *trixie
   <<: *test
 
+py313-trixie:lint:
+  <<: *trixie
+  <<: *lint
+
 py313-trixie-setuptools:deploy:
-  needs: ["py313-trixie:test"]
+  needs: ["py313-trixie:lint"]
   <<: *trixie
   <<: *deploy_setuptools
 
 py313-trixie-pip:deploy:
-  needs: ["py313-trixie:test"]
+  needs: ["py313-trixie:lint"]
   <<: *trixie
   <<: *deploy_pip_venv

{episoder-0.11.1 → episoder-0.12.0}/CHANGELOG

@@ -1,3 +1,9 @@
+== 0.12.0 (17 Apr 2025) ==
+ * Add feature to test email configuration
+ * Fix typo in main script
+ * Fix dry-run mode for email notifications
+ * Drop --show parameter to notify command
+
 == 0.11.1 (8 Apr 2025) ==
  * Use Python's EmailMessage class when sending e-mail
 

{episoder-0.11.1 → episoder-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: episoder
-Version: 0.11.1
+Version: 0.12.0
 Summary: TV episode notifier
 Home-page: https://code.ott.net/episoder/
 Author: Stefan Ott
@@ -21,6 +21,9 @@ Requires-Dist: argparse
 Requires-Dist: requests
 Requires-Dist: beautifulsoup4
 Requires-Dist: sqlalchemy>=1.3
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pyfakefs; extra == "test"
 
 # episoder
 

episoder-0.12.0/episoder/config.py

@@ -0,0 +1,102 @@
+# episoder, https://code.ott.net/episoder
+#
+# Copyright (C) 2004-2025 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 logging import getLogger
+from os import environ, path
+
+from typing import BinaryIO, Optional
+
+from .version import __version__
+
+
+class InvalidDataFormatError(Exception):
+    def __init__(self, filename: str) -> None:
+        super().__init__(f'Please remove old/invalid data file: {filename}')
+
+
+class EpisoderConfig:
+    # pylint: disable=too-few-public-methods,too-many-instance-attributes
+    def __init__(self) -> None:
+        self.agent = f'episoder/{__version__}'
+        self.datafile = path.join(environ['HOME'], '.episodes')
+        self.dateformat = '%a, %b %d, %Y'
+        self.format = '%airdate %show %seasonx%epnum'
+        self.tvdb_key = '8F15287C4B23B36E'
+
+        self.email_to: Optional[str] = None
+        self.email_username: Optional[str] = None
+        self.email_password: Optional[str] = None
+        self.email_server = 'localhost'
+        self.email_port = 587
+        self.email_tls = False
+
+
+class ConfigLoader:
+    def __init__(self) -> None:
+        self._log = getLogger('Config')
+
+    def _load_rcfile(self, file_: BinaryIO) -> dict[str, str]:
+        def strip_comments(line: str) -> str:
+            return line.split('#')[0]
+
+        def valid(line: str) -> bool:
+            return '=' in line
+
+        self._log.info('Loading config file')
+        lines = file_.readlines()
+        decoded_lines = [x.decode('utf8').strip() for x in lines]
+        non_comments = map(strip_comments, decoded_lines)
+        valid_lines = filter(valid, non_comments)
+        return dict(line.split('=') for line in valid_lines)
+
+    def _update(self, cfg: EpisoderConfig, values: dict[str, str]) -> None:
+        cfg.agent = values.get('agent', cfg.agent)
+        cfg.datafile = values.get('data', cfg.datafile)
+        cfg.dateformat = values.get('dateformat', cfg.dateformat)
+        cfg.format = values.get('format', cfg.format)
+        cfg.tvdb_key = values.get('tvdb_key', cfg.tvdb_key)
+
+        cfg.email_to = values.get('email_to', cfg.email_to)
+        cfg.email_username = values.get('email_username', cfg.email_username)
+        cfg.email_password = values.get('email_password', cfg.email_password)
+        cfg.email_port = int(values.get('email_port', cfg.email_port))
+        cfg.email_server = values.get('email_server', cfg.email_server)
+        cfg.email_tls = bool(values.get('email_tls', cfg.email_tls))
+
+    def load(self, file: str) -> EpisoderConfig:
+        config = EpisoderConfig()
+
+        if path.exists(file):
+            with open(file, 'rb') as file_:
+                values = self._load_rcfile(file_)
+
+            self._log.debug('Settings loaded: %s', values)
+            self._update(config, values)
+            self._log.info("Loaded configuration")
+        else:
+            self._log.warning('No config file found, using defaults')
+
+        return config
+
+    def validate(self, config: EpisoderConfig) -> None:
+        filename = config.datafile
+        if path.exists(filename):
+            with open(filename, 'rb') as file:
+                data = file.read(6)
+
+            if data != b'SQLite':
+                raise InvalidDataFormatError(filename)

{episoder-0.11.1 → episoder-0.12.0}/episoder/database.py

@@ -15,8 +15,6 @@
 # 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 datetime import datetime
 
 from sqlalchemy import Column, Integer, Text, Date, ForeignKey, Sequence
@@ -63,12 +61,8 @@ class Show(Base):
 
         return self.name == other.name and self.url == other.url
 
-    def remove_episodes_before(self, store, date):
-
-        logging.debug("Removing episodes from before %s", date)
-        store.remove_before(date, show=self)
-
 
+# pylint: disable=too-many-instance-attributes
 class Episode(Base):
 
     __tablename__ = "episodes"
@@ -106,11 +100,11 @@ class Episode(Base):
 
     def __repr__(self):
 
-        d = self.airdate
+        airdate = self.airdate
 
         return f'Episode("{self.title}", {self.season}, {self.episode}, ' \
-               f'date({d.year}, {d.month}, {d.day}), "{self.prodnum}", ' \
-               f'{self.totalnum})'
+               f'date({airdate.year}, {airdate.month}, {airdate.day}), ' \
+               f'"{self.prodnum}", {self.totalnum})'
 
     def __eq__(self, other):
 

{episoder-0.11.1 → episoder-0.12.0}/episoder/episoder.py

@@ -17,6 +17,7 @@
 
 import logging
 from datetime import date, timedelta
+from typing import Optional
 
 import sqlite3
 from sqlalchemy import create_engine, or_, and_, select, inspect
@@ -26,25 +27,20 @@ from .database import Episode, Show, Meta
 
 
 class Database:
-
-    def __init__(self, path):
-
+    def __init__(self, path: str) -> None:
         self._path = path
-        self.logger = logging.getLogger("Database")
+        self.logger = logging.getLogger('Database')
 
         self.open()
         self._initdb()
 
-    def __str__(self):
-
-        return f"Episoder Database at {self._path}"
-
-    def __repr__(self):
-
-        return f"Database({self._path})"
+    def __str__(self) -> str:
+        return f'Episoder Database at {self._path}'
 
-    def _initdb(self):
+    def __repr__(self) -> str:
+        return f'Database({self._path})'
 
+    def _initdb(self) -> None:
         inspector = inspect(self.engine)
 
         # Initialize the database if all tables are missing
@@ -57,34 +53,30 @@ class Database:
             Meta.__table__.create(bind=self.engine)
             self.set_schema_version(4)
 
-    def open(self):
-
-        if self._path.find("://") > -1:
+    def open(self) -> None:
+        if self._path.find('://') > -1:
             self.engine = create_engine(self._path)
         else:
-            self.engine = create_engine(f"sqlite:///{self._path}")
+            self.engine = create_engine(f'sqlite:///{self._path}')
 
-        sm = sessionmaker(self.engine)
-        self.session = sm()
+        session = sessionmaker(self.engine)
+        self.session = session()
         self.session.begin()
 
-    def close(self):
-
+    def close(self) -> None:
         self.session.commit()
         self.session.close()
         self.engine.dispose()
 
-    def set_schema_version(self, version):
-
+    def set_schema_version(self, version: int) -> None:
         meta = Meta()
-        meta.key = "schema"
-        meta.value = f"{version}"
+        meta.key = 'schema'
+        meta.value = f'{version}'
 
         with self.session.begin_nested():
             self.session.merge(meta)
 
-    def get_schema_version(self):
-
+    def get_schema_version(self) -> int:
         inspector = inspect(self.engine)
         if not inspector.has_table(Meta.__table__.name):
             return 1
@@ -96,8 +88,7 @@ class Database:
 
         return 0
 
-    def clear(self):
-
+    def clear(self) -> None:
         episodes = self.session.query(Episode).all()
 
         for episode in episodes:
@@ -105,18 +96,15 @@ class Database:
 
         self.session.flush()
 
-    def migrate(self):
-
+    def migrate(self) -> None:
         schema_version = self.get_schema_version()
         self.logger.debug("Found schema version %s", schema_version)
 
         if schema_version < 0:
-
             self.logger.debug("Automatic schema updates disabled")
             return
 
         if schema_version == 1:
-
             # Upgrades from version 1 are rather harsh, we
             # simply drop and re-create the tables
             self.logger.debug("Upgrading to schema version 2")
@@ -134,7 +122,6 @@ class Database:
             self.set_schema_version(schema_version)
 
         if schema_version == 2:
-
             # Add two new columns to the shows table
             self.logger.debug("Upgrading to schema version 3")
 
@@ -155,7 +142,6 @@ class Database:
             self.set_schema_version(schema_version)
 
         if schema_version == 3:
-
             # Add a new column to the episodes table
             self.logger.debug("Upgrading to schema version 4")
 
@@ -173,8 +159,7 @@ class Database:
             schema_version = 4
             self.set_schema_version(schema_version)
 
-    def get_expired_shows(self, today=date.today()):
-
+    def get_expired_shows(self, today: date = date.today()) -> list[Show]:
         delta_running = timedelta(2)    # 2 days
         delta_suspended = timedelta(7)    # 1 week
         delta_ended = timedelta(14)    # 2 weeks
@@ -199,13 +184,11 @@ class Database:
 
         return shows.all()
 
-    def get_enabled_shows(self):
-
+    def get_enabled_shows(self) -> list[Show]:
         shows = self.session.query(Show).filter(Show.enabled)
         return shows.all()
 
-    def get_show_by_url(self, url):
-
+    def get_show_by_url(self, url: str) -> Optional[Show]:
         shows = self.session.query(Show).filter(Show.url == url)
 
         if shows.count() < 1:
@@ -213,26 +196,17 @@ class Database:
 
         return shows.first()
 
-    def get_show_by_id(self, show_id):
-
+    def get_show_by_id(self, show_id: int) -> Optional[Show]:
         return self.session.scalars(
                 select(Show).where(Show.id == show_id)).first()
 
-    def add_show(self, show):
-
+    def add_show(self, show: Show) -> Show:
         show = self.session.merge(show)
         self.session.flush()
         return show
 
-    def remove_show(self, show_id):
-
-        show = self.session.scalars(
-                select(Show).where(Show.id == show_id)).first()
-
-        if not show:
-            self.logger.error("No such show")
-            return
-
+    def remove_show(self, show: Show) -> None:
+        assert show is not None
         episodes = self.session.scalars(select(Episode))
 
         hits = [e for e in episodes if e.show_id == show.id]
@@ -242,51 +216,46 @@ class Database:
         self.session.delete(show)
         self.session.flush()
 
-    def get_shows(self):
-
+    def get_shows(self) -> list[Show]:
         return self.session.query(Show).all()
 
-    def add_episode(self, episode, show):
-
+    def add_episode(self, episode: Episode, show: Show) -> None:
         episode.show_id = show.id
         self.session.merge(episode)
         self.session.flush()
 
-    def get_episodes(self, basedate=date.today(), n_days=0):
-
-        enddate = basedate + timedelta(n_days)
+    def get_episodes(self, basedate: date = date.today(),
+                     days: int = 0) -> list[Episode]:
+        enddate = basedate + timedelta(days)
 
         return self.session.query(Episode). \
             filter(Episode.airdate >= basedate). \
             filter(Episode.airdate <= enddate). \
             order_by(Episode.airdate).all()
 
-    def search(self, search):
-
-        q = self.session.query(Episode).join(Episode.show)
-        return q.filter(or_(
-                Episode.title.like(f"%%{search}%%"),
-                Show.name.like(f"%%{search}%%"))). \
+    def search(self, term: str) -> list[Episode]:
+        query = self.session.query(Episode).join(Episode.show)
+        return query.filter(or_(
+                Episode.title.like(f"%%{term}%%"),
+                Show.name.like(f"%%{term}%%"))). \
             order_by(Episode.airdate.asc()).all()
 
-    def commit(self):
-
+    def commit(self) -> None:
         self.session.commit()
         self.session.begin()
 
-    def rollback(self):
-
+    def rollback(self) -> None:
         self.session.rollback()
         self.session.begin()
 
-    def remove_before(self, then, show=None):
-
-        eps = self.session.query(Episode).filter(Episode.airdate < then)
+    def remove_before(self, then: date, show: Optional[Show] = None) -> None:
+        logging.debug("Removing episodes from before %s", then)
+        episodes = self.session.query(Episode).filter(Episode.airdate < then)
 
         if show:
-            eps = eps.filter(Episode.show == show)
+            episodes = episodes.filter(Episode.show == show)
 
-        for episode in eps:
+        for episode in episodes:
             self.session.delete(episode)
 
         self.commit()