finnix-make-bt-rss.py

#!/usr/bin/env python3

import datetime
from pathlib import Path
import re
import sys
import types
import xml.etree.ElementTree as ET

from natsort import natsorted


def texte(parent, tag, text=None, attrib={}, **extra):
    element = ET.SubElement(parent, tag, attrib=attrib, **extra)
    if text:
        element.text = text
    return element


def xml_indent(elem, level=0):
    i = "\n" + level * "  "
    if len(elem):
        if not elem.text or not elem.text.strip():
            elem.text = i + "  "
        if not elem.tail or not elem.tail.strip():
            elem.tail = i
        for elem in elem:
            xml_indent(elem, level + 1)
        if not elem.tail or not elem.tail.strip():
            elem.tail = i
    else:
        if level and (not elem.tail or not elem.tail.strip()):
            elem.tail = i


class BTRSS:
    releases_dir = "/srv/www/www.finnix.org/htdocs/releases"
    releases_url_base = "https://www.finnix.org/releases"
    rss_dir = "/srv/www/www.finnix.org/htdocs/rss/bittorrent"

    r_ver = re.compile(r"^[0-9][0-9\.]+$")
    r_iso = re.compile(
        r"^finnix(-(?P<arch>ppc|armhf))?-(?P<version>[0-9][0-9\.]+)\.iso"
    )

    def __init__(self):
        self.versions = []
        self.releases = []

    def torrent_to_title(self, torrent):
        m = self.r_iso.search(torrent.name)
        if m:
            md = m.groupdict()
            if md["arch"] == "armhf":
                return "Finnix-ARM {}".format(md["version"])
            elif md["arch"] == "ppc":
                return "Finnix-PPC {}".format(md["version"])
            else:
                return "Finnix {}".format(md["version"])
        return "Finnix"

    def gather_releases(self):
        p = Path(self.releases_dir)
        for release_dir in p.iterdir():
            if not (release_dir.is_dir() and self.r_ver.search(release_dir.name)):
                continue
            for torrent in release_dir.glob("*.torrent"):
                m = self.r_iso.search(torrent.name)
                if m:
                    md = m.groupdict()
                    self.releases.append(
                        types.SimpleNamespace(
                            file=torrent,
                            stat=torrent.stat(),
                            arch=md.get("arch", "x86"),
                            version=md["version"],
                        )
                    )
                    continue
        self.versions = natsorted(set([x.version for x in self.releases]))

    def make_rss(self, filename, title, description, criteria):
        now = datetime.datetime.utcnow()

        e_rss = ET.Element(
            "rss",
            attrib={"version": "2.0", "xmlns:atom": "http://www.w3.org/2005/Atom"},
        )
        e_channel = ET.SubElement(e_rss, "channel")
        texte(e_channel, "title", title)
        texte(
            e_channel,
            "atom:link",
            href="https://www.finnix.org/rss/bittorrent/{}".format(filename),
            rel="self",
            type="application/rss+xml",
        )
        texte(e_channel, "ttl", "1440")
        texte(e_channel, "link", "https://www.finnix.org/")
        texte(e_channel, "description", description)
        texte(e_channel, "pubDate", now.strftime("%a, %d %b %Y %H:%M:%S +0000"))

        for item in natsorted(
            [x for x in self.releases if criteria(x)],
            key=lambda x: x.version,
            reverse=True,
        ):
            torrent = item.file
            item_title = self.torrent_to_title(torrent)
            e_item = ET.SubElement(e_channel, "item")
            texte(e_item, "title", item_title)
            texte(
                e_item,
                "guid",
                "{}/{}/{}".format(self.releases_url_base, item.version, torrent.name),
                isPermaLink="true",
            )
            texte(
                e_item,
                "link",
                "{}/{}/{}".format(self.releases_url_base, item.version, torrent.name),
            )
            texte(
                e_item,
                "pubDate",
                datetime.datetime.utcfromtimestamp(item.stat.st_mtime).strftime(
                    "%a, %d %b %Y %H:%M:%S +0000"
                ),
            )
            texte(e_item, "description", item_title)
            texte(
                e_item,
                "enclosure",
                url="{}/{}/{}".format(
                    self.releases_url_base, item.version, torrent.name
                ),
                length=str(item.stat.st_size),
                type="application/x-bittorrent",
            )

        et = ET.ElementTree(e_rss)
        xml_indent(e_rss)
        et.write(
            "{}/{}".format(self.rss_dir, filename),
            xml_declaration=True,
            encoding="UTF-8",
        )

    def main(self):
        self.gather_releases()

        self.make_rss(
            "all-releases.rss",
            "Finnix Torrents - All Releases",
            "All releases of Finnix",
            lambda x: True,
        )
        self.make_rss(
            "seeder.rss",
            "Finnix Torrents - Seeder",
            "Last two releases of Finnix",
            lambda x: x.version in ("109", self.versions[-1], self.versions[-2]),
        )
        self.make_rss(
            "current-release.rss",
            "Finnix Torrents - Current Release",
            "The latest release of Finnix",
            lambda x: x.version == self.versions[-1],
        )
        self.make_rss(
            "current-release-x86.rss",
            "Finnix Torrents - Current Release (x86/AMD64)",
            "The latest release of Finnix (x86/AMD64 only)",
            lambda x: x.version == self.versions[-1] and x.arch == "x86",
        )
        self.make_rss(
            "current-release-ppc.rss",
            "Finnix Torrents - Current Release (PowerPC)",
            "The latest release of Finnix (PowerPC only)",
            lambda x: x.version == "109" and x.arch == "ppc",
        )


if __name__ == "__main__":
    cls = BTRSS()
    sys.exit(cls.main())