Python from_ 예제들

예제 #1

파일: test_distinct.py 프로젝트: mcorniere/rxsci

def test_distinct_with_key():
    source = [
        (1, "foo", 1),
        (1, "foo", 3),
        (1, "bar", 1),
        (2, "biz", 1),
        (1, "bar", 2),
        (3, "biz", 1),
        (7, "Biz", 1),
    ]
    actual_result = []

    def on_next(i):
        actual_result.append(i)

    rx.from_(source).pipe(
        rs.state.with_memory_store(
            rs.ops.distinct(lambda i: (i[0], i[1])), ), ).subscribe(on_next)

    assert actual_result == [
        (1, "foo", 1),
        (1, "bar", 1),
        (2, "biz", 1),
        (3, "biz", 1),
        (7, "Biz", 1),
    ]

예제 #2

def test_to_list_mux():
    actual_result = []
    source = [
        rs.OnCreateMux((1, )),
        rs.OnNextMux((1, ), 1),
        rs.OnNextMux((1, ), 2),
        rs.OnCreateMux((2, )),
        rs.OnNextMux((1, ), 3),
        rs.OnNextMux((2, ), 10),
        rs.OnNextMux((2, ), 11),
        rs.OnNextMux((1, ), 4),
        rs.OnNextMux((2, ), 12),
        rs.OnCompletedMux((1, )),
        rs.OnCompletedMux((2, )),
    ]

    rx.from_(source).pipe(
        rs.cast_as_mux_observable(),
        rs.state.with_memory_store(rs.data.to_list(), ),
    ).subscribe(on_next=actual_result.append)

    assert actual_result == [
        rs.OnCreateMux((1, )),
        rs.OnCreateMux((2, )),
        rs.OnNextMux((1, ), [1, 2, 3, 4]),
        rs.OnCompletedMux((1, )),
        rs.OnNextMux((2, ), [10, 11, 12]),
        rs.OnCompletedMux((2, )),
    ]

예제 #3

파일: test_scan.py 프로젝트: mcorniere/rxsci

def test_scan_mux_reduce_empty_on_complete():
    source = [
        rs.OnCreateMux((0, None)),
        rs.OnCompletedMux((0, None)),
    ]
    actual_error = []
    actual_completed = []
    actual_result = []

    def on_completed():
        actual_completed.append(True)

    rx.from_(source).pipe(
        rs.cast_as_mux_observable(),
        rs.state.with_memory_store(
            rs.ops.scan(lambda acc, i: i + acc, seed=0,
                        reduce=True), )).subscribe(
                            on_next=actual_result.append,
                            on_completed=on_completed,
                            on_error=actual_error.append,
                        )

    assert actual_error == []
    assert actual_completed == [True]
    assert actual_result == [
        rs.OnCreateMux((0, None)),
        rs.OnNextMux((0, None), 0),
        rs.OnCompletedMux((0, None)),
    ]

예제 #4

파일: test_split.py 프로젝트: maki-nage/rxsci

def test_split_without_store():
    actual_error = []

    rx.from_([1, 2, 3, 4]).pipe(rs.data.split(
        lambda i: i[-1], rx.pipe()), ).subscribe(on_error=actual_error.append)

    assert type(actual_error[0]) is ValueError

예제 #5

파일: timeflies_qt.py 프로젝트: ReactiveX/RxPY

def main():
    app = QApplication(sys.argv)
    scheduler = QtScheduler(QtCore)

    window = Window()
    window.show()

    text = 'TIME FLIES LIKE AN ARROW'

    def on_next(info):
        label, (x, y), i = info
        label.move(x + i*12 + 15, y)
        label.show()

    def handle_label(label, i):
        delayer = ops.delay(i * 0.100)
        mapper = ops.map(lambda xy: (label, xy, i))

        return window.mousemove.pipe(
            delayer,
            mapper,
            )

    labeler = ops.flat_map_indexed(handle_label)
    mapper = ops.map(lambda c: QLabel(c, window))

    rx.from_(text).pipe(
        mapper,
        labeler,
    ).subscribe(on_next, on_error=print, scheduler=scheduler)

    sys.exit(app.exec_())

예제 #6

