def test_Retry_Observable_Throws():
    scheduler1 = TestScheduler()
    xs = Observable.return_value(1, scheduler1).retry()
    xs.subscribe(lambda x: _raise('ex'))
    
    try:
        return scheduler1.start()
    except RxException:
        pass

    scheduler2 = TestScheduler()
    ys = Observable.throw_exception('ex', scheduler2).retry()
    d = ys.subscribe(on_error=lambda ex: _raise('ex'))
    
    scheduler2.schedule_absolute(210, lambda: d.dispose())
    
    scheduler2.start()
    scheduler3 = TestScheduler()
    zs = Observable.return_value(1, scheduler3).retry()
    zs.subscribe(on_completed=lambda: _raise('ex'))
    
    try:
        return scheduler3.start()
    except RxException:
        pass

    xss = Observable.create(lambda o: _raise('ex')).retry()
    try:
        return xss.subscribe()
    except RxException:
        pass
Beispiel #2
0
 def projection(x, i):
     selector_result = selector(x, i)
     if isinstance(selector_result, collections.Iterable):
         result = Observable.from_(selector_result)
     else:
         result = Observable.from_future(selector_result)
     return result
def test_repeat_observable_repeat_count_throws():
    scheduler1 = TestScheduler()
    xs = Observable.return_value(1, scheduler1).repeat(3)
    xs.subscribe(lambda x: _raise('ex'))
    
    try:
        return scheduler1.start()
    except RxException:
        pass

    scheduler2 = TestScheduler()
    ys = Observable.throwException('ex1', scheduler2).repeat(3)
    ys.subscribe(lambda ex: _raise('ex2'))
    
    try:
        return scheduler2.start()
    except RxException:
        pass

    scheduler3 = TestScheduler()
    zs = Observable.return_value(1, scheduler3).repeat(100)
    d = zs.subscribe(on_complete=lambda: _raise('ex3'))
    
    scheduler3.schedule_absolute(10, lambda: d.dispose())
    
    scheduler3.start()
    xss = Observable.create(lambda o: _raise('ex4')).repeat(3)
    try:
        return xss.subscribe()
    except RxException:
        pass
Beispiel #4
0
def case(cls, selector, sources, default_source=None, scheduler=None):
    """Uses selector to determine which source in sources to use.
    There is an alias 'switch_case'.

    Example:
    1 - res = rx.Observable.case(selector, { '1': obs1, '2': obs2 })
    2 - res = rx.Observable.case(selector, { '1': obs1, '2': obs2 }, obs0)
    3 - res = rx.Observable.case(selector, { '1': obs1, '2': obs2 },
                                 scheduler=scheduler)

    Keyword arguments:
    :param types.FunctionType selector: The function which extracts the value
        for to test in a case statement.
    :param list sources: A object which has keys which correspond to the case
        statement labels.
    :param Observable default_source: The observable sequence or Promise that
        will be run if the sources are not matched. If this is not provided, it
        defaults to rx.Observabe.empty with the specified scheduler.

    :returns: An observable sequence which is determined by a case statement.
    :rtype: Observable
    """

    default_source = default_source or Observable.empty(scheduler=scheduler)

    def factory():
        try:
            result = sources[selector()]
        except KeyError:
            result = default_source

        result = Observable.from_future(result)

        return result
    return Observable.defer(factory)
Beispiel #5
0
def main_reactive():
    ll = _load()
    mm = np.array(ll)

    def diagonal(n, m, a):
        (n_axis, m_axis) = a
        res = []
        try:
            for x in range(4):
                res.append(mm[n + x * n_axis][m + x * m_axis])
            return res
        except IndexError:
            return 0,

    axes = (
        (0, 1),
        (1, 0),
        (1, -1),
        (1, 1),
    )

    Observable.from_(product(range(mm.shape[0]), range(mm.shape[1]), axes)). \
        map(lambda t: diagonal(*t)) \
        .map(mul_many) \
        .max() \
        .subscribe(print)
