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]