def test_tee_map_mux_combine_latest_empty():
    source = [
        rs.OnCreateMux((1, )),
        rs.OnCompletedMux((1, )),
        rs.OnCreateMux((1, )),
        rs.OnNextMux((1, ), 10),
        rs.OnNextMux((1, ), 20),
        rs.OnCompletedMux((1, )),
    ]
    actual_result = []
    actual_error = []

    rx.from_(source).pipe(
        rs.cast_as_mux_observable(),
        rs.ops.tee_map(
            rs.ops.map(lambda i: i * 2),
            rs.ops.map(lambda i: i),
            join='combine_latest',
        ),
    ).subscribe(
        on_next=actual_result.append,
        on_error=actual_error.append,
    )

    assert actual_error == []
    assert actual_result == [
        rs.OnCreateMux((1, )),
        rs.OnCompletedMux((1, )),
        rs.OnCreateMux((1, )),
        rs.OnNextMux((1, ), (20, None)),
        rs.OnNextMux((1, ), (20, 10)),
        rs.OnNextMux((1, ), (40, 10)),
        rs.OnNextMux((1, ), (40, 20)),
        rs.OnCompletedMux((1, )),
    ]

예제 #7

def test_tee_map_mux():
    source = [
        rs.OnCreateMux((1, )),
        rs.OnNextMux((1, ), 1),
        rs.OnCreateMux((2, )),
        rs.OnNextMux((2, ), 2),
        rs.OnNextMux((2, ), 2),
        rs.OnNextMux((1, ), 1),
        rs.OnCompletedMux((1, )),
        rs.OnCompletedMux((2, )),
    ]
    actual_result = []
    actual_error = []

    rx.from_(source).pipe(
        rs.cast_as_mux_observable(),
        rs.ops.tee_map(lambda d: d.pipe(rs.ops.map(lambda i: i * 2), ),
                       lambda d: d.pipe(rs.ops.map(lambda i: i))),
    ).subscribe(
        on_next=actual_result.append,
        on_error=actual_error.append,
    )

    assert actual_error == []
    assert actual_result == [
        rs.OnCreateMux((1, )),
        rs.OnNextMux((1, ), (2, 1)),
        rs.OnCreateMux((2, )),
        rs.OnNextMux((2, ), (4, 2)),
        rs.OnNextMux((2, ), (4, 2)),
        rs.OnNextMux((1, ), (2, 1)),
        rs.OnCompletedMux((1, )),
        rs.OnCompletedMux((2, )),
    ]

예제 #8

def test_pad_start_no_value():
    actual_result = []
    source = [
        rs.OnCreateMux((1, )),
        rs.OnNextMux((1, ), 1),
        rs.OnNextMux((1, ), 2),
        rs.OnNextMux((1, ), 3),
        rs.OnNextMux((1, ), 4),
        rs.OnNextMux((1, ), 5),
        rs.OnCompletedMux((1, )),
    ]

    rx.from_(source).pipe(
        rs.cast_as_mux_observable(),
        rs.state.with_memory_store(rs.data.pad_start(size=3), ),
    ).subscribe(on_next=actual_result.append)

    assert actual_result == [
        rs.OnCreateMux((1, )),
        rs.OnNextMux((1, ), 1),
        rs.OnNextMux((1, ), 1),
        rs.OnNextMux((1, ), 1),
        rs.OnNextMux((1, ), 1),
        rs.OnNextMux((1, ), 2),
        rs.OnNextMux((1, ), 3),
        rs.OnNextMux((1, ), 4),
        rs.OnNextMux((1, ), 5),
        rs.OnCompletedMux((1, )),
    ]

예제 #9

파일: ex_merge.py 프로젝트: xuqinghan/learn-RxPY

def demo_merge1():

    obs1 = rx.from_([1, 2, 3, 4])
    obs2 = rx.from_([5, 6, 7, 8])

    res = rx.merge(obs1, obs2)
    res.subscribe(print)

예제 #10

파일: test_distinct_until_changed.py 프로젝트: mcorniere/rxsci