Beispiel #6
0
    def if_then(cls, condition, then_source, else_source=None, scheduler=None):
        """Determines whether an observable collection contains values. 
        
        Example:
        1 - res = rx.Observable.if(condition, obs1)
        2 - res = rx.Observable.if(condition, obs1, obs2)
        3 - res = rx.Observable.if(condition, obs1, scheduler=scheduler)

        Keyword parameters:
        condition -- {Function} The condition which determines if the 
            then_source or else_source will be run.
        then_source -- {Observable} The observable sequence or Promise that 
            will be run if the condition function returns true.
        else_source -- {Observable} [Optional] The observable sequence or 
            Promise that will be run if the condition function returns False. 
            If this is not provided, it defaults to Rx.Observabe.Empty
        scheduler -- [Optional] Scheduler to use.
   
        Returns an observable {Observable} sequence which is either the 
        then_source or else_source."""
        
        else_source = else_source or Observable.empty(scheduler=scheduler)
        
        then_source = Observable.from_future(then_source)
        else_source = Observable.from_future(else_source)
        
        def factory():
            
            return then_source if condition() else else_source
        return Observable.defer(factory)
Beispiel #7
0
    def test_create_with_disposable_observer_throws(self):
        def subscribe1(o):
            o.on_next(1)
            return Disposable.empty()

        def on_next(x):
            _raise('ex')

        try:
            return Observable.create_with_disposable(subscribe1).subscribe(on_next)
        except RxException:
            pass
        
        def subscribe2(o):
            o.on_error('exception')
            return Disposable.empty()

        try:
            return Observable.create_with_disposable(subscribe2).subscribe(on_error=lambda ex: _raise('ex'))
        except RxException:
            pass
        
        def subscribe3(o):
            o.on_completed()
            return Disposable.empty()

        try:
            return Observable.create_with_disposable(subscribe3).subscribe(on_completed=_raise('ex'))
        except RxException:
            pass
Beispiel #8
0
    def subscribe(observer):
        active_plans = []
        external_subscriptions = {}

        def on_error(err):
            for v in external_subscriptions.values():
                v.on_error(err)
            observer.on_error(err)

        out_observer = AnonymousObserver(observer.on_next, on_error, observer.on_completed)

        def deactivate(active_plan):
            active_plans.remove(active_plan)
            if not len(active_plans):
                observer.on_completed()
        try:
            for plan in plans:
                active_plans.append(plan.activate(external_subscriptions, 
                                                  out_observer, deactivate))
        except Exception as ex:
            Observable.throw(ex).subscribe(observer)

        group = CompositeDisposable()
        for join_observer in external_subscriptions.values():
            join_observer.subscribe()
            group.add(join_observer)

        return group
Beispiel #9
0
async def run(sel, loop):
    def create_socket_observable(port, observer):
        sock = socket.socket()
        sock.bind(('localhost', port))
        sock.listen(100)
        sock.setblocking(False)
        sel.register(
            sock,
            selectors.EVENT_READ,
            partial(accept, observer, sel)
        )

    socket_1234 = Observable.create(
        partial(create_socket_observable, 1234)
    )
    socket_1235 = Observable.create(
        partial(create_socket_observable, 1235)
    )

    source = socket_1234.merge(socket_1235).share()

    source.subscribe(
        logging.info
    )

    source.where(
        lambda msg: "error" in msg
    ).subscribe(
        logging.error
    )
Beispiel #10
0
 def create():
     return xs.join(ys,
         lambda x: Observable.timer(x.interval, scheduler=scheduler),
         lambda y: Observable.timer(y.interval, scheduler=scheduler).select_many(
             Observable.throw_exception(ex) if y.value == "tin" else Observable.empty()),
         lambda x, y: str(x.value) + y.value
     )
Beispiel #11
0
        def create3():
            Observable.create(throw_error).transduce(
                compose(
                    filtering(even), mapping(mul10))
                ).subscribe()

            self.assertRaises(RxException, create3)
Beispiel #12
0
    def __init__(self, scheduler, messages):
        log.debug("HotObservable.__init__()")
        Observable.__init__(self, self._subscribe)

        self.scheduler = scheduler
        self.messages = messages
        self.subscriptions = AssertList()
        self.observers = []

        observable = self

        def get_action(notification):
            def action(scheduler, state):
                for observer in observable.observers[:]:
                    notification.accept(observer)
                return Disposable.empty()

            return action

        for message in self.messages:
            notification = message.value

            # Warning: Don't make closures within a loop
            action = get_action(notification)
            scheduler.schedule_absolute(message.time, action)
Beispiel #13
0
def combine_frames(*frames):
    result = Observable.combine_latest(
        frames[0], frames[1],
        lambda x, y: "{} {}".format(x, y))
    for f in frames[2:]:
        result = Observable.combine_latest(
            result, f, lambda x, y: "{} {}".format(x, y))
    return result
