def test_map_with_index_dispose_inside_mapper(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(100, 4), on_next(200, 3), on_next(500, 2), on_next(600, 1)
)
invoked = [0]
results = scheduler.create_observer()
d = SerialDisposable()
def projection(x, index):
invoked[0] += 1
if scheduler.clock > 400:
d.dispose()
return x + index * 10
d.disposable = xs.pipe(map_indexed(projection)).subscribe(results)
def action(scheduler, state):
return d.dispose()
scheduler.schedule_absolute(disposed, action)
scheduler.start()
assert results.messages == [on_next(100, 4), on_next(200, 13)]
assert xs.subscriptions == [subscribe(0, 500)]
assert invoked[0] == 3
def factory():
def projection(x, index):
invoked[0] += 1
if invoked[0] == 3:
raise Exception(ex)
return (x + 1) + (index * 10)
return xs.pipe(map_indexed(projection))
def create():
def mapper(w, i):
return w.pipe(ops.map(lambda x: str(i) + " " + str(x)))
return xs.pipe(
ops.window(ys),
ops.map_indexed(mapper),
ops.merge_all(),
)
def create():
def mapper(w, i):
def mapping(x):
return "%s %s" % (i, x)
return w.pipe(ops.map(mapping))
return xs.pipe(ops.window_with_count(3, 2),
ops.map_indexed(mapper), ops.merge_all())
def create():
def mapper(ys, i):
def proj(y):
return "%s %s" % (i, y)
return ys.pipe(
ops.map(proj),
ops.concat(reactivex.return_value("%s end" % i)))
return xs.pipe(ops.window_with_time(100, 50),
ops.map_indexed(mapper), ops.merge_all())
def create():
def closing(x):
return reactivex.timer(x)
def mapper(w, i):
return w.pipe(ops.map(lambda x: str(i) + " " + str(x)))
return xs.pipe(
ops.window_toggle(ys, closing),
ops.map_indexed(mapper),
ops.merge_all(),
)
def create():
def closing():
return reactivex.throw(ex)
def mapper(w, i):
return w.pipe(ops.map(lambda x: str(i) + " " + str(x)))
return xs.pipe(
ops.window_when(closing),
ops.map_indexed(mapper),
ops.merge_all(),
)
def create():
def projection(w, i):
def inner_proj(x):
return "%s %s" % (i, x)
return w.pipe(ops.map(inner_proj))
return xs.pipe(
ops.window_with_time_or_count(70, 3),
ops.map_indexed(projection),
ops.merge_all(),
)
def create():
def closing():
curr = window[0]
window[0] += 1
return reactivex.timer(curr * 100)
def mapper(w, i):
return w.pipe(ops.map(lambda x: str(i) + " " + str(x)))
return xs.pipe(
ops.window_when(closing),
ops.map_indexed(mapper),
ops.merge_all(),
)
def skip_while_indexed_(
predicate: typing.PredicateIndexed[_T],
) -> Callable[[Observable[_T]], Observable[_T]]:
def indexer(x: _T, i: int) -> Tuple[_T, int]:
return (x, i)
def skipper(x: Tuple[_T, int]) -> bool:
return predicate(*x)
def mapper(x: Tuple[_T, int]) -> _T:
return x[0]
return compose(
ops.map_indexed(indexer),
ops.skip_while(skipper),
ops.map(mapper),
)
def test_map_with_index_throws(self):
with self.assertRaises(RxException):
mapper = map_indexed(lambda x, index: x)
return return_value(1).pipe(mapper).subscribe(lambda x: _raise("ex"))
with self.assertRaises(RxException):
return (
throw("ex").pipe(mapper).subscribe(lambda x: x, lambda ex: _raise(ex))
)
with self.assertRaises(RxException):
return (
empty()
.pipe(mapper)
.subscribe(lambda x: x, lambda ex: None, lambda: _raise("ex"))
)
with self.assertRaises(RxException):
return create(lambda o, s: _raise("ex")).pipe(mapper).subscribe()
def _flat_map_internal(
source: Observable[_T1],
mapper: Optional[Mapper[_T1, Any]] = None,
mapper_indexed: Optional[MapperIndexed[_T1, Any]] = None,
) -> Observable[Any]:
def projection(x: _T1, i: int) -> Observable[Any]:
mapper_result: Any = (mapper(x) if mapper else mapper_indexed(x, i)
if mapper_indexed else identity)
if isinstance(mapper_result, Future):
result: Observable[Any] = from_future(
cast("Future[Any]", mapper_result))
elif isinstance(mapper_result, Observable):
result = mapper_result
else:
result = from_(mapper_result)
return result
return source.pipe(
ops.map_indexed(projection),
ops.merge_all(),
)
def create():
def mapper(w, i):
return w.pipe(ops.map(lambda x: "%s %s" % (i, x)))
return xs.pipe(ops.window_with_time(100), ops.map_indexed(mapper),
ops.merge_all())
def factory():
return xs.pipe(map_indexed())
def create():
def proj(w, i):
return w.pipe(ops.map(lambda x: str(i) + " " + str(x)))
return xs.pipe(ops.window_with_count(3, 2), ops.map_indexed(proj),
ops.merge_all())
def projection(x):
return reactivex.interval(10).pipe(
ops.map_indexed(lambda a, b: x), ops.take(x))
def factory():
def projection(x, index):
invoked[0] += 1
return (x + 1) + (index * 10)
return xs.pipe(map_indexed(projection))