def test_distinct_until_changed_with_key():
    source = [
        (1, "foo", 1),
        (1, "foo", 3),
        (1, "bar", 1),
        (2, "biz", 1),
        (1, "bar", 2),
        (3, "biz", 1),
        (7, "Biz", 1),
    ]
    actual_result = []

    def on_next(i):
        actual_result.append(i)

    rx.from_(source).pipe(rs.ops.distinct_until_changed(
        lambda i: (i[0], i[1]))).subscribe(on_next)

    assert actual_result == [
        (1, "foo", 1),
        (1, "bar", 1),
        (2, "biz", 1),
        (1, "bar", 2),
        (3, "biz", 1),
        (7, "Biz", 1),
    ]

예제 #11

파일: test_mean.py 프로젝트: mcorniere/rxsci

def test_mean_mux_key_mapper():
    source = [
        rs.OnCreateMux((1, None)),
        rs.OnNextMux((1, None), ('a', 2)),
        rs.OnCreateMux((2, None)),
        rs.OnNextMux((2, None), ('A', 3)),
        rs.OnNextMux((2, None), ('B', 6)),
        rs.OnNextMux((1, None), ('b', 3)),
        rs.OnNextMux((1, None), ('c', 10)),
        rs.OnNextMux((1, None), ('d', 4)),
        rs.OnCompletedMux((1, None)),
        rs.OnCompletedMux((2, None)),
    ]
    actual_result = []

    rx.from_(source).pipe(
        rs.cast_as_mux_observable(),
        rs.state.with_memory_store(rs.math.mean(lambda i: i[1],
                                                reduce=True), ),
    ).subscribe(
        on_next=actual_result.append,
        on_error=lambda e: print(e),
    )

    assert actual_result == [
        rs.OnCreateMux((1, None)),
        rs.OnCreateMux((2, None)),
        rs.OnNextMux((1, None), 4.75),
        rs.OnCompletedMux((1, None)),
        rs.OnNextMux((2, None), 4.5),
        rs.OnCompletedMux((2, None)),
    ]

예제 #12

def test_variance_mux():
    s1 = [random.normalvariate(0.0, 1.0) for _ in range(10)]
    s2 = [random.normalvariate(1.0, 2.0) for _ in range(10)]
    source = [
        rs.OnCreateMux((1, None)),
        rs.OnCreateMux((2, None)),
    ]
    source.extend([rs.OnNextMux((1, None), i) for i in s1])
    source.extend([rs.OnNextMux((2, None), i) for i in s2])
    source.extend([
        rs.OnCompletedMux((1, None)),
        rs.OnCompletedMux((2, None)),
    ])

    actual_result = []

    rx.from_(source).pipe(
        rs.cast_as_mux_observable(),
        rs.state.with_memory_store(rs.math.formal.variance(reduce=True), ),
    ).subscribe(on_next=actual_result.append)

    assert actual_result == [
        rs.OnCreateMux((1, None)),
        rs.OnCreateMux((2, None)),
        rs.OnNextMux((1, None), approx(np.var(s1))),
        rs.OnCompletedMux((1, None)),
        rs.OnNextMux((2, None), approx(np.var(s2))),
        rs.OnCompletedMux((2, None)),
    ]

예제 #13

def main():
    root = Tk()
    root.title("Rx for Python rocks")
    scheduler = TkinterScheduler(root)

    mousemove = Subject()

    frame = Frame(root, width=600, height=600)

    frame.bind("<Motion>", mousemove.on_next)

    text = 'TIME FLIES LIKE AN ARROW'

    def on_next(info):
        label, ev, i = info
        label.place(x=ev.x + i * 12 + 15, y=ev.y)

    def handle_label(label, i):
        label.config(dict(borderwidth=0, padx=0, pady=0))

        mapper = ops.map(lambda ev: (label, ev, i))
        delayer = ops.delay(i * 0.1)

        return mousemove.pipe(delayer, mapper)

    labeler = ops.flat_map_indexed(handle_label)
    mapper = ops.map(lambda c: Label(frame, text=c))

    rx.from_(text).pipe(mapper, labeler).subscribe(on_next,
                                                   on_error=print,
                                                   scheduler=scheduler)

    frame.pack()
    root.mainloop()

예제 #14

파일: test_multiplex.py 프로젝트: mcorniere/rxsci

