def partition_indexed(source: Observable[_T]) -> List[Observable[_T]]:
"""The partially applied indexed partition operator.
Returns two observables which partition the observations of the
source by the given function. The first will trigger
observations for those values for which the predicate returns
true. The second will trigger observations for those values
where the predicate returns false. The predicate is executed
once for each subscribed observer. Both also propagate all
error observations arising from the source and each completes
when the source completes.
Args:
source: Source observable to partition.
Returns:
A list of observables. The first triggers when the
predicate returns True, and the second triggers when the
predicate returns False.
"""
def not_predicate_indexed(x: _T, i: int) -> bool:
return not predicate_indexed(x, i)
published = source.pipe(
ops.publish(),
ops.ref_count(),
)
return [
published.pipe(ops.filter_indexed(predicate_indexed)),
published.pipe(ops.filter_indexed(not_predicate_indexed)),
]
def share_() -> Callable[[Observable[_TSource]], Observable[_TSource]]:
"""Share a single subscription among multple observers.
Returns a new Observable that multicasts (shares) the original
Observable. As long as there is at least one Subscriber this
Observable will be subscribed and emitting data. When all
subscribers have unsubscribed it will unsubscribe from the source
Observable.
This is an alias for a composed publish() and ref_count().
"""
return compose(
ops.publish(),
ops.ref_count(),
)
def test_ref_count_notconnected(self):
disconnected = [False]
count = [0]
def factory(scheduler):
count[0] += 1
def create(obs, scheduler=None):
def func():
disconnected[0] = True
return func
return reactivex.create(create)
xs = reactivex.defer(factory)
subject = MySubject()
conn = ConnectableObservable(xs, subject)
refd = conn.pipe(ops.ref_count())
dis1 = refd.subscribe()
self.assertEqual(1, count[0])
self.assertEqual(1, subject.subscribe_count)
assert not disconnected[0]
dis2 = refd.subscribe()
self.assertEqual(1, count[0])
self.assertEqual(2, subject.subscribe_count)
assert not disconnected[0]
dis1.dispose()
assert not disconnected[0]
dis2.dispose()
assert disconnected[0]
disconnected[0] = False
dis3 = refd.subscribe()
self.assertEqual(2, count[0])
self.assertEqual(3, subject.subscribe_count)
assert not disconnected[0]
dis3.dispose()
assert disconnected[0]
def create():
return conn.pipe(ops.ref_count())