Esempio n. 1
0
 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())
Esempio n. 2
0
 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)
Esempio n. 3
0
 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())
Esempio n. 4
0
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())))
Esempio n. 5
0
    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()
Esempio n. 6
0
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')
Esempio n. 7
0
 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)
Esempio n. 8
0
File: main.py Progetto: tek/proteome
 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())
Esempio n. 9
0
File: main.py Progetto: tek/proteome
 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))
     )
Esempio n. 10
0
 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)
Esempio n. 11
0
 def matcher(record: Map) -> Boolean:
     return (record.get('name').contains(name) and
             record.get('type').contains(tpe))
Esempio n. 12
0
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)
Esempio n. 13
0
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)
Esempio n. 14
0
 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())