def test_multiplex():
    source = [1, 2, 3, 4]
    actual_error = []
    actual_completed = []
    actual_result = []
    mux_actual_result = []

    def on_completed():
        actual_completed.append(True)

    rx.from_(source).pipe(
        rs.ops.multiplex(rx.pipe(ops.do_action(
            mux_actual_result.append), ), ), ).subscribe(
                on_next=actual_result.append,
                on_completed=on_completed,
                on_error=actual_error.append,
            )

    assert actual_error == []
    assert actual_completed == [True]
    assert actual_result == source
    assert mux_actual_result == [
        rs.OnCreateMux((0, )),
        rs.OnNextMux((0, ), 1),
        rs.OnNextMux((0, ), 2),
        rs.OnNextMux((0, ), 3),
        rs.OnNextMux((0, ), 4),
        rs.OnCompletedMux((0, )),
    ]

예제 #15

def test_completion():
    source = [
        rs.OnCreateMux((1, None)),
        rs.OnNextMux((1, None), 1),
        rs.OnNextMux((1, None), 2),
        rs.OnCompletedMux((1, None)),
    ]
    actual_result = []
    actual_completed = []

    rx.from_(source).pipe(
        rs.cast_as_mux_observable(),
        rs.state.with_memory_store(
            rs.ops.tee_map(
                rs.ops.first(),
                rs.ops.last(),
            ), ),
    ).subscribe(on_next=actual_result.append,
                on_completed=lambda: actual_completed.append(True))

    #assert actual_completed == [True]
    assert actual_result == [
        rs.OnCreateMux((1, None)),
        rs.OnNextMux((1, None), (1, 2)),
        rs.OnCompletedMux((1, None)),
    ]

예제 #16

파일: test_lag.py 프로젝트: mcorniere/rxsci

def test_lag_mux():
    source = [
        rs.OnCreateMux((1, None)),
        rs.OnNextMux((1, None), 1),
        rs.OnNextMux((1, None), 2),
        rs.OnNextMux((1, None), 3),
        rs.OnNextMux((1, None), 4),
        rs.OnNextMux((1, None), 5),
        rs.OnNextMux((1, None), 6),
        rs.OnCompletedMux((1, None)),
    ]
    actual_result = []

    rx.from_(source).pipe(
        rs.cast_as_mux_observable(),
        rs.state.with_memory_store(rs.data.lag(2), ),
    ).subscribe(on_next=actual_result.append)

    assert actual_result == [
        rs.OnCreateMux((1, None)),
        rs.OnNextMux((1, None), (1, 1)),
        rs.OnNextMux((1, None), (1, 2)),
        rs.OnNextMux((1, None), (1, 3)),
        rs.OnNextMux((1, None), (2, 4)),
        rs.OnNextMux((1, None), (3, 5)),
        rs.OnNextMux((1, None), (4, 6)),
        rs.OnCompletedMux((1, None)),
    ]

예제 #17

파일: timeflies_qt.py 프로젝트: wensincai/RxPY

def main():
    app = QApplication(sys.argv)
    scheduler = QtScheduler(QtCore)

    window = Window()
    window.show()

    text = 'TIME FLIES LIKE AN ARROW'

    def on_next(info):
        label, (x, y), i = info
        label.move(x + i * 12 + 15, y)
        label.show()

    def handle_label(label, i):
        delayer = ops.delay(i * 0.100)
        mapper = ops.map(lambda xy: (label, xy, i))

        return window.mousemove.pipe(
            delayer,
            mapper,
        )

    labeler = ops.flat_map_indexed(handle_label)
    mapper = ops.map(lambda c: QLabel(c, window))

    rx.from_(text).pipe(
        mapper,
        labeler,
    ).subscribe(on_next, on_error=print, scheduler=scheduler)

    sys.exit(app.exec_())

예제 #18

파일: test_last.py 프로젝트: mcorniere/rxsci

