class AsyncHandler(ReleaseHandler): def __init__(self, timeout, *a, **kw) -> None: super().__init__(*a, **kw) self._async = Empty() self._timeout = timedelta(minutes=timeout) def _handle(self, monitor): if self._async.empty: self._async = (self._create_async(monitor) / amino.L(self._adapter)(_, monitor) % __.start()) def _cleanup(self): def timeout(a): if datetime.now() - a.created > self._timeout: self._clean_timeout(a) a.kill() return True if (self._async.exists(self._clean_done) or self._async.exists(timeout)): self._async = Empty() @abc.abstractproperty def _adapter(self) -> type: ... @abc.abstractmethod def _clean_done(self, proc) -> bool: ... @abc.abstractmethod def _clean_timeout(self, proc) -> None: ...
def eff_map(self): a, b = self._r c = -1 t = Right(List(Just(Right(a)), Just(Left(c)), Empty())) target = Right(List(Just(Right(a + b)), Just(Left(c)), Empty())) res = t.effs(3).map(_ + b) res.value.should.equal(target)
def eff_flat_io_empty(self): t = IO.now(List(Right(Empty()))) target = List(Right(Empty())) res = (t.effs( 4, List, Either, Maybe, Either).flat_map(lambda x: IO.now(List(Right(Just(Right(1))))))) res.value.run().should.equal(target)
def optional(self) -> None: a = 'a' b = 'b' Maybe.optional(a).to_maybe.should.just_contain(a) Empty().to_maybe.should.be.a(Empty) Maybe.optional(a).to_either(b).should.equal(Right(a)) Empty().to_either(b).should.equal(Left(b)) Empty().to_either(lambda: b).should.equal(Left(b))
def _cleanup(self): def timeout(a): if datetime.now() - a.created > self._timeout: self._clean_timeout(a) a.kill() return True if (self._async.exists(self._clean_done) or self._async.exists(timeout)): self._async = Empty()
def find(self): k1 = 'key' v1 = 'value' k2 = 'key2' v2 = 'value2' m = Map({k1: v1, k2: v2}) m.find(_ == v1).should.equal(Just((k1, v1))) m.find_key(_ == k2).should.equal(Just((k2, v2))) m.find(_ == 'invalid').should.equal(Empty()) m.find_key(_ == 'invalid').should.equal(Empty())
def run(names, ids): return ( Empty() if ids.empty else ids.head if ids.length == 1 else self._ask_show(names, ids) )
def create(self, data: Callable = None, path=Empty()): cb = (lambda a: Just(dict())) if data is None else data sub = path / '/{}'.format | '' def assemble(path): return (cb(self.rest).io('invalid arguments') / L(self.client.post)('{}{}'.format(path, sub), _)) return self._data_path // assemble
def add_multi(self): key = 'key' val = 'value' k2 = 'key2' v2 = 'value2' m = Map({key: val}) m2 = m**Map({k2: v2}) m2.lift(k2).should.equal(Just(v2)) m.lift(k2).should.equal(Empty())
def add(self): key = 'key' val = 'value' k2 = 'key2' v2 = 'value2' m = Map({key: val}) m2 = m + (k2, v2) m2.lift(k2).should.equal(Just(v2)) m.lift(k2).should.equal(Empty())
def flat_map(self): k1 = 'key' v1 = 'value' k2 = 'key2' v2 = 'value2' m = Map({k1: v1, k2: v2}) res = m.flat_map(lambda a, b: Just((a, b)) if a == k1 else Empty()) res.should.have.key(k1).being.equal(v1) res.should_not.have.key(k2)
def __init__(self, library) -> None: self._library = library if self._display: os.environ['DISPLAY'] = self._display self._Player = None self._mplayer = None self._target = None self._observer = None self._extra_args = [] # type: list self._sub_fps = Empty() self._setup_player_type()
def from_tree( tree: Node[A, Any], f: Callable[[Node[A, Any], Maybe[RoseTree[B]]], B], cons_root: Callable[[B, Callable[[RoseTree[Node[A, Any]]], LazyList[RoseTree[Node[A, Any]]]]], RoseTree[B]], cons_node: Callable[ [B, RoseTree[Node[A, Any]], Callable[[RoseTree[Node[A, Any]]], LazyList[RoseTree[Node[A, Any]]]]], RoseTree[B] ] ) -> RoseTree[B]: def sub(node: Node[A, Any]) -> Callable[[RoseTree[Node[B, Any]]], LazyList[RoseTree[Node[B, Any]]]]: def cons_sub(parent: RoseTree[Node[B, Any]], a: A) -> RoseTree[B]: return cons_node(f(a, Just(parent)), parent, sub(a)) return lambda parent: node.sub_l.map(lambda a: cons_sub(parent, a)) return cons_root(f(tree, Empty()), sub(tree))
def _req(self, meth, path=Empty(), data=None): sub = path / '/{}'.format | '' cb = (lambda a: Just(dict())) if data is None else data def io(i, body): return IO.delay(meth(self.client), '{}/{}{}'.format(self._type, i, sub), body=body) def assemble(i, a): return cb(a).io('invalid arguments') // L(io)(i, _) def check_error(response): if isinstance(response, dict) and 'error' in response: return IO.failed(response['error']) else: return IO.pure(response) return self.run(assemble) // check_error
def eff_map_io(self): a, b = self._r t = IO.now(List(Just(a), Just(b), Empty())) target = List(Just(a + b), Just(b + b), Empty()) res = t.effs(2).map(_ + b) res.value.run().should.equal(target)
def join_maybes(self): List(Just(4), Empty(), Just(5), Empty())\ .join\ .should.equal(List(4, 5))
def resolve(): return self._resolve_show(name) if self._query_etvdb else Empty()
def flat_map_maybe(self): List(1, 2, 3)\ .flat_map(lambda a: Empty() if a % 2 == 0 else Just(a + 1))\ .should.equal(List(2, 4))
def __init__(self, timeout, *a, **kw) -> None: super().__init__(*a, **kw) self._async = Empty() self._timeout = timedelta(minutes=timeout)
def filter(self, fa: Maybe[A], f: Callable[[A], bool]): return fa // (lambda a: Just(a) if f(a) else Empty())
def index_where(self, fa: Maybe[A], f: Callable[[A], bool]): return fa / f // (lambda a: Just(0) if a else Empty())
def flat_map(self, fa: Maybe[A], f: Callable[[A], Maybe[B]]) -> Maybe[B]: return fa.cata(lambda v: f(v), Empty())
def traverse(self, fa: Maybe[A], f: Callable, tpe: type): monad = Applicative.fatal(tpe) r = lambda a: monad.map(f(a), Just) return fa.cata(r, monad.pure(Empty()))
def find(self): l = List(1, 6, 9) l.find(_ % 2 == 0).should.equal(Just(6)) l.find(_ == 3).should.equal(Empty())
def lift(self): l = List(1, 4, 7) l.lift(1).should.equal(Just(4)) l.lift(3).should.equal(Empty())
def eff_flat_empty(self): t = List(Right(Empty())) target = List(Right(Empty())) res = (t.effs(3, Either, Maybe, Maybe).flat_map(lambda x: List(Right(Just(Just(1)))))) res.value.should.equal(target)
def __init__(self, releases, shows, *a, **kw): RestApiBase.__init__(self, 'get') self._releases = releases self._shows = shows self._getd = Empty()
def __init__(self, releases, *a, **kw): super().__init__(self._download_timeout, releases, 5, 'download manager') self._min_failed = 0 self._proc = Empty()
def result(self) -> Maybe[List]: return (Just(List.wrap(self._result.get_nowait())) if self.result_present else Empty())
def post(self, data: Callable = None, path=Empty()): return self._req(_.post, path=path, data=data)