async def test_pipe_complex_pipe(): xs = AsyncObservable.from_iterable([1, 2, 3]) result = [] def mapper(value): return value * 10 async def predicate(value): await asyncio.sleep(0.1) return value > 1 async def long_running(value): return AsyncObservable.from_iterable([value]) ys = pipe(xs, op.filter(predicate), op.map(mapper), op.flat_map(long_running) ) async with subscribe(ys) as stream: async for value in stream: result.append(value) assert result == [20, 30]
async def test_forward_pipe_map() -> None: xs = AsyncObservable.from_iterable([1, 2, 3]) result = [] def mapper(value) -> int: return value * 10 ys = xs | op.map(mapper) async def asend(value) -> None: result.append(value) await run(ys, AnonymousAsyncObserver(asend)) assert result == [10, 20, 30]
async def test_pipe_map(): xs = AsyncObservable.from_iterable([1, 2, 3]) result = [] def mapper(value): return value * 10 ys = pipe(xs, op.map(mapper)) async def asend(value): result.append(value) await run(ys, AnonymousAsyncObserver(asend)) assert result == [10, 20, 30]
async def test_map_happy(): xs = from_iterable([1, 2, 3]) # type: AsyncObservable[int] values = [] async def asend(value): values.append(value) def mapper(value: int) -> int: return value * 10 ys = xs | op.map(mapper) result = await run(ys, AnonymousAsyncObserver(asend)) assert result == 30 assert values == [10, 20, 30]
async def test_forward_pipe_simple_pipe() -> None: xs = AsyncObservable.from_iterable([1, 2, 3]) result = [] def mapper(value) -> int: return value * 10 async def predicate(value) -> bool: await asyncio.sleep(0.1) return value > 1 ys = xs | op.filter(predicate) | op.map(mapper) async def asend(value) -> None: result.append(value) await run(ys, AnonymousAsyncObserver(asend)) assert result == [20, 30]
async def test_pipe_simple_pipe(): xs = AsyncObservable.from_iterable([1, 2, 3]) result = [] def mapper(value): return value * 10 async def predicate(value): await asyncio.sleep(0.1) return value > 1 ys = pipe(xs, op.filter(predicate), op.map(mapper) ) async def asend(value): result.append(value) await run(ys, AnonymousAsyncObserver(asend)) assert result == [20, 30]
async def test_map_mapper_throws(): xs = from_iterable([1]) exception = None error = Exception("ex") async def asend(value): pass async def athrow(ex): nonlocal exception exception = ex def mapper(x): raise error ys = xs | op.map(mapper) try: await run(ys, AnonymousAsyncObserver(asend, athrow)) except Exception as ex: assert ex == error assert exception == error
async def websocket_handler(request): print("WebSocket opened") stream = AsyncStream() # Line break before binary operator is more readable. Disable W503 xs = ( stream | op.map(lambda x: x["term"]) | op.filter(lambda text: len(text) > 2) | op.debounce(0.75) | op.distinct_until_changed() | op.flat_map(search_wikipedia) #| op.switch_latest() ) ws = web.WebSocketResponse() await ws.prepare(request) async def asend(value): ws.send_str(value) async def athrow(ex): print(ex) await subscribe(xs, AnonymousAsyncObserver(asend, athrow)) async for msg in ws: if msg.type == aiohttp.WSMsgType.TEXT: obj = json.loads(msg.data) await stream.asend(obj) elif msg.type == aiohttp.WSMsgType.ERROR: print('ws connection closed with exception %s' % ws.exception()) print('websocket connection closed') return ws
async def test_map_subscription_cancel(): xs = AsyncStream() result = [] sub = None def mapper(value): return value * 10 print("-----------------------") print([xs, op.map]) ys = xs | op.map(mapper) async def asend(value): result.append(value) sub.dispose() await asyncio.sleep(0) async with subscribe(ys, AnonymousAsyncObserver(asend)) as sub: await xs.asend(10) await asyncio.sleep(0) await xs.asend(20) assert result == [100]