def test_last_mux_empty():
    source = [
        rs.OnCreateMux((1, )),
        rs.OnCreateMux((2, )),
        rs.OnCompletedMux((1, )),
        rs.OnCompletedMux((2, )),
    ]
    actual_error = []
    actual_completed = []
    actual_result = []

    def on_completed():
        actual_completed.append(True)

    rx.from_(source).pipe(
        rs.cast_as_mux_observable(),
        rs.state.with_memory_store(rs.ops.last(), ),
    ).subscribe(
        on_next=actual_result.append,
        on_completed=on_completed,
        on_error=actual_error.append,
    )

    assert actual_error == []
    assert actual_completed == [True]
    assert actual_result == [
        rs.OnCreateMux((1, )),
        rs.OnCreateMux((2, )),
        rs.OnCompletedMux((1, )),
        rs.OnCompletedMux((2, )),
    ]

예제 #19

파일: test_pad.py 프로젝트: maki-nage/rxsci

def test_pad_end_without_store():
    actual_error = []

    rx.from_([1, 2, 3, 4]).pipe(rs.data.pad_end(
        size=3, value=0), ).subscribe(on_error=actual_error.append)

    assert type(actual_error[0]) is ValueError

예제 #20

파일: test_min.py 프로젝트: mcorniere/rxsci

def test_min_mux_reduce():
    source = [
        rs.OnCreateMux((1, None)),
        rs.OnNextMux((1, None), 4),
        rs.OnCreateMux((2, None)),
        rs.OnNextMux((2, None), 8),
        rs.OnNextMux((2, None), 6),
        rs.OnNextMux((1, None), 10),
        rs.OnNextMux((1, None), 3),
        rs.OnNextMux((1, None), 2),
        rs.OnCompletedMux((1, None)),
        rs.OnCompletedMux((2, None)),
    ]
    actual_result = []

    rx.from_(source).pipe(
        rs.cast_as_mux_observable(),
        rs.state.with_memory_store(rs.math.min(reduce=True)),
    ).subscribe(on_next=actual_result.append)

    assert actual_result == [
        rs.OnCreateMux((1, None)),
        rs.OnCreateMux((2, None)),
        rs.OnNextMux((1, None), 2),
        rs.OnCompletedMux((1, None)),
        rs.OnNextMux((2, None), 6),
        rs.OnCompletedMux((2, None)),
    ]

예제 #21

파일: test_assert.py 프로젝트: maki-nage/rxsci

def test_assert_mux_ok():
    source = [
        rs.OnCreateMux((1, None)),
        rs.OnNextMux((1, None), 1),
        rs.OnCreateMux((2, None)),
        rs.OnNextMux((2, None), 2),
        rs.OnNextMux((2, None), 3),
        rs.OnNextMux((1, None), 2),
        rs.OnNextMux((1, None), 3),
        rs.OnCompletedMux((1, None)),
        rs.OnCompletedMux((2, None)),
    ]
    actual_result = []

    rx.from_(source).pipe(rs.cast_as_mux_observable(),
                          rs.ops.assert_(lambda i: i > 0)).subscribe(
                              on_next=actual_result.append)

    assert actual_result == [
        rs.OnCreateMux((1, None)),
        rs.OnNextMux((1, None), 1),
        rs.OnCreateMux((2, None)),
        rs.OnNextMux((2, None), 2),
        rs.OnNextMux((2, None), 3),
        rs.OnNextMux((1, None), 2),
        rs.OnNextMux((1, None), 3),
        rs.OnCompletedMux((1, None)),
        rs.OnCompletedMux((2, None)),
    ]

예제 #22

def test_start_with_without_store():
    actual_error = []

    rx.from_([1, 2, 3, 4]).pipe(rs.ops.start_with([0, -1])).subscribe(
        on_error=actual_error.append, )

    assert type(actual_error[0]) is ValueError

예제 #23

def test_sum_mux():
    source = [
        rs.OnCreateMux((1, None)),
        rs.OnNextMux((1, None), 2),
        rs.OnCreateMux((2, None)),
        rs.OnNextMux((2, None), 8),
        rs.OnNextMux((2, None), 6),
        rs.OnNextMux((1, None), 3),
        rs.OnNextMux((1, None), 10),
        rs.OnNextMux((1, None), 4),
        rs.OnCompletedMux((1, None)),
        rs.OnCompletedMux((2, None)),
    ]

    actual_completed = []
    actual_result = []

    rx.from_(source).pipe(
        rs.cast_as_mux_observable(),
        rs.state.with_memory_store(rs.math.sum(reduce=True), ),
    ).subscribe(on_next=actual_result.append,
                on_completed=lambda: actual_completed.append(True))

    assert actual_completed == [True]
    assert actual_result == [
        rs.OnCreateMux((1, None)),
        rs.OnCreateMux((2, None)),
        rs.OnNextMux((1, None), 19),
        rs.OnCompletedMux((1, None)),
        rs.OnNextMux((2, None), 14),
        rs.OnCompletedMux((2, None)),
    ]

