def add_multi(self):
key = 'key'
val = 'value'
k2 = 'key2'
v2 = 'value2'
m = Map({key: val})
m2 = m**Map({k2: v2})
m2.get(k2).should.equal(Just(v2))
m.get(k2).should.equal(Empty())
def parse(torr):
td = Map(torr)
name = '{} {}'.format(title_long, td.get('quality') | '')
size = td.get('size_bytes') | 0
size_str = sizeof_fmt(str(size))
seeds = td.get('seeds') | 0
hsh = td.get('hash') | 'no_hash'
magnet_link = yify_magnet(title, hsh)
return SearchResult(name, size, size_str, seeds, magnet_link)
def add(self):
key = 'key'
val = 'value'
k2 = 'key2'
v2 = 'value2'
m = Map({key: val})
m2 = m + (k2, v2)
m2.get(k2).should.equal(Just(v2))
m.get(k2).should.equal(Empty())
def match_title(monitor, title, res):
r = monitor.release
matches = Map(guessit(title))
attr = lambda key, target: matches.get(key).contains(target)
search_name = canonicalize(r.effective_search_name)
name = canonicalize(r.name)
canonical_title = matches.get('title').map(canonicalize)
return ((canonical_title.contains(search_name)
or canonical_title.contains(name))
and (attr('screen_size', res) or
(matches.get('screen_size').empty and res == ''))
and ((attr('season', r.season) and attr('episode', r.episode))
or attr('date', r.airdate.date())))
def from_yify(self, result):
data = Map(result)
title_long = data.get('title_long') | 'no title'
title = data.get('title') | 'no title'
def parse(torr):
td = Map(torr)
name = '{} {}'.format(title_long, td.get('quality') | '')
size = td.get('size_bytes') | 0
size_str = sizeof_fmt(str(size))
seeds = td.get('seeds') | 0
hsh = td.get('hash') | 'no_hash'
magnet_link = yify_magnet(title, hsh)
return SearchResult(name, size, size_str, seeds, magnet_link)
return data.get('torrents') / List.wrap / __.map(parse) | List()
def parse_magnet(magnet) -> Either[str, Magnet]:
pr = urlparse(magnet)
if pr.scheme == 'magnet':
q = Map(parse_qs(pr.query)).valmap(List.wrap)
name = q.get('dn') // _.head
return Right(Magnet(name, q))
else:
return Left('not a magnet')
def _search_yify(self):
query = ' '.join(self.args)
response = requests.get(yify_url,
params=dict(query_term=query,
limit=self._limit))
data = Map(response.json())
results = ((data.get('data') / Map // __.get('movies') / List.wrap /
__.flat_map(SearchResultFactory.from_yify)) | List())
return self._handle_results(query, results)
def input(self):
handlers = Map({
'j': self._down,
'k': self._up,
'%CR%': self._switch,
's': self._switch,
'p': self._pick,
'r': self._revert,
'q': self._close_tab,
})
return handlers.get(self.msg.keyseq).flat_map(lambda f: f())
def add_by_params(self):
options = Map(self.msg.options)
ident = self.msg.ident
return (
(options.get('root') /
mkpath //
F(self.data.loader.from_params, ident, params=options))
.or_else(
self.data.loader.by_ident(ident)
.or_else(self.data.loader.resolve_ident(
ident, options, self.data.main_type))
) /
Add |
Error(self._no_such_ident(ident, options))
)
def from_params(self, ident: str, root: Path, params: Map):
parts = List(*reversed(ident.split('/', 1)))
name = parts[0]
tpe = parts.lift(1).or_else(params.get('type'))
kw = params.at('types', 'langs', 'history')
return self.create(name, root, tpe=tpe, **kw)
def matcher(record: Map) -> Boolean:
return (record.get('name').contains(name) and
record.get('type').contains(tpe))
class App(threading.Thread, Logging):
_components = [] # type: List[Handler]
def __init__(self,
c_module,
run,
omit,
c_args=(),
interval=0.2,
name='series'):
super().__init__(name=name)
self._c_module = c_module
self._c_args = c_args
self._interval = interval
self.name = name
self._running = False
self.components = List()
self.component_map = Map()
self._init_components(run, omit)
def run(self):
self.register_sigint_handler()
self.pre()
self.main_loop()
def pre(self):
self.start_components()
self.prepare()
def prepare(self):
pass
def start_components(self):
for component in self.components:
component.start()
def main_loop(self):
self._running = True
self.log.info('{} running.'.format(self.name))
while self._running:
time.sleep(self._interval)
def _init_components(self, run, omit):
components = self._components
if run:
components = [c for c in components if c in run]
if omit:
components = [c for c in components if c not in omit]
for component in components:
self._setup_component(component)
def _setup_component(self, component):
def error(exc):
msg = 'Invalid component name: {} ({})'.format(component, exc)
self.log.error(msg)
mod_name = 'series.{}.{}'.format(self._c_module, component)
try:
module = importlib.import_module(mod_name)
except ImportError as e:
error(e)
else:
try:
Component = getattr(module, camelcaseify(component))
except AttributeError as e:
error(e)
else:
instance = Component(*self._c_args)
setattr(self, component, instance)
self.components.append(instance)
self.component_map[component] = instance
def register_sigint_handler(self):
SignalManager.instance.sigint(self.interrupt)
def interrupt(self, signum=10, frame=None):
self._stop_components()
self._join_threads()
self._cleanup()
self._running = False
self.log.info('{} shut down due to SIGINT.'.format(self.name))
def _stop_components(self):
for component in self.components:
component.stop()
def _join_threads(self):
for component in self.components:
if component.is_alive():
component.join()
def _cleanup(self):
pass
def component(self, name):
return self.component_map.get(name)
def decode_json_object(data: dict) -> Generator:
m = Map(data)
tpe_s = yield m.get('__type__').to_either(f'no `__type__` attr in json object {m}')
tpe = yield Either.import_path(tpe_s)
dec = yield Decoder.e(tpe)
yield dec.decode(tpe, m)
def get(self):
key = 'key'
val = 'value'
m = Map({key: val})
m.get(key).should.equal(Just(val))
m.get(key + key).should.equal(Empty())
