def create():
def mapper(x):
return Timestamp(x.value, x.timestamp)
return xs.pipe(
ops.timestamp(),
ops.map(mapper),
)
def create():
return reactivex.never().pipe(ops.timestamp())
def create():
return reactivex.throw(ex).pipe(ops.timestamp())
def create():
return reactivex.empty().pipe(ops.timestamp())
def subscribe(observer: abc.ObserverBase[_T],
scheduler_: Optional[abc.SchedulerBase] = None):
nonlocal duetime
_scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
if isinstance(duetime, datetime):
duetime_ = _scheduler.to_datetime(duetime) - _scheduler.now
else:
duetime_ = _scheduler.to_timedelta(duetime)
cancelable = SerialDisposable()
exception: Optional[Exception] = None
active = [False]
running = [False]
queue: List[Timestamp[Notification[_T]]] = []
def on_next(notification: Timestamp[Notification[_T]]) -> None:
nonlocal exception
should_run = False
with source.lock:
if isinstance(notification.value, OnError):
del queue[:]
queue.append(notification)
exception = notification.value.exception
should_run = not running[0]
else:
queue.append(
Timestamp(
value=notification.value,
timestamp=notification.timestamp + duetime_,
))
should_run = not active[0]
active[0] = True
if should_run:
if exception:
observer.on_error(exception)
else:
mad = MultipleAssignmentDisposable()
cancelable.disposable = mad
def action(scheduler: abc.SchedulerBase,
state: Any = None):
if exception:
return
with source.lock:
running[0] = True
while True:
result = None
if queue and queue[
0].timestamp <= scheduler.now:
result = queue.pop(0).value
if result:
result.accept(observer)
if not result:
break
should_continue = False
recurse_duetime: typing.RelativeTime = 0
if queue:
should_continue = True
diff = queue[0].timestamp - scheduler.now
recurse_duetime = max(DELTA_ZERO, diff)
else:
active[0] = False
ex = exception
running[0] = False
if ex:
observer.on_error(ex)
elif should_continue:
mad.disposable = scheduler.schedule_relative(
recurse_duetime, action)
mad.disposable = _scheduler.schedule_relative(
duetime_, action)
subscription = source.pipe(
ops.materialize(),
ops.timestamp(),
).subscribe(on_next, scheduler=_scheduler)
return CompositeDisposable(subscription, cancelable)