예제 #24

def test_start_with():
    actual_result = []
    source = [
        rs.OnCreateMux((1, )),
        rs.OnNextMux((1, ), 1),
        rs.OnNextMux((1, ), 2),
        rs.OnNextMux((1, ), 3),
        rs.OnNextMux((1, ), 4),
        rs.OnNextMux((1, ), 5),
        rs.OnCompletedMux((1, )),
    ]

    rx.from_(source).pipe(
        rs.cast_as_mux_observable(),
        rs.state.with_memory_store(rs.ops.start_with([-3, -2, -1, 0]), ),
    ).subscribe(on_next=actual_result.append)

    assert actual_result == [
        rs.OnCreateMux((1, )),
        rs.OnNextMux((1, ), -3),
        rs.OnNextMux((1, ), -2),
        rs.OnNextMux((1, ), -1),
        rs.OnNextMux((1, ), 0),
        rs.OnNextMux((1, ), 1),
        rs.OnNextMux((1, ), 2),
        rs.OnNextMux((1, ), 3),
        rs.OnNextMux((1, ), 4),
        rs.OnNextMux((1, ), 5),
        rs.OnCompletedMux((1, )),
    ]

예제 #25

파일: test_distinct_until_changed.py 프로젝트: mcorniere/rxsci

def test_distinct_until_changed_mux():
    source = [
        rs.OnCreateMux((1, )),
        rs.OnNextMux((1, ), 1),
        rs.OnNextMux((1, ), 2),
        rs.OnNextMux((1, ), 2),
        rs.OnNextMux((1, ), 3),
        rs.OnCompletedMux((1, )),
    ]
    actual_result = []

    def on_next(i):
        actual_result.append(i)

    rx.from_(source).pipe(
        rs.cast_as_mux_observable(),
        rs.state.with_memory_store(rs.ops.distinct_until_changed()),
    ).subscribe(on_next)

    assert actual_result == [
        rs.OnCreateMux((1, )),
        rs.OnNextMux((1, ), 1),
        rs.OnNextMux((1, ), 2),
        rs.OnNextMux((1, ), 3),
        rs.OnCompletedMux((1, )),
    ]

예제 #26

파일: test_clip.py 프로젝트: mcorniere/rxsci

def test_clip_mux():
    source = [
        rs.OnCreateMux((1, None)),
        rs.OnNextMux((1, None), 1),
        rs.OnNextMux((1, None), 2),
        rs.OnNextMux((1, None), 3),
        rs.OnNextMux((1, None), 4),
        rs.OnNextMux((1, None), 5),
        rs.OnNextMux((1, None), 6),
        rs.OnCompletedMux((1, None)),
    ]
    actual_result = []

    rx.from_(source).pipe(
        rs.cast_as_mux_observable(),
        rs.data.clip(lower_bound=2,
                     higher_bound=5)).subscribe(on_next=actual_result.append)

    assert actual_result == [
        rs.OnCreateMux((1, None)),
        rs.OnNextMux((1, None), 2),
        rs.OnNextMux((1, None), 2),
        rs.OnNextMux((1, None), 3),
        rs.OnNextMux((1, None), 4),
        rs.OnNextMux((1, None), 5),
        rs.OnNextMux((1, None), 5),
        rs.OnCompletedMux((1, None)),
    ]

예제 #27

파일: test_assert.py 프로젝트: maki-nage/rxsci

