def _cycle(self, episode, comp, sorter):
season = episode.season
candidate = find(lambda e: comp(e, episode), sorter(season.episodes))
if candidate is None:
series = episode.series
next_season = find(lambda s: comp(s, season),
sorter(series.seasons))
if next_season is not None and next_season.episodes.count() > 0:
candidate = sorter(next_season.episodes)[0]
return candidate
def is_not_positional(name, value):
''' Check if either the config defines this value as
positional or the caller requested the parameter of that
name as positional
'''
return (not (isinstance(value, ConfigOption) and value.positional)
and (positional is None or not find(lambda p: p[0] == name,
positional)))
def get_episode(search_name,
season,
number,
release=None,
canonical_name=None):
from tek.tools import find
canon = canonical_name or search_name
info = SubtitleQueryData(search_name, canon, season, number, release)
parser = HTMLParser(info)
subs = parser.subtitles()
if not subs:
raise NoSubsForEpisode(search_name, season, number)
same_release = lambda sub: sub.release == release
if release is not None:
matching = list(filter(same_release, subs))
if matching:
subs = matching
not_deaf = lambda sub: not sub.hearing_impaired
return find(not_deaf, subs) or subs[0]
def archive(self, path):
extension = path.rsplit('.')[-1]
_type = self._archive_type(path)
if self._use_mime:
self._use_mime = _type in self.extractors
Extractor = self.extractors.get(_type, None)
if not self._use_mime and self._use_extension:
Extractor = find(lambda e: extension in e().extensions,
list(self.extractors.values()))
if not Extractor:
raise MimeTypeError(_type, extension)
extractor = Extractor()
if isinstance(extractor, RarExtractor):
is_multi, archive, parts = self._check_multipart(path)
if is_multi:
archive = MultipartRarArchive(archive, parts, extractor)
else:
archive = RarArchive(path, extractor)
else:
archive = Archive(path, extractor)
extractor.pipe = self._pipe
return archive
def release(self):
return find(lambda r: r.hd_series, self.releases)
def _find_nuke(self, entry):
return find(lambda m: m.release.is_same_episode(entry.release),
self._releases.all)
def _find_release(self, entry):
return find(lambda m: m.release == entry.release, self._releases.all)
def transfer_for_torrent(self, torrent):
return find(lambda t: t.get('source') == torrent, self.transfers, {})