X-Git-Url: https://git.distorted.org.uk/~mdw/epls/blobdiff_plain/151b3c4f3f5cb4edcdc95ba144f85b3dbb993ee1..d13ab556b54713aaba1127e443fdb9a466d553f2:/mkm3u diff --git a/mkm3u b/mkm3u index 046373f..74496b2 100755 --- a/mkm3u +++ b/mkm3u @@ -5,6 +5,7 @@ from contextlib import contextmanager import optparse as OP import os as OS import re as RX +import subprocess as SP import sys as SYS class ExpectedError (Exception): pass @@ -36,6 +37,11 @@ def getint(s): if not s.isdigit(): raise ExpectedError("bad integer `%s'" % s) return int(s) +def getbool(s): + if s == "t": return True + elif s == "nil": return False + else: raise ExpectedError("bad boolean `%s'" % s) + class Words (object): def __init__(me, s): me._s = s @@ -59,6 +65,12 @@ class Words (object): if begin < 0: return None else: return s[begin:].rstrip() +def program_output(*args, **kw): + try: return SP.check_output(*args, **kw) + except SP.CalledProcessError as e: + raise ExpectedError("program `%s' failed with code %d" % + (e.cmd, e.returncode)) + URL_SAFE_P = 256*[False] for ch in \ b"ABCDEFGHIJKLMNOPQRSTUVWXYZ" \ @@ -94,32 +106,48 @@ class Source (object): me.used_titles = dict() me.used_chapters = set() me.nuses = 0 - def url(me, title = None, chapter = None): + def _duration(me, title, start_chapter, end_chapter): + return -1 + def url_and_duration(me, title = None, + start_chapter = None, end_chapter = None): if title == "-": if me.TITLEP: raise ExpectedError("missing title number") - if chapter is not None: + if start_chapter is not None or end_chapter is not None: raise ExpectedError("can't specify chapter without title") suffix = "" elif not me.TITLEP: raise ExpectedError("can't specify title with `%s'" % me.fn) - elif chapter is None: + elif start_chapter is None: + if end_chapter is not None: + raise ExpectedError("can't specify end chapter without start chapter") suffix = "#%d" % title elif not me.CHAPTERP: raise ExpectedError("can't specify chapter with `%s'" % me.fn) + elif end_chapter is None: + suffix = "#%d:%d" % (title, start_chapter) else: - suffix = "#%d:%d-%d:%d" % (title, chapter, title, chapter) - if chapter is not None: key, set = (title, chapter), me.used_chapters - else: key, set = title, me.used_titles - if key in set: - if title == "-": - raise ExpectedError("`%s' already used" % me.fn) - elif chapter is None: - raise ExpectedError("`%s' title %d already used" % (me.fn, title)) - else: - raise ExpectedError("`%s' title %d chapter %d already used" % - (me.fn, title, chapter)) - if chapter is not None: me.used_chapters.add((title, chapter)) - return me.PREFIX + ROOT + urlencode(me.fn) + suffix + suffix = "#%d:%d-%d:%d" % (title, start_chapter, title, end_chapter - 1) + + duration = me._duration(title, start_chapter, end_chapter) + + if end_chapter is not None: + keys = [(title, ch) for ch in range(start_chapter, end_chapter)] + set = me.used_chapters + else: + keys, set = [title], me.used_titles + for k in keys: + if k in set: + if title == "-": + raise ExpectedError("`%s' already used" % me.fn) + elif end_chapter is None: + raise ExpectedError("`%s' title %d already used" % (me.fn, title)) + else: + raise ExpectedError("`%s' title %d chapter %d already used" % + (me.fn, title, k[1])) + if end_chapter is not None: + for ch in range(start_chapter, end_chapter): + me.used_chapters.add((title, ch)) + return me.PREFIX + ROOT + urlencode(me.fn) + suffix, duration class VideoDisc (Source): PREFIX = "dvd://" @@ -129,6 +157,26 @@ class VideoDisc (Source): super().__init__(fn, *args, **kw) me.neps = 0 + def _duration(me, title, start_chapter, end_chapter): + path = OS.path.join(ROOT, me.fn) + ntitle = int(program_output(["dvd-info", path, "titles"])) + if not 1 <= title <= ntitle: + raise ExpectedError("bad title %d for `%s': must be in 1 .. %d" % + (title, me.fn, ntitle)) + if start_chapter is None: + durq = "duration:%d" % title + else: + nch = int(program_output(["dvd-info", path, "chapters:%d" % title])) + if end_chapter is None: end_chapter = nch + else: end_chapter -= 1 + if not 1 <= start_chapter <= end_chapter <= nch: + raise ExpectedError("bad chapter range %d .. %d for `%s' title %d: " + "must be in 1 .. %d" % + (start_chapter, end_chapter, me.fn, title, nch)) + durq = "duration:%d.%d-%d" % (title, start_chapter, end_chapter) + duration = int(program_output(["dvd-info", path, durq])) + return duration + class VideoSeason (object): def __init__(me, i, title): me.i = i @@ -139,27 +187,28 @@ class VideoSeason (object): raise ExpectedError("season %d episode %d already taken" % (me.i, i)) me.episodes[i] = disc; disc.neps += 1 -def some_group(m, *gg): - for g in gg: - s = m.group(g) +def match_group(m, *groups, dflt = None, mustp = False): + for g in groups: + try: s = m.group(g) + except IndexError: continue if s is not None: return s - return None + if mustp: raise ValueError("no match found") + else: return dflt class VideoDir (object): - _R_ISO_PRE = RX.compile(r""" ^ - (?: S (?P \d+) - (?: \. \ (?P .*) — (?: D \d+ \. \ )? | - D \d+ \. \ | - (?= E \d+ \. \ ) | - \. \ ) | - \d+ \. \ ) - (?: (?P - (?: S \d+ \ )? E \d+ (?: – \d+)? - (?: , \ (?: S \d+ \ )? E \d+ (?: – \d+)?)*) | - (?P E \d+) \. \ .*) - \. iso $ - """, RX.X) + _R_ISO_PRE = list(map(lambda pats: + list(map(lambda pat: + RX.compile("^" + pat + r"\.iso$", RX.X), + pats)), + [[r""" S (?P \d+) \. \ (?P .*) — (?: D \d+ \. \ )? + (?P .*) """, + r""" S (?P \d+) (?: D \d+)? \. \ (?P .*) """, + r""" S (?P \d+) \. \ (?P E \d+ .*) """, + r""" S (?P \d+) (?P E \d+) \. \ .* """], + [r""" (?P \d+) [A-Z]? \. \ (?P .*) — (?P .*) """], + [r""" \d+ \. \ (?P [ES] \d+ .*) """], + [r""" (?P \d+ ) \. \ .* """]])) _R_ISO_EP = RX.compile(r""" ^ (?: S (?P \d+) \ )? @@ -172,25 +221,34 @@ class VideoDir (object): fns.sort() season = None seasons = {} + styles = me._R_ISO_PRE for fn in fns: path = OS.path.join(dir, fn) if not fn.endswith(".iso"): continue - m = me._R_ISO_PRE.match(fn) - if not m: - #print(";; `%s' ignored" % path, file = SYS.stderr) + #print(";; `%s'" % path, file = SYS.stderr) + for sty in styles: + for r in sty: + m = r.match(fn) + if m: styles = [sty]; break + else: + continue + break + else: + #print(";;\tignored (regex mismatch)", file = SYS.stderr) continue - i = filter(m.group("si"), int) - stitle = m.group("st") - check(i is not None or stitle is None, + si = filter(match_group(m, "si"), int) + stitle = match_group(m, "stitle") + + check(si is not None or stitle is None, "explicit season title without number in `%s'" % fn) - if i is not None: - if season is None or i != season.i: - check(season is None or i == season.i + 1, + if si is not None: + if season is None or si != season.i: + check(season is None or si == season.i + 1, "season %d /= %d" % - (i, season is None and -1 or season.i + 1)) - check(i not in seasons, "season %d already seen" % i) - seasons[i] = season = VideoSeason(i, stitle) + (si, season is None and -1 or season.i + 1)) + check(si not in seasons, "season %d already seen" % si) + seasons[si] = season = VideoSeason(si, stitle) else: check(stitle == season.title, "season title `%s' /= `%s'" % (stitle, season.title)) @@ -198,15 +256,15 @@ class VideoDir (object): disc = VideoDisc(path) ts = season any, bad = False, False - epname = m.group("epname") - if epname is not None: eplist = [epname] - else: eplist = m.group("eplist").split(", ") + epnum = match_group(m, "epnum") + if epnum is not None: eplist = ["E" + epnum] + else: eplist = match_group(m, "epex", mustp = True).split(", ") for eprange in eplist: mm = me._R_ISO_EP.match(eprange) - if mm is None: bad = True; continue - if not any: - #print(";; `%s'" % path, file = SYS.stderr) - any = True + if mm is None: + #print(";;\t`%s'?" % eprange, file = SYS.stderr) + bad = True; continue + if not any: any = True i = filter(mm.group("si"), int) if i is not None: try: ts = seasons[i] @@ -218,17 +276,25 @@ class VideoDir (object): for k in range(start, end + 1): ts.set_episode_disc(k, disc) #print(";;\tepisode %d.%d" % (ts.i, k), file = SYS.stderr) - if not any: pass #print(";; `%s' ignored" % path, file = SYS.stderr) - elif bad: raise ExpectedError("bad ep list in `%s'", fn) + if not any: + #print(";;\tignored", file = SYS.stderr) + pass + elif bad: + raise ExpectedError("bad ep list in `%s'", fn) me.seasons = seasons class AudioDisc (Source): PREFIX = "file://" TITLEP = CHAPTERP = False -class AudioEpisode (Source): - PREFIX = "file://" - TITLEP = CHAPTERP = False + def _duration(me, title, start_chapter, end_chaptwr): + out = program_output(["metaflac", + "--show-total-samples", "--show-sample-rate", + OS.path.join(ROOT, me.fn)]) + nsamples, hz = map(float, out.split()) + return int(nsamples/hz) + +class AudioEpisode (AudioDisc): def __init__(me, fn, i, *args, **kw): super().__init__(fn, *args, **kw) me.i = i @@ -262,15 +328,18 @@ class AudioDir (object): class Chapter (object): def __init__(me, episode, title, i): me.title, me.i = title, i - me.url = episode.source.url(episode.tno, i) + me.url, me.duration = \ + episode.source.url_and_duration(episode.tno, i, i + 1) class Episode (object): - def __init__(me, season, i, neps, title, src, tno = None): + def __init__(me, season, i, neps, title, src, series_title_p = True, + tno = None, startch = None, endch = None): me.season = season me.i, me.neps, me.title = i, neps, title me.chapters = [] me.source, me.tno = src, tno - me.url = src.url(tno) + me.series_title_p = series_title_p + me.url, me.duration = src.url_and_duration(tno, startch, endch) def add_chapter(me, title, j): ch = Chapter(me, title, j) me.chapters.append(ch) @@ -284,49 +353,76 @@ class BaseSeason (object): me.episodes = [] me.implicitp = implicitp me.ep_i, episodes = 1, [] - def add_episode(me, j, neps, title, src, tno): - ep = Episode(me, j, neps, title, src, tno) + def add_episode(me, j, neps, title, src, series_title_p, + tno, startch, endch): + ep = Episode(me, j, neps, title, src, series_title_p, + tno, startch, endch) me.episodes.append(ep) src.nuses += neps; me.ep_i += neps return ep + def _epnames(me, i, neps): + playlist = me.series.playlist + if neps == 1: return playlist.epname, ["%d" % i] + elif neps == 2: return playlist.epnames, ["%d" % i, "%d" % (i + 1)] + else: return playlist.epnames, ["%d–%d" % (i, i + neps - 1)] class Season (BaseSeason): def __init__(me, series, title, i, *args, **kw): super().__init__(series, *args, **kw) me.title, me.i = title, i def _eplabel(me, i, neps, title): - playlist = me.series.playlist - if neps == 1: epname = playlist.epname; epn = "%d" % i - elif neps == 2: epname = playlist.epnames; epn = "%d, %d" % (i, i + 1) - else: epname = playlist.epnames; epn = "%d–%d" % (i, i + neps - 1) + epname, epn = me._epnames(i, neps) if title is None: - if me.implicitp: label = "%s %s" % (epname, epn) - elif me.title is None: label = "%s %d.%s" % (epname, me.i, epn) - else: label = "%s—%s %s" % (me.title, epname, epn) + if me.implicitp: + label = "%s %s" % (epname, ", ".join(epn)) + elif me.title is None: + label = "%s %s" % \ + (epname, ", ".join("%d.%s" % (me.i, e) for e in epn)) + else: + label = "%s—%s %s" % (me.title, epname, ", ".join(epn)) else: - if me.implicitp: label = "%s. %s" % (epn, title) - elif me.title is None: label = "%d.%s. %s" % (me.i, epn, title) - else: label = "%s—%s. %s" % (me.title, epn, title) + if me.implicitp: + label = "%s. %s" % (", ".join(epn), title) + elif me.title is None: + label = "%s. %s" % \ + (", ".join("%d.%s" % (me.i, e) for e in epn), title) + else: + label = "%s—%s. %s" % (me.title, ", ".join(epn), title) return label class MovieSeason (BaseSeason): - def add_episode(me, j, neps, title, src, tno): - if title is None: raise ExpectedError("movie must have a title") - return super().add_episode(j, neps, title, src, tno) - def _eplabel(me, i, epn, title): - return title + def __init__(me, series, title, *args, **kw): + super().__init__(series, *args, **kw) + me.title = title + me.i = None + def add_episode(me, j, neps, title, src, series_title_p, + tno, startch, endch): + if me.title is None and title is None: + raise ExpectedError("movie or movie season must have a title") + return super().add_episode(j, neps, title, src, series_title_p, + tno, startch, endch) + def _eplabel(me, i, neps, title): + if me.title is None: + label = title + elif title is None: + epname, epn = me._epnames(i, neps) + label = "%s—%s %s" % (me.title, epname, ", ".join(epn)) + else: + label = "%s—%s" % (me.title, title) + return label class Series (object): - def __init__(me, playlist, title = None): + def __init__(me, playlist, name, title = None, wantedp = True): me.playlist = playlist - me.title = title + me.name, me.title = name, title me.cur_season = None + me.wantedp = wantedp def _add_season(me, season): me.cur_season = season def add_season(me, title, i, implicitp = False): me._add_season(Season(me, title, i, implicitp)) - def add_movies(me): - me._add_season(MovieSeason(me)) + def add_movies(me, title = None): + me._add_season(MovieSeason(me, title)) def ensure_season(me): if me.cur_season is None: me.add_season(None, 1, implicitp = True) return me.cur_season @@ -351,13 +447,40 @@ class Playlist (object): f.write("\n") for ep in season: label = ep.label() - if me.nseries > 1: label = ep.season.series.title + " " + label + if me.nseries > 1 and ep.series_title_p and \ + ep.season.series.title is not None: + if ep.season.i is None: sep = "—" + else: sep = " " + label = ep.season.series.title + sep + label if not ep.chapters: - f.write("#EXTINF:0,,%s\n%s\n" % (label, ep.url)) + f.write("#EXTINF:%d,,%s\n%s\n" % (ep.duration, label, ep.url)) else: for ch in ep.chapters: - f.write("#EXTINF:0,,%s: %s\n%s\n" % - (label, ch.title, ch.url)) + f.write("#EXTINF:%d,,%s: %s\n%s\n" % + (ch.duration, label, ch.title, ch.url)) + +DEFAULT_EXPVAR = 0.05 +R_DURMULT = RX.compile(r""" ^ + (\d+ (?: \. \d+)?) x +$ """, RX.X) +R_DUR = RX.compile(r""" ^ + (?: (?: (\d+) :)? (\d+) :)? (\d+) + (?: / (\d+ (?: \. \d+)?) \%)? +$ """, RX.X) +def parse_duration(s, base = None, basevar = DEFAULT_EXPVAR): + if base is not None: + m = R_DURMULT.match(s) + if m is not None: return base*float(m.group(1)), basevar + m = R_DUR.match(s) + if not m: raise ExpectedError("invalid duration spec `%s'" % s) + hr, min, sec = map(lambda g: filter(m.group(g), int, 0), [1, 2, 3]) + var = filter(m.group(4), lambda x: float(x)/100.0) + if var is None: var = DEFAULT_EXPVAR + return 3600*hr + 60*min + sec, var +def format_duration(d): + if d >= 3600: return "%d:%02d:%02d" % (d//3600, (d//60)%60, d%60) + elif d >= 60: return "%d:%02d" % (d//60, d%60) + else: return "%d s" % d MODE_UNSET = 0 MODE_SINGLE = 1 @@ -371,6 +494,7 @@ class EpisodeListParser (object): me._series = {}; me._vdirs = {}; me._audirs = {}; me._isos = {} me._series_wanted = series_wanted me._chaptersp = chapters_wanted_p + me._explen, me._expvar = None, DEFAULT_EXPVAR if series_wanted is None: me._mode = MODE_UNSET else: me._mode = MODE_MULTI @@ -396,7 +520,7 @@ class EpisodeListParser (object): me._set_mode(MODE_SINGLE) try: series = me._series[None] except KeyError: - series = me._series[None] = Series(me._pl) + series = me._series[None] = Series(me._pl, None) me._pl.nseries += 1 else: me._set_mode(MODE_MULTI) @@ -408,10 +532,19 @@ class EpisodeListParser (object): for k, v in me._keyvals(opts): if k is None: name = v else: me._bad_keyval(cmd, k, v) - return me._get_series(name), name + return me._get_series(name) - def _wantedp(me, name): - return me._series_wanted is None or name in me._series_wanted + def _auto_epsrc(me, series): + dir = lookup(me._vdirs, series.name, "no active video directory") + season = series.ensure_season() + check(season.i is not None, "must use explicit iso for movie seasons") + vseason = lookup(dir.seasons, season.i, + "season %d not found in video dir `%s'" % + (season.i, dir.dir)) + src = lookup(vseason.episodes, season.ep_i, + "episode %d.%d not found in video dir `%s'" % + (season.i, season.ep_i, dir.dir)) + return src def _process_cmd(me, ww): @@ -427,64 +560,80 @@ class EpisodeListParser (object): else: me._bad_keyval(cmd, k, v) check(name is not None, "missing series name") check(name not in me._series, "series `%s' already defined" % name) - title = ww.rest(); check(title is not None, "missing title") + title = ww.rest() me._set_mode(MODE_MULTI) - me._series[name] = Series(me._pl, title) - if me._wantedp(name): me._pl.nseries += 1 + me._series[name] = series = Series(me._pl, name, title, + me._series_wanted is None or + name in me._series_wanted) + if series.wantedp: me._pl.nseries += 1 elif cmd == "season": - series, sname = me._opts_series(cmd, opts) + series = me._opts_series(cmd, opts) w = ww.nextword(); check(w is not None, "missing season number") if w == "-": - check(ww.rest() is None, "trailing junk") - if not me._wantedp(sname): return - series.add_movies() + if not series.wantedp: return + series.add_movies(ww.rest()) else: title = ww.rest(); i = getint(w) - if not me._wantedp(sname): return + if not series.wantedp: return series.add_season(ww.rest(), getint(w), implicitp = False) me._cur_episode = me._cur_chapter = None me._pl.done_season() + elif cmd == "explen": + w = ww.rest(); check(w is not None, "missing duration spec") + if w == "-": + me._explen, me._expvar = None, DEFAULT_EXPVAR + else: + d, v = parse_duration(w) + me._explen = d + if v is not None: me._expvar = v + elif cmd == "epname": for k, v in me._keyvals(opts): me._bad_keyval("epname", k, v) name = ww.rest(); check(name is not None, "missing episode name") - try: sep = name.index(",") + try: sep = name.index("::") except ValueError: names = name + "s" else: name, names = name[:sep], name[sep + 1:] me._pl.epname, me._pl.epnames = name, names elif cmd == "epno": - series, sname = me._opts_series(cmd, opts) + series = me._opts_series(cmd, opts) w = ww.rest(); check(w is not None, "missing episode number") epi = getint(w) - if not me._wantedp(sname): return + if not series.wantedp: return series.ensure_season().ep_i = epi elif cmd == "iso": - _, name = me._opts_series(cmd, opts) + series = me._opts_series(cmd, opts) fn = ww.rest(); check(fn is not None, "missing filename") - if not me._wantedp(name): return - if fn == "-": forget(me._isos, name) + if not series.wantedp: return + if fn == "-": forget(me._isos, series.name) else: check(OS.path.exists(OS.path.join(ROOT, fn)), "iso file `%s' not found" % fn) - me._isos[name] = VideoDisc(fn) + me._isos[series.name] = VideoDisc(fn) elif cmd == "vdir": - _, name = me._opts_series(cmd, opts) + series = me._opts_series(cmd, opts) dir = ww.rest(); check(dir is not None, "missing directory") - if not me._wantedp(name): return - if dir == "-": forget(me._vdirs, name) - else: me._vdirs[name] = VideoDir(dir) + if not series.wantedp: return + if dir == "-": forget(me._vdirs, series.name) + else: me._vdirs[series.name] = VideoDir(dir) elif cmd == "adir": - _, name = me._opts_series(cmd, opts) + series = me._opts_series(cmd, opts) dir = ww.rest(); check(dir is not None, "missing directory") - if not me._wantedp(name): return - if dir == "-": forget(me._audirs, name) - else: me._audirs[name] = AudioDir(dir) + if not series.wantedp: return + if dir == "-": forget(me._audirs, series.name) + else: me._audirs[series.name] = AudioDir(dir) + + elif cmd == "displaced": + series = me._opts_series(cmd, opts) + w = ww.rest(); check(w is not None, "missing count"); n = getint(w) + src = me._auto_epsrc(series) + src.nuses += n else: raise ExpectedError("unknown command `%s'" % cmd) @@ -492,7 +641,9 @@ class EpisodeListParser (object): def _process_episode(me, ww): opts = ww.nextword(); check(opts is not None, "missing title/options") - ti = None; sname = None; neps = 1; epi = None + ti = None; sname = None; neps = 1; epi = None; loch = hich = None + explen, expvar, explicitlen = me._explen, me._expvar, False + series_title_p = True for k, v in me._keyvals(opts): if k is None: if v.isdigit(): ti = int(v) @@ -501,36 +652,50 @@ class EpisodeListParser (object): elif k == "s": sname = v elif k == "n": neps = getint(v) elif k == "ep": epi = getint(v) + elif k == "st": series_title_p = getbool(v) + elif k == "l": + if v == "-": me._explen, me._expvar = None, DEFAULT_EXPVAR + else: + explen, expvar = parse_duration(v, explen, expvar) + explicitlen = True + elif k == "ch": + try: sep = v.index("-") + except ValueError: loch, hich = getint(v), None + else: loch, hich = getint(v[:sep]), getint(v[sep + 1:]) + 1 else: raise ExpectedError("unknown episode option `%s'" % k) check(ti is not None, "missing title number") series = me._get_series(sname) me._cur_chapter = None title = ww.rest() - if not me._wantedp(sname): return + if not series.wantedp: return season = series.ensure_season() if epi is None: epi = season.ep_i if ti == "-": check(season.implicitp, "audio source, but explicit season") - if not me._wantedp(sname): return - dir = lookup(me._audirs, sname, "no title, and no audio directory") + dir = lookup(me._audirs, series.name, + "no title, and no audio directory") src = lookup(dir.episodes, season.ep_i, "episode %d not found in audio dir `%s'" % (epi, dir.dir)) else: - try: src = me._isos[sname] - except KeyError: - dir = lookup(me._vdirs, sname, - "title, but no iso or video directory") - vseason = lookup(dir.seasons, season.i, - "season %d not found in video dir `%s'" % - (season.i, dir.dir)) - src = lookup(vseason.episodes, season.ep_i, - "episode %d.%d not found in video dir `%s'" % - (season.i, season.ep_i, dir.dir)) - - episode = season.add_episode(epi, neps, title, src, ti) + try: src = me._isos[series.name] + except KeyError: src = me._auto_epsrc(series) + + episode = season.add_episode(epi, neps, title, src, + series_title_p, ti, loch, hich) + + if episode.duration != -1 and explen is not None: + if not explicitlen: explen *= neps + if not explen*(1 - expvar) <= episode.duration <= explen*(1 + expvar): + if season.i is None: epid = "episode %d" % epi + else: epid = "episode %d.%d" % (season.i, epi) + raise ExpectedError \ + ("%s duration %s %g%% > %g%% from expected %s" % + (epid, format_duration(episode.duration), + abs(100*(episode.duration - explen)/explen), 100*expvar, + format_duration(explen))) me._pl.add_episode(episode) me._cur_episode = episode @@ -559,7 +724,7 @@ class EpisodeListParser (object): def done(me): discs = set() for name, vdir in me._vdirs.items(): - if not me._wantedp(name): continue + if not me._series[name].wantedp: continue for s in vdir.seasons.values(): for d in s.episodes.values(): discs.add(d)