def test_assert_mux_fail():
    source = [
        rs.OnCreateMux((1, None)),
        rs.OnNextMux((1, None), 1),
        rs.OnCreateMux((2, None)),
        rs.OnNextMux((2, None), 2),
        rs.OnNextMux((2, None), -1),
        rs.OnNextMux((1, None), 2),
        rs.OnNextMux((1, None), -1),
        rs.OnCompletedMux((1, None)),
        rs.OnCompletedMux((2, None)),
    ]
    actual_result = []
    error = []

    rx.from_(source).pipe(rs.cast_as_mux_observable(),
                          rs.ops.assert_(lambda i: i > 0)).subscribe(
                              on_next=actual_result.append,
                              on_error=error.append,
                          )

    assert actual_result == [
        rs.OnCreateMux((1, None)),
        rs.OnNextMux((1, None), 1),
        rs.OnCreateMux((2, None)),
        rs.OnNextMux((2, None), 2),
    ]
    assert type(error[0]) == ValueError

예제 #28

def test_describe_mux():
    s1 = [random.normalvariate(0.0, 1.0) for _ in range(200)]
    s2 = [random.normalvariate(1.0, 2.0) for _ in range(200)]

    source = [
        rs.OnCreateMux((1 ,None)),
        rs.OnCreateMux((2, None)),
    ]
    source.extend([rs.OnNextMux((1, None), i) for i in s1])
    source.extend([rs.OnNextMux((2, None), i) for i in s2])
    source.extend([
        rs.OnCompletedMux((1, None)),
        rs.OnCompletedMux((2, None)),

    ])

    actual_result = []
    store = rs.state.StoreManager(store_factory=rs.state.MemoryStore)
    rx.from_(source).pipe(
        rs.cast_as_mux_observable(),
        rs.state.with_store(
            store,
            rs.math.dist.update(reduce=True),
        ),
        rs.math.dist.describe(),
    ).subscribe(on_next=actual_result.append)

예제 #29

파일: test_stddev.py 프로젝트: mcorniere/rxsci

def test_stddev():
    source = [random.normalvariate(0.0, 1.0) for _ in range(10)]
    actual_result = []

    rx.from_(source).pipe(rs.math.formal.stddev(reduce=True)).subscribe(
        on_next=actual_result.append)

    assert actual_result[0] == approx(np.std(source))

예제 #30

파일: test_stddev.py 프로젝트: mcorniere/rxsci

def test_stddev_on_empty_observable():
    source = []
    actual_result = []

    rx.from_(source).pipe(rs.math.formal.stddev(reduce=True)).subscribe(
        on_next=actual_result.append)

    assert actual_result[0] == 0.0

예제 #31

파일: test_stddev.py 프로젝트: mcorniere/rxsci

def test_stddev_completed():
    source = [random.normalvariate(0.0, 1.0) for _ in range(10)]
    actual_completed = []

    rx.from_(source).pipe(rs.math.formal.stddev()).subscribe(
        on_completed=lambda: actual_completed.append(True))

    assert actual_completed == [True]

예제 #32

파일: flatmap.py 프로젝트: MichaelSchneeberger/RxPY

 def projection(x, i):
     mapper_result = mapper(x) if mapper else mapper_indexed(x, i)
     if isinstance(mapper_result, collections.abc.Iterable):
         result = from_(mapper_result)
     else:
         result = from_future(mapper_result) if is_future(
             mapper_result) else mapper_result
     return result

예제 #33

파일: timeflies_gtk.py 프로젝트: ReactiveX/RxPY

def main():
    scheduler = GtkScheduler()
    scrolled_window = Gtk.ScrolledWindow()

    window = Window()
    window.connect("delete-event", Gtk.main_quit)

    container = Gtk.Fixed()

    scrolled_window.add(container)
    window.add(scrolled_window)
    text = 'TIME FLIES LIKE AN ARROW'

    def on_next(info):
        label, (x, y), i = info
        container.move(label, x + i*12 + 15, y)
        label.show()

    def handle_label(label, i):
        delayer = ops.delay(i*0.100)
        mapper = ops.map(lambda xy: (label, xy, i))

        return window.mousemove.pipe(
            delayer,
            mapper,
        )

    def make_label(char):
        label = Gtk.Label(label=char)
        container.put(label, 0, 0)
        label.hide()
        return label

    mapper = ops.map(make_label)
    labeler = ops.flat_map_indexed(handle_label)

    rx.from_(text).pipe(
        mapper,
        labeler,
    ).subscribe(on_next, on_error=print, scheduler=scheduler)

    window.show_all()

    Gtk.main()

