def filter_by_metadata(self, series=None, season=None, episode=None):
filters = List(
Maybe(series) / (lambda a: Release.name == a),
Maybe(season) / str / (lambda a: Release.season == a),
Maybe(episode) / str / (lambda a: Release.episode == a),
)
return self.filter_release(*filters.join)
def add_season(self, id, num):
def handle_show(show):
season = List.wrap(self.tvdb.season(show.etvdb_id, num))
if season:
now = datetime.now().strftime('%F')
aired = (season.filter(_['date'] < now).map(_['episode']).max)
aired % L(self._releases.add_season)(
show.canonical_name, num, _, search_name=show.search_name)
return 'Done'
else:
return 'No such season: {} s{}'.format(show, num)
return (Maybe(self._shows.find_by_id(id)) / handle_show
| self._no_show(id))
def m(self, params, skip=1):
return Maybe(self(params, skip))
def _current(self):
return Maybe(Job(self._candidates))
def find(self, fa: List[A], f: Callable[[A], bool]):
return Maybe(_find(fa, f))
def format_cause(exc: Exception, **kw) -> List[str]:
from amino import Maybe
return Maybe(exc.__cause__) / (lambda a: format_exception(a, **kw)) / (lambda a: a.cons('Cause:')) | List()
def latest_episode_m(self):
return Maybe(self.latest_episode)
def search(self, data: str, *a: Any, **kw: Any) -> Either[str, 'Match']:
return (Maybe(self.rex.search(data, *a, **kw)).to_either(
'`{}` does not contain `{}`'.format(data, self.spec)) /
L(Match)(self, _, data))
def http_link_by_id(self, id):
return Maybe(self._db.query(Link).filter_by(id=id).first())
def torrent_by_id(self, id):
return Maybe(self._db.query(Torrent).filter_by(id=id).first())
def latest_for_season(self, name, season):
q = (self._db.query(func.max(Release.episode)).filter_by(
name=name, season=season).join(ReleaseMonitor))
return Maybe(*q.first())
def match(self, data: str, *a: Any, **kw: Any) -> Maybe['Match']:
return (Maybe(self.rex.match(data, *a, **kw)).to_either(
'`{}` does not match `{}`'.format(data, self.spec)) /
L(Match)(self, _, data))
def find_by_metadata(self, **data):
return Maybe(self.filter_by(**data).first())
def find_by_name(self, name):
return Maybe(self.filter_by(canonical_name=name).first())
def format_exception(exc: Exception) -> List[str]:
tb = sanitize_tb(Lists.wrap(format_tb(exc.__traceback__)))
main = tb.cat(f'{exc.__class__.__name__}: {exc}')
cause = Maybe(exc.__cause__) / format_exception / (
lambda a: a.cons('Cause:')) | List()
return main + cause
