def skip(self, count): """Bypasses a specified number of elements in an observable sequence and then returns the remaining elements. Keyword arguments: count -- The number of elements to skip before returning the remaining elements. Returns an observable sequence that contains the elements that occur after the specified index in the input sequence. """ if count < 0: raise ArgumentOutOfRangeException() observable = self def subscribe(observer): remaining = [count] def on_next(value): if remaining[0] <= 0: observer.on_next(value) else: remaining[0] -= 1 return observable.subscribe(on_next, observer.on_error, observer.on_completed) return AnonymousObservable(subscribe)
def advance_to(self, time): """Advances the schedulers clock to the specified time, running all work til that point. Keyword arguments: time -- Absolute time to advance the schedulers clock to.""" due_to_clock = self.comparer(self.clock, time) if due_to_clock > 0: raise ArgumentOutOfRangeException() if not due_to_clock: return if not self.is_enabled: self.is_enabled = True while self.is_enabled: next = self.get_next() if next and self.comparer(next.duetime, time) <= 0: if self.comparer(next.duetime, self.clock) > 0: self.clock = next.duetime next.invoke() else: self.is_enabled = False self.clock = time
def advance_to(self, time): """Advances the schedulers clock to the specified time, running all work til that point. Keyword arguments: time -- Absolute time to advance the schedulers clock to.""" if self.clock > time: raise ArgumentOutOfRangeException() if self.clock == time: return if self.is_enabled: return self.is_enabled = True while self.is_enabled: next = self.get_next() if not next: break if next.duetime > time: self.queue.enqueue(next) break if next.duetime > self.clock: self.clock = next.duetime next.invoke() self.is_enabled = False self.clock = time
def _skip(count: int) -> Callable[[Observable], Observable]: if count < 0: raise ArgumentOutOfRangeException() def skip(source: Observable) -> Observable: """The skip operator. Bypasses a specified number of elements in an observable sequence and then returns the remaining elements. Args: source: The source observable. Returns: An observable sequence that contains the elements that occur after the specified index in the input sequence. """ def subscribe(observer, scheduler=None): remaining = count def on_next(value): nonlocal remaining if remaining <= 0: observer.on_next(value) else: remaining -= 1 return source.subscribe_(on_next, observer.on_error, observer.on_completed, scheduler) return Observable(subscribe) return skip
def advance_to(self, time: float) -> None: """Advances the schedulers clock to the specified time, running all work til that point. Args: time: Absolute time to advance the schedulers clock to. """ if self.clock > time: raise ArgumentOutOfRangeException() if self.clock == time: return if self.is_enabled: return self.is_enabled = True while self.is_enabled: item = self.get_next() if not item: break if item.duetime > time: self.queue.enqueue(item) break if item.duetime > self.clock: self.clock = item.duetime item.invoke() self.is_enabled = False self.clock = time
def skip(count: int, source: ObservableBase) -> ObservableBase: """Bypasses a specified number of elements in an observable sequence and then returns the remaining elements. Keyword arguments: count -- The number of elements to skip before returning the remaining elements. Returns an observable sequence that contains the elements that occur after the specified index in the input sequence. """ if count < 0: raise ArgumentOutOfRangeException() observable = source def subscribe(observer, scheduler=None): remaining = count def on_next(value): nonlocal remaining if remaining <= 0: observer.on_next(value) else: remaining -= 1 return observable.subscribe_(on_next, observer.on_error, observer.on_completed, scheduler) return AnonymousObservable(subscribe)
def sleep(self, time): """Advances the schedulers clock by the specified relative time. Keyword arguments: time -- Relative time to advance the schedulers clock by.""" dt = self.add(self.clock, time) if self.clock > dt: raise ArgumentOutOfRangeException() self.clock = dt
def advance_by(self, time): """Advances the schedulers clock by the specified relative time, running all work scheduled for that timespan. Keyword arguments: time -- Relative time to advance the schedulers clock by.""" log.debug("VirtualTimeScheduler.advance_by(time=%s)", time) dt = self.add(self.clock, time) if self.clock > dt: raise ArgumentOutOfRangeException() return self.advance_to(dt)
def sleep(self, time: float) -> None: """Advances the schedulers clock by the specified relative time. Args: time: Relative time to advance the schedulers clock by. """ dt = self.add(self.clock, time) if self.clock > dt: raise ArgumentOutOfRangeException() self.clock = dt
def advance_to(self, time: typing.AbsoluteTime) -> None: """Advances the schedulers clock to the specified absolute time, running all work til that point. Args: time: Absolute time to advance the schedulers clock to. """ dt: datetime = self.to_datetime(time) with self._lock: if self.now > dt: raise ArgumentOutOfRangeException() if self.now == dt or self._is_enabled: return self._is_enabled = True while True: with self._lock: if not self._is_enabled or not self._queue: break item: ScheduledItem = self._queue.peek() if item.duetime > dt: break if item.duetime > self.now: if isinstance(self._clock, datetime): self._clock = item.duetime else: self._clock = self.to_seconds(item.duetime) self._queue.dequeue() if not item.is_cancelled(): item.invoke() with self._lock: self._is_enabled = False if isinstance(self._clock, datetime): self._clock = dt else: self._clock = self.to_seconds(dt)
def sleep(self, time: typing.RelativeTime) -> None: """Advances the schedulers clock by the specified relative time. Args: time: Relative time to advance the schedulers clock by. """ absolute = self.add(self.now, self.to_timedelta(time)) dt: datetime = self.to_datetime(absolute) if self.now > dt: raise ArgumentOutOfRangeException() with self._lock: if isinstance(self._clock, datetime): self._clock = dt else: self._clock = self.to_seconds(dt)
def take(self, count, scheduler=None): """Returns a specified number of contiguous elements from the start of an observable sequence, using the specified scheduler for the edge case of take(0). 1 - source.take(5) 2 - source.take(0, rx.Scheduler.timeout) Keyword arguments: count -- The number of elements to return. scheduler -- [Optional] Scheduler used to produce an OnCompleted message in case count is set to 0. Returns an observable sequence that contains the specified number of elements from the start of the input sequence. """ if count < 0: raise ArgumentOutOfRangeException() if not count: return Observable.Empty(scheduler) observable = self def subscribe(observer): remaining = count def on_next(value): nonlocal remaining if remaining > 0: remaining -= 1 observer.on_next(value) if not remaining: observer.on_completed() return observable.subscribe(on_next, observer.on_error, observer.on_completed) return AnonymousObservable(subscribe)
def advance_to(self, time: float) -> None: """Advances the schedulers clock to the specified absolute time, running all work til that point. Args: time: Absolute time to advance the schedulers clock to. """ with self._lock: if self._clock > time: raise ArgumentOutOfRangeException() if self._clock == time or self._is_enabled: return self._is_enabled = True while True: with self._lock: if not self._is_enabled or not self._queue: break item: ScheduledItem[typing.TState] = self._queue.peek() if item.duetime > time: break if item.duetime > self._clock: self._clock = item.duetime self._queue.dequeue() if not item.is_cancelled(): item.invoke() with self._lock: self._is_enabled = False self._clock = time
def _take(count: int) -> Callable[[Observable], Observable]: if count < 0: raise ArgumentOutOfRangeException() def take(source: Observable) -> Observable: """Returns a specified number of contiguous elements from the start of an observable sequence. >>> take(source) Keyword arguments: count -- The number of elements to return. Returns an observable sequence that contains the specified number of elements from the start of the input sequence. """ if not count: return empty() def subscribe(observer, scheduler=None): remaining = count def on_next(value): nonlocal remaining if remaining > 0: remaining -= 1 observer.on_next(value) if not remaining: observer.on_completed() return source.subscribe_(on_next, observer.on_error, observer.on_completed, scheduler) return Observable(subscribe) return take