예제 #34

파일: test_fromiterable.py 프로젝트: ReactiveX/RxPY

    def test_double_subscribe_to_iterable(self):
        iterable_finite = [1, 2, 3]
        scheduler = TestScheduler()
        obs = rx.from_(iterable_finite)

        results = scheduler.start(lambda: rx.concat(obs, obs))

        assert results.messages == [
            on_next(200, 1), on_next(200, 2), on_next(200, 3),
            on_next(200, 1), on_next(200, 2), on_next(200, 3),
            on_completed(200)]

예제 #35

파일: timeflies_wx.py 프로젝트: ReactiveX/RxPY

def main():
    app = wx.App()
    scheduler = WxScheduler(wx)

    app.TopWindow = frame = Frame()
    frame.Show()

    text = 'TIME FLIES LIKE AN ARROW'

    def on_next(info):
        label, (x, y), i = info
        label.Move(x + i*12 + 15, y)
        label.Show()

    def handle_label(label, i):
        delayer = ops.delay(i * 0.100)
        mapper = ops.map(lambda xy: (label, xy, i))

        return frame.mousemove.pipe(
            delayer,
            mapper,
            )

    def make_label(char):
        label = wx.StaticText(frame, label=char)
        label.Hide()
        return label

    mapper = ops.map(make_label)
    labeler = ops.flat_map_indexed(handle_label)

    rx.from_(text).pipe(
        mapper,
        labeler,
    ).subscribe(on_next, on_error=print, scheduler=scheduler)

    frame.Bind(wx.EVT_CLOSE, lambda e: (scheduler.cancel_all(), e.Skip()))
    app.MainLoop()

예제 #36

파일: timeflies_tkinter.py 프로젝트: MichaelSchneeberger/RxPY

def main():
    root = Tk()
    root.title("Rx for Python rocks")
    scheduler = TkinterScheduler(root)

    mousemove = Subject()

    frame = Frame(root, width=600, height=600)

    frame.bind("<Motion>", mousemove.on_next)

    text = 'TIME FLIES LIKE AN ARROW'

    def on_next(info):
        label, ev, i = info
        label.place(x=ev.x + i*12 + 15, y=ev.y)

    def handle_label(label, i):
        label.config(dict(borderwidth=0, padx=0, pady=0))

        mapper = ops.map(lambda ev: (label, ev, i))
        delayer = ops.delay(i*0.1)

        return mousemove.pipe(
            delayer,
            mapper
        )

    labeler = ops.flat_map_indexed(handle_label)
    mapper = ops.map(lambda c: Label(frame, text=c))

    rx.from_(text).pipe(
        mapper,
        labeler
    ).subscribe(on_next, on_error=print, scheduler=scheduler)

    frame.pack()
    root.mainloop()

예제 #37

파일: test_blocking.py 프로젝트: MichaelSchneeberger/RxPY

 def test_run_from(self):
     result = rx.from_([1, 2, 3]).run()
     assert result == 3

예제 #38

파일: test_blocking.py 프로젝트: MichaelSchneeberger/RxPY

 def test_run_from_first(self):
     result = rx.from_([1, 2, 3]).pipe(ops.first()).run()
     assert result == 1

예제 #39

파일: test_tofuture.py 프로젝트: ReactiveX/RxPY

 async def go():
     nonlocal result
     source = rx.from_([40, 41, 42])
     result = await source

예제 #40

파일: timer.py 프로젝트: MichaelSchneeberger/RxPY

import concurrent.futures
import time

import rx
from rx import operators as ops

seconds = [5, 1, 2, 4, 3]


def sleep(tm):
    time.sleep(tm)
    return tm


def output(result):
    print('%d seconds' % result)

with concurrent.futures.ProcessPoolExecutor(5) as executor:
    rx.from_(seconds).pipe(
        ops.flat_map(lambda s: executor.submit(sleep, s))
    ).subscribe(output)

# 1 seconds
# 2 seconds
# 3 seconds
# 4 seconds
# 5 seconds

예제 #41

파일: test_fromiterable.py 프로젝트: ReactiveX/RxPY

 def create():
     return rx.from_(iterable_finite)