Beispiel #14
0
 def scan(self):
     self.is_armed = not self.bluetooth.is_there_friendly_devices_nearby()
     self.blueStream.on_next(self.is_armed)
     # TODO: decouple sms alert
     if self.is_armed:
         Observable.just(True).subscribe(SmsObserver('system armed'))
     else:
         Observable.just(True).subscribe(SmsObserver('system disarmed'))
Beispiel #15
0
async def run(loop):
    Observable.timer(
        0,
        1000,
        scheduler=AsyncIOScheduler()
    ).tap(
        logging.info
    )
Beispiel #16
0
 def __sense_environment(self):
     Observable.from_(self.sensors). \
         subscribe(
         lambda sensor: self.working_memory.append(Fact(sensor=sensor.name, data=sensor.exec(), binding=sensor.binding))
     )
     Observable.from_(self.working_memory). \
         subscribe(
         lambda fact: setattr(self.world_state, fact.binding, fact.data.output)
     )
Beispiel #17
0
 def test_concat_never_never(self):
     scheduler = TestScheduler()
     e1 = Observable.never()
     e2 = Observable.never()
     
     def create():
         return e1.concat(e2)
     results = scheduler.start(create)
     results.messages.assert_equal()
Beispiel #18
0
 def on_next(self, img_lines):
     """Draw the detected lines on top of the image and display the result"""
     img, lines = img_lines
     green = (0, 255, 0)
     Observable.from_(lines).subscribe(
         lambda line: cv2.line(img, line.a, line.b, green),  # on_next
         lambda error: print(error),                         # on_error
         lambda: self.display(img)                           # on_completed
     )
Beispiel #19
0
    def test_let_calls_function_immediately(self):
        called = [False]

        def func(x):
            called[0] = True
            return x

        Observable.empty().let_bind(func)
        assert(called[0])
Beispiel #20
0
def main():
    # start bluetooth scanning in the background
    new_bluetooth_thread = threading.Thread(target=scanner.watch)
    new_bluetooth_thread.daemon = True  # stop if the program exits
    new_bluetooth_thread.start()

    # start listening door tag
    new_doortag_thread = threading.Thread(target=door_listener.listen)
    new_doortag_thread.daemon = True  # stop if the program exits
    new_doortag_thread.start()

    # light on if pir detection or door opened
    door_listener.openDoorStream.merge(pirs.pirStream)\
        .subscribe(LightOnObserver())

    # light of after x second with no event
    door_listener.openDoorStream.merge(pirs.pirStream).debounce(parameters.lightup_duration*1000)\
        .subscribe(LightOffObserver())

    # send sms when unknown presence is detected
    pirs.pirStream.pausable(scanner.blueStream)\
        .throttle_first(parameters.sms_min_interval_between_sms*1000).subscribe(SmsObserver('presence detected'))

    # send sms on open door
    door_listener.openDoorStream.pausable(scanner.blueStream)\
        .throttle_first(parameters.sms_min_interval_between_sms*1000).subscribe(SmsObserver('door open'))

    # send sms on door vibe
    door_listener.vibeDoorStream.pausable(scanner.blueStream)\
        .throttle_first(parameters.sms_min_interval_between_sms*1000).subscribe(SmsObserver('door vibe'))

    # turn siren when unknown presence is detected with both open door and pir
    # TODO: put timer duration in a variable
    door_listener.openDoorStream\
        .join(pirs.pirStream,
              lambda x: Observable.timer(15*1000),
              lambda x: Observable.timer(15*1000),
              lambda x, y: True)\
        .pausable(scanner.blueStream).subscribe(SirenClientObserver())

    # take photo if pir detection or door opened or door vibe
    # TODO: more test on this
    # TODO: put camera interval in a variable
    door_listener.openDoorStream.merge(door_listener.vibeDoorStream).merge(pirs.pirStream) \
        .select_many(Observable.interval(1000).take(20)).throttle_first(1000) \
        .pausable(scanner.blueStream) \
        .subscribe(CameraObserver())

    # if the subscriber doesn't get the first blueStream event they will be paused by default
    # TODO:  use a replay here instead of the following workaround
    scanner.scan()

    while True:
        # TODO: use a infinit loop instead
        # TODO: manage interruption
        time.sleep(1)
Beispiel #21
0
 def test_skip_until_never_never(self):
     scheduler = TestScheduler()
     l = Observable.never()
     r = Observable.never()
     
     def create():
         return l.skip_until(r)
     
     results = scheduler.start(create)
     results.messages.assert_equal()
