Esempio n. 1
0
def observable_timer_timespan(duetime, scheduler):
    d = Scheduler.normalize(duetime)

    def subscribe(observer):
        def action(scheduler, state):
            observer.on_next(0)
            observer.on_completed()

        return scheduler.schedule_relative(d, action)
    return AnonymousObservable(subscribe)
Esempio n. 2
0
    def observable_timer_timespan(duetime, scheduler):
        d = Scheduler.normalize(duetime)

        def subscribe(observer):
            def action(scheduler, state):
                observer.on_next(0)
                observer.on_completed()

            return scheduler.schedule_relative(d, action)

        return AnonymousObservable(subscribe)
Esempio n. 3
0
def observable_timer_date_and_period(duetime, period, scheduler):
    p = Scheduler.normalize(period)

    def subscribe(observer):
        count = [0]
        d = [duetime]

        def action(state):
            if p > 0:
                now = scheduler.now()
                d[0] = d[0] + scheduler.to_timedelta(p)
                if d[0] <= now:
                    d[0] = now + p

            observer.on_next(count[0])
            count[0] += 1
            state(d[0])

        return scheduler.schedule_recursive_with_absolute(d[0], action)
    return AnonymousObservable(subscribe)
Esempio n. 4
0
    def observable_timer_date_and_period(duetime, period, scheduler):
        p = Scheduler.normalize(period)

        def subscribe(observer):
            count = [0]
            d = [duetime]

            def action(state):
                if p > 0:
                    now = scheduler.now()
                    d[0] = d[0] + scheduler.to_timedelta(p)
                    if d[0] <= now:
                        d[0] = now + p

                observer.on_next(count[0])
                count[0] += 1
                state(d[0])

            return scheduler.schedule_recursive_with_absolute(d[0], action)

        return AnonymousObservable(subscribe)
    def observable_timer_date_and_period(duetime, period, scheduler):
        p = Scheduler.normalize(period)

        def subscribe(observer):
            count = 0
            d = duetime

            def action(scheduler, state):
                nonlocal d, count
                if p > 0:
                    now = scheduler.now()
                    d = d + p
                    if d <= now:
                        d = now + p
                
                observer.on_next(count)
                count += 1
                self(d)
            
            return scheduler.schedule_recursive(d, action)
        return AnonymousObservable(subscribe)
Esempio n. 6
0
    def observable_timer_date_and_period(duetime, period, scheduler):
        p = Scheduler.normalize(period)

        def subscribe(observer):
            count = 0
            d = duetime

            def action(scheduler, state):
                nonlocal d, count
                if p > 0:
                    now = scheduler.now()
                    d = d + p
                    if d <= now:
                        d = now + p

                observer.on_next(count)
                count += 1
                self(d)

            return scheduler.schedule_recursive(d, action)

        return AnonymousObservable(subscribe)
def test_immediate_now():
    res = Scheduler.now() - datetime.utcnow()
    assert res < timedelta(milliseconds=1000)
def test_currentthread_now():
    res = Scheduler.now() - datetime.utcnow()
    assert res < timedelta(milliseconds=1000)
Esempio n. 9
0
def test_immediate_now():
    res = Scheduler.now() - datetime.utcnow()
    assert res < timedelta(milliseconds=1000)
def test_currentthread_now():
    res = Scheduler.now() - datetime.utcnow()
    assert res < timedelta(milliseconds=1000)