def _publish_value(initial_value: Any, mapper: Mapper = None) -> Callable[[Observable], Observable]:
if mapper:
def subject_factory(scheduler):
return BehaviorSubject(initial_value)
return ops.multicast(subject_factory=subject_factory, mapper=mapper)
return ops.multicast(BehaviorSubject(initial_value))
def _publish(
mapper: Optional[Mapper] = None
) -> Callable[[Observable], ConnectableObservable]:
"""Returns an observable sequence that is the result of invoking the
mapper on a connectable observable sequence that shares a single
subscription to the underlying sequence. This operator is a
specialization of Multicast using a regular Subject.
Example:
>>> res = publish()
>>> res = publish(lambda x: x)
mapper: [Optional] Selector function which can use the
multicasted source sequence as many times as needed, without causing
multiple subscriptions to the source sequence. Subscribers to the
given source will receive all notifications of the source from the
time of the subscription on.
Returns:
An observable sequence that contains the elements of a sequence
produced by multicasting the source sequence within a mapper
function.
"""
if mapper:
return pipe(
ops.multicast(subject_factory=lambda _: Subject(), mapper=mapper))
return pipe(ops.multicast(subject=Subject()))
def _publish(mapper=None) -> ConnectableObservable:
"""Returns an observable sequence that is the result of invoking the
mapper on a connectable observable sequence that shares a single
subscription to the underlying sequence. This operator is a
specialization of Multicast using a regular Subject.
Example:
>>> res = publish()
>>> res = publish(lambda x: x)
mapper: [Optional] Selector function which can use the
multicasted source sequence as many times as needed, without causing
multiple subscriptions to the source sequence. Subscribers to the
given source will receive all notifications of the source from the
time of the subscription on.
Returns:
An observable sequence that contains the elements of a sequence
produced by multicasting the source sequence within a mapper
function.
"""
if mapper:
return pipe(ops.multicast(subject_factory=lambda _: Subject(), mapper=mapper))
return pipe(ops.multicast(subject=Subject()))
def _replay(
mapper: Optional[Mapper] = None,
buffer_size: Optional[int] = None,
window: Optional[typing.RelativeTime] = None,
scheduler: Optional[Scheduler] = None
) -> Callable[[Observable], Union[Observable, ConnectableObservable]]:
"""Returns an observable sequence that is the result of invoking the
mapper on a connectable observable sequence that shares a single
subscription to the underlying sequence replaying notifications
subject to a maximum time length for the replay buffer.
This operator is a specialization of Multicast using a
ReplaySubject.
Examples:
>>> res = replay(buffer_size=3)
>>> res = replay(buffer_size=3, window=500)
>>> res = replay(None, 3, 500)
>>> res = replay(lambda x: x.take(6).repeat(), 3, 500)
Args:
mapper: [Optional] Selector function which can use the multicasted
source sequence as many times as needed, without causing
multiple subscriptions to the source sequence. Subscribers to
the given source will receive all the notifications of the
source subject to the specified replay buffer trimming policy.
buffer_size: [Optional] Maximum element count of the replay
buffer.
window: [Optional] Maximum time length of the replay buffer.
scheduler: [Optional] Scheduler the observers are invoked on.
Returns:
An observable sequence that contains the elements of a
sequence produced by multicasting the source sequence within a
mapper function.
"""
if mapper:
def subject_factory(scheduler):
return ReplaySubject(buffer_size, window, scheduler)
return ops.multicast(subject_factory=subject_factory, mapper=mapper)
return ops.multicast(ReplaySubject(buffer_size, window, scheduler))
def create():
def subject_factory(scheduler):
return Subject()
def mapper(ys):
return ys
return xs.pipe(
ops.multicast(subject_factory=subject_factory, mapper=mapper))
def create():
def subject_factory(scheduler):
return Subject()
def mapper(ys):
return ys.pipe(
ops.zip(ys),
ops.map(sum),
)
return xs.pipe(ops.multicast(subject_factory=subject_factory, mapper=mapper))
def _replay(mapper: Optional[Mapper] = None,
buffer_size: Optional[int] = None,
window: Optional[typing.RelativeTime] = None,
scheduler: Optional[Scheduler] = None
) -> Callable[[Observable], Union[Observable, ConnectableObservable]]:
"""Returns an observable sequence that is the result of invoking the
mapper on a connectable observable sequence that shares a single
subscription to the underlying sequence replaying notifications
subject to a maximum time length for the replay buffer.
This operator is a specialization of Multicast using a
ReplaySubject.
Examples:
>>> res = replay(buffer_size=3)
>>> res = replay(buffer_size=3, window=500)
>>> res = replay(None, 3, 500)
>>> res = replay(lambda x: x.take(6).repeat(), 3, 500)
Args:
mapper: [Optional] Selector function which can use the multicasted
source sequence as many times as needed, without causing
multiple subscriptions to the source sequence. Subscribers to
the given source will receive all the notifications of the
source subject to the specified replay buffer trimming policy.
buffer_size: [Optional] Maximum element count of the replay
buffer.
window: [Optional] Maximum time length of the replay buffer.
scheduler: [Optional] Scheduler the observers are invoked on.
Returns:
An observable sequence that contains the elements of a
sequence produced by multicasting the source sequence within a
mapper function.
"""
if mapper:
def subject_factory(scheduler):
return ReplaySubject(buffer_size, window, scheduler)
return ops.multicast(subject_factory=subject_factory, mapper=mapper)
return ops.multicast(ReplaySubject(buffer_size, window, scheduler))
def select(selector: Mapper[T1, T2]
) -> Callable[[Observable], Observable]:
""" Reactive operator that applies a selector
and shares the result across multiple subscribers
Args:
selector: the selector function
Returns:
The reactive operator
"""
return pipe(
op.map(selector),
op.distinct_until_changed(comparer=is_),
op.multicast(subject=ReplaySubject(1)),
op.ref_count(),
)
def action0(scheduler, state):
c[0] = xs.pipe(ops.multicast(s))
def test_connectable_observable_multiple_non_overlapped_connections(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(210, 1),
on_next(220, 2),
on_next(230, 3),
on_next(240, 4),
on_next(250, 5),
on_next(260, 6),
on_next(270, 7),
on_next(280, 8),
on_next(290, 9),
on_completed(300)
)
subject = Subject()
conn = xs.pipe(ops.multicast(subject))
c1 = [None]
def action10(scheduler, state):
c1[0] = conn.connect(scheduler)
scheduler.schedule_absolute(225, action10)
def action11(scheduler, state):
c1[0].dispose()
scheduler.schedule_absolute(241, action11)
def action12(scheduler, state):
c1[0].dispose() # idempotency test
scheduler.schedule_absolute(245, action12)
def action13(scheduler, state):
c1[0].dispose() # idempotency test
scheduler.schedule_absolute(251, action13)
def action14(scheduler, state):
c1[0].dispose() # idempotency test
scheduler.schedule_absolute(260, action14)
c2 = [None]
def action20(scheduler, state):
c2[0] = conn.connect(scheduler)
scheduler.schedule_absolute(249, action20)
def action21(scheduler, state):
c2[0].dispose()
scheduler.schedule_absolute(255, action21)
def action22(scheduler, state):
c2[0].dispose() # idempotency test
scheduler.schedule_absolute(265, action22)
def action23(scheduler, state):
c2[0].dispose() # idempotency test
scheduler.schedule_absolute(280, action23)
c3 = [None]
def action30(scheduler, state):
c3[0] = conn.connect(scheduler)
scheduler.schedule_absolute(275, action30)
def action31(scheduler, state):
c3[0].dispose()
scheduler.schedule_absolute(295, action31)
res = scheduler.start(lambda: conn)
assert res.messages == [
on_next(230, 3),
on_next(240, 4),
on_next(250, 5),
on_next(280, 8),
on_next(290, 9)]
assert xs.subscriptions == [
subscribe(225, 241),
subscribe(249, 255),
subscribe(275, 295)]
def action0(scheduler, state):
c[0] = xs.pipe(ops.multicast(s))