Beispiel #22
0
    def test_amb_never2(self):
        scheduler = TestScheduler()
        l = Observable.never()
        r = Observable.never()

        def create():
            return l.amb(r)

        results = scheduler.start(create)
        results.messages.assert_equal()
Beispiel #23
0
    def test_zip_never_never(self):
        scheduler = TestScheduler()
        o1 = Observable.never()
        o2 = Observable.never()

        def create():
            return o1.zip(o2, lambda x, y: x + y)

        results = scheduler.start(create)
        results.messages.assert_equal()
Beispiel #24
0
    def test_combine_latest_never_never(self):
        scheduler = TestScheduler()
        e1 = Observable.never()
        e2 = Observable.never()

        def create():
            return e1.combine_latest(e2, lambda x, y: x + y)

        results = scheduler.start(create)
        results.messages.assert_equal()
Beispiel #25
0
    def test_merge_never2(self):
        scheduler = TestScheduler()
        n1 = Observable.never()
        n2 = Observable.never()

        def create():
            return Observable.merge(scheduler, n1, n2)

        results = scheduler.start(create)
        results.messages.assert_equal()
Beispiel #26
0
    def test_merge_empty2(self):
        scheduler = TestScheduler()
        e1 = Observable.empty()
        e2 = Observable.empty()

        def create():
            return Observable.merge(scheduler, e1, e2)

        results = scheduler.start(create)
        results.messages.assert_equal(on_completed(203))
Beispiel #27
0
    def test_for_each_index_return(self):
        lstX = []
        lstI = []

        def action(x, i):
            lstX.append(x)
            lstI.append(i)

        Observable.return_value(42).to_blocking().for_each(action)
        assert(lstX == [42])
        assert(lstI == [0])
Beispiel #28
0
    def test_for_each_index_some_data(self):
        lstX = []
        lstI = []

        def action(x, i):
            lstX.append(x)
            lstI.append(i)

        Observable.range(10, 10).to_blocking().for_each(action)
        assert(lstX == [x for x in range(10, 20)])
        assert(lstI == [x for x in range(10)])
Beispiel #29
0
    def test_amb_never3(self):
        scheduler = TestScheduler()
        n1 = Observable.never()
        n2 = Observable.never()
        n3 = Observable.never()

        def create():
            return Observable.amb(n1, n2, n3)

        results = scheduler.start(create)
        results.messages.assert_equal()
Beispiel #30
0
        def create():
            def result_selector(x, y):
                if x.value >= 0:
                    raise Exception(ex)
                else:
                    return str(x.value) + y.value

            return xs.join(ys,
                lambda x: Observable.timer(x.interval, scheduler=scheduler),
                lambda y: Observable.timer(y.interval, scheduler=scheduler),
                result_selector,
                )
Beispiel #31
0
 def closing():
     curr = window[0]
     window[0] += 1
     return Observable.timer(curr * 100, scheduler=scheduler)
Beispiel #32
0
 def closings():
     w = window[0]
     window[0] += 1
     return Observable.timer(w * 100, scheduler=scheduler)
Beispiel #33
0
 def closing(x):
     return Observable.timer(x, scheduler=scheduler)
from __future__ import print_function
from rx import Observable, Observer

Observable.from_(["Alpha", "Beta", "Gamma", "Delta", "Epsilon"]) \
    .map(lambda s: len(s)) \
    .distinct() \
    .subscribe(lambda i: print(i))


Observable.from_(["Alpha", "Beta", "Gamma", "Delta", "Epsilon"]) \
    .distinct(lambda s: len(s)) \
    .subscribe(lambda i: print(i))
Beispiel #35
0
 def create():
     return Observable.of(scheduler=scheduler)
from rx import Observable

numbers = Observable.from_([1, 2, 3, 4])
characters = Observable.from_(['a', 'b', 'c', 'd', 'e'])

Observable.zip_list(characters, numbers).subscribe(
    on_next=lambda i: print("on_next {}".format(i)),
    on_error=lambda e: print("on_error: {}".format(e)),
    on_completed=lambda: print("on_completed"))
 def create2():
     Observable.empty().transduce(
         compose(filtering(even),
                 mapping(mul10))).subscribe(noop, noop, throw_error)
Beispiel #38
0
    def sequence_equal(self, second, comparer=None):
        """Determines whether two sequences are equal by comparing the
        elements pairwise using a specified equality comparer.

        1 - res = source.sequence_equal([1,2,3])
        2 - res = source.sequence_equal([{ "value": 42 }], lambda x, y: x.value == y.value)
        3 - res = source.sequence_equal(Observable.return_value(42))
        4 - res = source.sequence_equal(Observable.return_value({ "value": 42 }), lambda x, y: x.value == y.value)

        second -- Second observable sequence or array to compare.
        comparer -- [Optional] Comparer used to compare elements of both sequences.

        Returns an observable sequence that contains a single element which
        indicates whether both sequences are of equal length and their
        corresponding elements are equal according to the specified equality
        comparer.
        """

        first = self
        comparer = comparer or default_comparer

        if isinstance(second, collections.Iterable):
            second = Observable.from_iterable(second)

        def subscribe(observer):
            donel = [False]
            doner = [False]
            ql = []
            qr = []

            def on_next1(x):
                if len(qr) > 0:
                    v = qr.pop(0)
                    try:
                        equal = comparer(v, x)
                    except Exception as e:
                        observer.on_error(e)
                        return

                    if not equal:
                        observer.on_next(False)
                        observer.on_completed()

                elif doner[0]:
                    observer.on_next(False)
                    observer.on_completed()
                else:
                    ql.append(x)

            def on_completed1():
                donel[0] = True
                if not len(ql):
                    if len(qr) > 0:
                        observer.on_next(False)
                        observer.on_completed()
                    elif doner[0]:
                        observer.on_next(True)
                        observer.on_completed()

            def on_next2(x):
                if len(ql) > 0:
                    v = ql.pop(0)
                    try:
                        equal = comparer(v, x)
                    except Exception as exception:
                        observer.on_error(exception)
                        return

                    if not equal:
                        observer.on_next(False)
                        observer.on_completed()

                elif donel[0]:
                    observer.on_next(False)
                    observer.on_completed()
                else:
                    qr.append(x)

            def on_completed2():
                doner[0] = True
                if not len(qr):
                    if len(ql) > 0:
                        observer.on_next(False)
                        observer.on_completed()
                    elif donel[0]:
                        observer.on_next(True)
                        observer.on_completed()

            subscription1 = first.subscribe(on_next1, observer.on_error,
                                            on_completed1)
            subscription2 = second.subscribe(on_next2, observer.on_error,
                                             on_completed2)
            return CompositeDisposable(subscription1, subscription2)

        return AnonymousObservable(subscribe)
from rx import Observable

observable = Observable.from_([1, 2])
other_observable = Observable.from_([3, 4])
Observable.concat(observable, other_observable) \
  .subscribe(on_next=lambda n: print(n))

# O/P
# (1, 'LITE Industrial', 'Southwest', '729 Ravine Way', 'Irving', 'TX', 75014)
# (3, 'Re-Barre Construction', 'Southwest', '9043 Windy Dr', 'Irving', 'TX', 75032)
# (5, 'Marsh Lane Metal Works', 'Southeast', '9143 Marsh Ln', 'Avondale', 'LA', 79782)
from __future__ import print_function
from rx import Observable



foo = Observable.interval(100).take(5)

foo.debounce(1000).subscribe(lambda s: print(s), on_completed=lambda : print("DONE"))



input("ok\n")
Beispiel #41
0
from rx import Observable

source1 = Observable.interval(1000).map(lambda s: "Source 1: {0}".format(s))
source2 = Observable.interval(500).map(lambda s: "Source 2: {0}".format(s))
source3 = Observable.interval(2000).map(lambda s: "Source 3: {0}".format(s))

Observable.merge(source1, source2, source3) \
    .subscribe(lambda s: print(s))

input("Press key to quit\nq")
Beispiel #42
0
def read_request(link):
    f = urlopen(link)

    return Observable.from_(f) \
        .map(lambda s: s.decode("gbk").strip())
Beispiel #43
0
'''
获取新浪的美股接口数据,并打印出股票名和价格
'''
from rx import Observable, Observer
from urllib.request import urlopen


def read_request(link):
    f = urlopen(link)

    return Observable.from_(f) \
        .map(lambda s: s.decode("gbk").strip())


codes = ["usr_aapl", "usr_fb", "usr_goog", "usr_baba"]
source = Observable.from_(codes)\
    .map(lambda s: "http://hq.sinajs.cn/list={0}".format(s))\
    .flat_map(lambda s: read_request(s)) \
    .map(lambda s: s.split('"')[1]) \
    .filter(lambda l: l != "") \
    .map(lambda s: s.split(","))\
    .map(lambda s: "股票:{0}           价格:{1}".format(s[0], s[1]))

source.subscribe(on_next=lambda s: print(s))
source.count().subscribe(
    on_next=lambda s: print("count=", s),
    on_completed=lambda: print("network data source Done!\n"))
from rx import Observable

source1 = Observable.interval(1000).map(lambda i: "Source 1: {0}".format(i))
source2 = Observable.interval(500).map(lambda i: "Source 2: {0}".format(i))
source3 = Observable.interval(300).map(lambda i: "Source 3: {0}".format(i))

Observable.from_([source1,source2,source3]) \
    .merge_all() \
    .subscribe(lambda s: print(s))

# keep application alive until user presses a key
input("Press any key to quit\n")
from rx import Observable

numbers = Observable.from_([1, 2, 3])
pub_numbers = numbers.publish()
pub_numbers.connect()

pub_numbers.subscribe(on_next=lambda i: print("item: {}".format(i)),
                      on_error=lambda e: print("error: {}".format(e)),
                      on_completed=lambda: print("completed"))

pub_numbers.subscribe(on_next=lambda i: print("item: {}".format(i)),
                      on_error=lambda e: print("error: {}".format(e)),
                      on_completed=lambda: print("completed"))
Beispiel #46
0
 def create():
     return Observable.throw_exception(
         ex, scheduler).time_interval(scheduler)
Beispiel #47
0
def observable_window_with_openings(self, window_openings,
                                    window_closing_selector):
    return window_openings.group_join(self, window_closing_selector,
                                      lambda _: Observable.empty(),
                                      lambda _, window: window)
Beispiel #48
0
    def test_of_empty(self):
        results = []

        Observable.of().subscribe_(results.append)

        assert (len(results) == 0)
 def create():
     Observable.throw_exception(RxException()).transduce(
         compose(filtering(even),
                 mapping(mul10))).subscribe(noop, throw_error)
Beispiel #50
0
    def test_of(self):
        results = []

        Observable.of(1, 2, 3, 4, 5).subscribe_(results.append)

        assert (str([1, 2, 3, 4, 5]) == str(results))
Beispiel #51
0
 def create():
     return Observable.empty(scheduler).time_interval(scheduler)
Beispiel #52
0
 def create():
     return Observable.amb(n1, n2, n3)
Beispiel #53
0
 def resolve_count_seconds(root, info, up_to=5):
     return (Observable.interval(1000).map(
         lambda i: "{0}".format(i)).take_while(lambda i: int(i) <= up_to))
Beispiel #54
0
 def create():
     return Observable.never().time_interval(scheduler)
Beispiel #55
0
from rx import Observable

if __name__ == '__main__':

    Observable.from_(range(2000)).buffer(Observable.interval(0.1)).subscribe(
        lambda buffer: print('#', len(buffer)))
Beispiel #56
0
 def resolve_random_int(root, info):
     return (Observable.interval(1000).map(lambda i: RandomType(
         seconds=i, random_int=random.randint(0, 500))))
Beispiel #57
0


def word_counter(file_name):

    # count words using `group_by()`
    # tuple the word with the count
    return words_from_file(file_name) \
        .group_by(lambda word: word) \
        .flat_map(lambda grp: grp.count().map(lambda ct: (grp.key, ct)))


# composes the above word_counter() into a dict
def word_counter_as_dict(file_name):
    return word_counter(file_name).to_dict(lambda t: t[0], lambda t: t[1])


# Schedule to create a word count dict every three seconds an article
# But only re-print if text is edited and word counts change

article_file = "bbc_news_article.txt"

# create a dict every three seconds, but only push if it changed
Observable.interval(3000) \
    .flat_map(lambda i: word_counter_as_dict(article_file))
    .distinct_until_changed() \
    .subscribe(lambda word_ct_dict: print(word_ct_dict))

# Keep alive until user presses any key
input("Starting, press any key to quit\n")
Beispiel #58
0
 def closing():
     return Observable.throw_exception(ex, scheduler=scheduler)
Beispiel #59
0
 def create():
     return Observable.of(1, 2, 3, 4, 5)
Beispiel #60
0
#!/usr/bin/env python3

import json

from rx import Observable
import APIReaderTelegram as Telegram


def is_message_f(element):
    return element['message']['text'] == "f"


def pretty_print(element):
    print(json.dumps(element, indent=4))


messages = Observable.from_(Telegram.get_iterable())
messages.filter(is_message_f).subscribe(pretty_print)