def _lag1(source): def on_subscribe(observer, scheduler): state = None def on_next(i): nonlocal state if type(i) is rs.OnNextMux: iprev = i.store.get_state(state, i.key) if iprev is rs.state.markers.STATE_NOTSET: iprev = i.item ii = (iprev, i.item) i.store.set_state(state, i.key, i.item) observer.on_next(i._replace(item=ii)) elif type(i) is rs.OnCreateMux: i.store.add_key(state, i.key) observer.on_next(i) elif type(i) is rs.OnCompletedMux or type(i) is rs.OnErrorMux: i.store.del_key(state, i.key) observer.on_next(i) elif type(i) is rs.state.ProbeStateTopology: state = i.topology.create_state(name='lag1', data_type='obj') observer.on_next(i) else: observer.on_next(i) return source.subscribe(on_next=on_next, on_completed=observer.on_completed, on_error=observer.on_error, scheduler=scheduler) return rs.MuxObservable(on_subscribe)
def _demux(source): def on_subscribe(observer, scheduler): def on_next(i): if type(i) is rs.OnNextMux: observer.on_next(i._replace(key=i.key[1])) elif type(i) is rs.OnErrorMux: observer.on_error(i.error) ''' elif type(i) is rs.OnCreateMux: observer.on_next(rs.OnCreateMux(i.key[1])) elif type(i) is rs.OnCompletedMux: observer.on_next(rs.OnCompletedMux(i.key[1])) else: observer.on_next(TypeError("flatten_aggregate: unknow item type: {}".format(type(i)))) ''' def on_next_outer(i): observer.on_next(i) disposable = CompositeDisposable() disposable.add( outer_group.subscribe( on_next=on_next_outer, scheduler=scheduler, )) disposable.add( source.subscribe( on_next=on_next, on_completed=observer.on_completed, on_error=observer.on_error, scheduler=scheduler, )) return disposable return rs.MuxObservable(on_subscribe)
def _do_action_mux(source): def on_subscribe(observer, scheduler): def _on_next(i): if type(i) is rs.OnNextMux: if on_next is not None: on_next(i.item) elif type(i) is rs.OnErrorMux: if on_error is not None: on_error(i.error) elif type(i) is rs.OnCompletedMux: if on_completed is not None: on_completed(i.key) elif type(i) is rs.OnCreateMux: if on_create is not None: on_create(i.key) observer.on_next(i) def _on_error(e): if on_error is not None: on_error(e) observer.on_error(e) def _on_completed(): if on_completed is not None: on_completed(None) observer.on_completed() return source.subscribe(on_next=_on_next, on_completed=_on_completed, on_error=_on_error, scheduler=scheduler) return rs.MuxObservable(on_subscribe)
def _first(source): def on_subscribe(observer, scheduler): state = None def on_next(i): nonlocal state if type(i) is rs.OnNextMux: value = i.store.get_state(state, i.key) if value is False: observer.on_next(i) i.store.set_state(state, i.key, True) elif type(i) is rs.OnCreateMux: i.store.add_key(state, i.key) observer.on_next(i) elif type(i) is rs.OnCompletedMux: observer.on_next(i) i.store.del_key(state, i.key) elif type(i) is rs.state.ProbeStateTopology: state = i.topology.create_state(name='first', data_type=bool, default_value=False) observer.on_next(i) else: observer.on_next(i) return source.subscribe(on_next=on_next, on_completed=observer.on_completed, on_error=observer.on_error, scheduler=scheduler) return rs.MuxObservable(on_subscribe)
def _scan(source): def on_subscribe(observer, scheduler): state = None def on_next(i): nonlocal state if type(i) is rs.OnNextMux: try: value = i.store.get_state(state, i.key) if value is rs.state.markers.STATE_NOTSET: value = seed() if callable( seed) else copy.deepcopy(seed) acc = accumulator(value, i.item) i.store.set_state(state, i.key, acc) if reduce is False: observer.on_next(rs.OnNextMux(i.key, acc, i.store)) except Exception as e: observer.on_next(rs.OnErrorMux(i.key, e, i.store)) elif type(i) is rs.OnCreateMux: i.store.add_key(state, i.key) observer.on_next(i) elif type(i) is rs.OnCompletedMux: if reduce is True: value = i.store.get_state(state, i.key) if value is rs.state.markers.STATE_NOTSET: value = seed() if callable( seed) else copy.deepcopy(seed) observer.on_next(rs.OnNextMux(i.key, value, i.store)) observer.on_next(i) i.store.del_key(state, i.key) elif type(i) is rs.OnErrorMux: observer.on_next(i) i.store.del_key(state, i.key) elif type(i) is rs.state.ProbeStateTopology: state = i.topology.create_state(name='scan', data_type=type(seed)) observer.on_next(i) else: observer.on_next(i) def on_completed(): #if reduce is True: # for key, value, is_set in i.store.iterate_state(state): # if not is_set: # value = seed() if callable(seed) else copy.deepcopy(seed) # observer.on_next(rs.OnNextMux(key, value)) # observer.on_next(rs.OnCompletedMux(key)) #state.clear() observer.on_completed() return source.subscribe(on_next=on_next, on_completed=on_completed, on_error=observer.on_error, scheduler=scheduler) return rs.MuxObservable(on_subscribe)
def _group_by(source): def on_subscribe(observer, scheduler): state = None def on_next(i): nonlocal state if type(i) is rs.OnNextMux: key = i.key map_key = key_mapper(i.item) index = i.store.get_map(state, key, map_key) if index is rs.state.markers.STATE_NOTSET: index = i.store.add_map(state, key, map_key) observer.on_next( rs.OnCreateMux((index, i.key), store=i.store)) observer.on_next(i._replace(key=(index, i.key))) elif type(i) is rs.OnCreateMux: i.store.add_key(state, i.key) outer_observer.on_next(i) elif type(i) is rs.OnCompletedMux: for k in i.store.iterate_map(state, i.key): index = i.store.get_map(state, i.key, k) observer.on_next(i._replace(key=(index, i.key))) i.store.del_key(state, i.key) outer_observer.on_next(i) elif type(i) is rs.OnErrorMux: for k in i.store.iterate_map(state, i.key): index = i.store.get_map(state, i.key, k) observer.on_next(i._replace(key=(index, i.key))) i.store.del_map(state, i.key, k) i.store.del_key(state, i.key) outer_observer.on_next(i) elif type(i) is rs.state.ProbeStateTopology: state = i.topology.create_mapper(name="groupby") observer.on_next(i) outer_observer.on_next(i) else: if state is None: observer.on_error( ValueError( "No state configured in group_by operator. A state store operator is probably missing in the graph" )) observer.on_next(i) return source.subscribe(on_next=on_next, on_completed=observer.on_completed, on_error=observer.on_error, scheduler=scheduler) return rs.MuxObservable(on_subscribe)
def _roll_count(source): def subscribe(observer, scheduler=None): state = None def on_next(i): nonlocal state if type(i) is rs.OnNextMux: count = i.store.get_state(state, i.key) if count == 0: observer.on_next( rs.OnCreateMux((i.key[0], i.key), i.store)) count += 1 observer.on_next(i._replace(key=(i.key[0], i.key))) if count == window: i.store.set_state(state, i.key, 0) observer.on_next( rs.OnCompletedMux((i.key[0], i.key), i.store)) else: i.store.set_state(state, i.key, count) elif type(i) is rs.OnCreateMux: i.store.add_key(state, i.key) outer_observer.on_next(i) elif type(i) in [rs.OnCompletedMux, rs.OnErrorMux]: count = i.store.get_state(state, i.key) if count > 0: observer.on_next(i._replace(key=(i.key[0], i.key))) i.store.del_key(state, i.key) outer_observer.on_next(i) elif type(i) is rs.state.ProbeStateTopology: state = i.topology.create_state(name="roll", data_type='uint', default_value=0) observer.on_next(i) outer_observer.on_next(i) else: if state is None: observer.on_error( ValueError( "No state configured in roll operator. A state store operator is probably missing in the graph" )) observer.on_next(i) return source.subscribe(on_next=on_next, on_error=observer.on_error, on_completed=observer.on_completed, scheduler=scheduler) return rs.MuxObservable(subscribe)
def _on_mux_action(source): def on_subscribe(observer, scheduler): def _on_next(i): on_next(i) observer.on_next(i) return source.subscribe( on_next=_on_next, on_error=observer.on_error, on_completed=observer.on_completed, ) return rs.MuxObservable(on_subscribe)
def _drop_probe_state_topology(source): def on_subscribe(observer, scheduler): def on_next(i): if type(i) is not ProbeStateTopology: observer.on_next(i._replace(store=None)) return source.subscribe( on_next=on_next, on_error=observer.on_error, on_completed=observer.on_completed, ) return rs.MuxObservable(on_subscribe)
def _on(source): def on_subscribe(observer, scheduler): def _on_next(i): if type(i) is rs.state.ProbeStateTopology: cbk(i) observer.on_next(i) return source.subscribe(on_next=_on_next, on_completed=observer.on_completed, on_error=observer.on_error, scheduler=scheduler) return rs.MuxObservable(on_subscribe)
def _ignore(source): def on_subscribe(observer, scheduler): def _on_next(i): if type(i) is not rs.OnErrorMux: observer.on_next(i) return source.subscribe( on_next=_on_next, on_completed=observer.on_completed, on_error=observer.on_error, scheduler=scheduler ) return rs.MuxObservable(on_subscribe)
def _split(source): def on_subscribe(observer, scheduler): state = None def on_next(i): nonlocal state if type(i) is rs.OnNextMux: new_predicate = predicate(i.item) current_predicate = i.store.get_state(state, i.key) if current_predicate is rs.state.markers.STATE_NOTSET: current_predicate = new_predicate i.store.set_state(state, i.key, current_predicate) observer.on_next(rs.OnCreateMux((i.key[0], i.key), i.store)) if new_predicate != current_predicate: i.store.set_state(state, i.key, new_predicate) observer.on_next(rs.OnCompletedMux((i.key[0], i.key), i.store)) observer.on_next(rs.OnCreateMux((i.key[0], i.key), i.store)) observer.on_next(i._replace(key=(i.key[0], i.key))) elif type(i) is rs.OnCreateMux: i.store.add_key(state, i.key) outer_observer.on_next(i) elif isinstance(i, rs.OnCompletedMux): observer.on_next(i._replace(key=(i.key[0], i.key))) outer_observer.on_next(i) elif type(i) is rs.OnErrorMux: observer.on_next(i._replace(key=(i.key[0], i.key))) outer_observer.on_next(i) elif type(i) is rs.state.ProbeStateTopology: state = i.topology.create_state(name='split', data_type='obj') observer.on_next(i) outer_observer.on_next(i) else: if state is None: observer.on_error(ValueError("No state configured in split operator. A state store operator is probably missing in the graph")) observer.on_next(i) return source.subscribe( on_next=on_next, on_completed=observer.on_completed, on_error=observer.on_error, ) return rs.MuxObservable(on_subscribe)
def _pad_end_mux(source): def on_subscribe(observer, scheduler): state = None def on_next(i): nonlocal state if type(i) is rs.OnNextMux: i.store.set_state(state, i.key, i.item) observer.on_next(i) elif type(i) is rs.OnCreateMux: i.store.add_key(state, i.key) observer.on_next(i) elif type(i) is rs.OnCompletedMux: v = i.store.get_state(state, i.key) if v is not rs.state.markers.STATE_NOTSET: if value is not None: v = value for _ in range(size): observer.on_next(rs.OnNextMux(i.key, v, i.store)) observer.on_next(i) i.store.del_key(state, i.key) elif type(i) is rs.OnErrorMux: i.store.del_key(state, i.key) observer.on_next(i) elif type(i) is rs.state.ProbeStateTopology: state = i.topology.create_state(name='pad_end', data_type='obj') observer.on_next(i) else: if state is None: observer.on_error( ValueError( "No state configured in pad_end operator. A state store operator is probably missing in the graph" )) observer.on_next(i) return source.subscribe( on_next=on_next, on_error=observer.on_error, on_completed=observer.on_completed, ) return rs.MuxObservable(on_subscribe)
def _flat_map(source): def on_subscribe(observer, scheduler): def on_next(i): if type(i) is rs.OnNextMux: for ii in i.item: observer.on_next(i._replace(item=ii)) else: observer.on_next(i) return source.subscribe(on_next=on_next, on_completed=observer.on_completed, on_error=observer.on_error, scheduler=scheduler) return rs.MuxObservable(on_subscribe)
def _with_store(source): def on_subscribe(observer, scheduler): topology = StateTopology() def on_next(i): observer.on_next(i._replace(store=store)) observer.on_next(ProbeStateTopology(topology)) store.set_topology(topology) return source.subscribe( on_next=on_next, on_error=observer.on_error, on_completed=observer.on_completed, ) return rs.MuxObservable(on_subscribe)
def _distinct(source): def on_subscribe(observer, scheduler=None): state = None def on_next(x): nonlocal state if type(x) is rs.OnNextMux: i = x.item key = i if key_mapper: try: key = key_mapper(i) except Exception as ex: observer.on_error(ex) return _state = x.store.get_state(state, x.key) if key not in _state: _state.add(key) observer.on_next(x) elif type(x) is rs.OnCreateMux: x.store.add_key(state, x.key) x.store.set_state(state, x.key, set()) observer.on_next(x) elif type(x) in [rs.OnCompletedMux, rs.OnErrorMux]: x.store.del_key(state, x.key) observer.on_next(x) elif type(x) is rs.state.ProbeStateTopology: state = x.topology.create_state(name="distinct", data_type='set') observer.on_next(x) else: if state is None: observer.on_error( ValueError( "No state configured in distinct operator. A state store operator is probably missing in the graph" )) observer.on_next(x) return source.subscribe_(on_next, observer.on_error, observer.on_completed, scheduler) return rs.MuxObservable(on_subscribe)
def _map(source): def on_subscribe(observer, scheduler): def on_next(i): if type(i) is rs.OnNextMux: try: ii = mapper(i.item) observer.on_next(i._replace(item=ii)) except Exception as e: observer.on_next(rs.OnErrorMux(i.key, e, i.store)) else: observer.on_next(i) return source.subscribe(on_next=on_next, on_completed=observer.on_completed, on_error=observer.on_error, scheduler=scheduler) return rs.MuxObservable(on_subscribe)
def _lag(source): def on_subscribe(observer, scheduler): state = None def on_next(i): nonlocal state if isinstance(i, rs.OnNextMux): q = i.store.get_state(state, i.key) q.append(i.item) observer.on_next(i._replace(item=(q[0], i.item))) if len(q) > size: q.popleft() elif isinstance(i, rs.OnCreateMux): i.store.add_key(state, i.key) i.store.set_state(state, i.key, deque()) observer.on_next(i) elif isinstance(i, rs.OnCompletedMux) \ or isinstance(i, rs.OnErrorMux): i.store.del_key(state, i.key) observer.on_next(i) elif type(i) is rs.state.ProbeStateTopology: state = i.topology.create_state(name='scan', data_type='obj') observer.on_next(i) else: if state is None: observer.on_error(ValueError("No state configured in lag operator. A state store operator is probably missing in the graph")) observer.on_next(i) def on_completed(): observer.on_completed() return source.subscribe( on_next=on_next, on_completed=on_completed, on_error=observer.on_error, scheduler=scheduler, ) return rs.MuxObservable(on_subscribe)
def _filter(source): def on_subscribe(observer, scheduler): def on_next(i): if type(i) is rs.OnNextMux: try: emit = predicate(i.item) if emit is True: observer.on_next(i) except Exception as e: observer.on_next(rs.OnErrorMux(i.key, e, i.store)) else: observer.on_next(i) return source.subscribe(on_next=on_next, on_completed=observer.on_completed, on_error=observer.on_error, scheduler=scheduler) return rs.MuxObservable(on_subscribe)
def _start_with(source): def on_subscribe(observer, scheduler): state = None def on_next(i): nonlocal state if type(i) is rs.OnNextMux: s = i.store.get_state(state, i.key) if s is rs.state.markers.STATE_NOTSET: i.store.set_state(state, i.key, True) for p in padding: observer.on_next(i._replace(item=p)) observer.on_next(i) elif type(i) is rs.OnCreateMux: i.store.add_key(state, i.key) observer.on_next(i) elif type(i) in [rs.OnCompletedMux, rs.OnErrorMux]: i.store.del_key(state, i.key) observer.on_next(i) elif type(i) is rs.state.ProbeStateTopology: state = i.topology.create_state(name='start_with', data_type=bool) observer.on_next(i) else: if state is None: observer.on_error( ValueError( "No state configured in start_with operator. A state store operator is probably missing in the graph" )) observer.on_next(i) return source.subscribe( on_next=on_next, on_error=observer.on_error, on_completed=observer.on_completed, ) return rs.MuxObservable(on_subscribe)
def __mux(source): def on_subscribe(observer, scheduler): def on_next(i): observer.on_next(rs.OnNextMux((0, ), i)) def on_error(e): observer.on_error(e) def on_completed(): observer.on_next(rs.OnCompletedMux((0, ))) observer.on_completed() observer.on_next(rs.OnCreateMux((0, ))) return source.subscribe( on_next=on_next, on_completed=on_completed, on_error=on_error, scheduler=scheduler, ) return rs.MuxObservable(on_subscribe)
def _last(source): def on_subscribe(observer, scheduler): state = None def on_next(i): nonlocal state if type(i) is rs.OnNextMux: i.store.set_state(state, i.key, i.item) elif type(i) is rs.OnCreateMux: i.store.add_key(state, i.key) observer.on_next(i) elif type(i) is rs.OnCompletedMux: value = i.store.get_state(state, i.key) if value is not rs.state.markers.STATE_NOTSET: observer.on_next(rs.OnNextMux(i.key, value, i.store)) observer.on_next(i) i.store.del_key(state, i.key) elif type(i) is rs.OnErrorMux: observer.on_next(i) i.store.del_key(state, i.key) elif type(i) is rs.state.ProbeStateTopology: state = i.topology.create_state(name='last', data_type='obj') observer.on_next(i) else: observer.on_next(i) return source.subscribe( on_next=on_next, on_completed=observer.on_completed, on_error=observer.on_error, scheduler=scheduler ) return rs.MuxObservable(on_subscribe)
def _pad_start_mux(source): def on_subscribe(observer, scheduler): state = None def on_next(i): nonlocal state if type(i) is rs.OnNextMux: v = i.store.get_state(state, i.key) if v is rs.state.markers.STATE_NOTSET: i.store.set_state(state, i.key, True) v = value if value is not None else i.item for _ in range(size): observer.on_next(i._replace(item=v)) observer.on_next(i) elif type(i) is rs.OnCreateMux: i.store.add_key(state, i.key) observer.on_next(i) elif type(i) is rs.OnCompletedMux or type(i) is rs.OnErrorMux: i.store.del_key(state, i.key) observer.on_next(i) elif type(i) is rs.state.ProbeStateTopology: state = i.topology.create_state(name='pad_start', data_type=bool) observer.on_next(i) else: observer.on_next(i) return source.subscribe( on_next=on_next, on_error=observer.on_error, on_completed=observer.on_completed, ) return rs.MuxObservable(on_subscribe)
def _assert_mux(source): def on_subscribe(observer, scheduler): def on_next(i): if type(i) is rs.OnNextMux: try: if predicate(i.item) is True: observer.on_next(rs.OnNextMux(i.key, i.item)) else: observer.on_error( error("assert {} failed on: {}".format( name, i.item))) except Exception as e: observer.on_next(rs.OnErrorMux(i.key, e)) else: observer.on_next(i) return source.subscribe(on_next=on_next, on_completed=observer.on_completed, on_error=observer.on_error, scheduler=scheduler) return rs.MuxObservable(on_subscribe)
def route_to_dead_letter(source): def on_subscribe(observer, scheduler): def on_next(i): nonlocal dead_letter_observer if type( i ) is rs.OnErrorMux and dead_letter_observer is not None: dead_letter_observer.on_next(i.error) else: observer.on_next(i) def on_error(e): nonlocal dead_letter_observer if dead_letter_observer is not None: dead_letter_observer.on_next(e) dead_letter_observer.on_completed() observer.on_error(e) def on_completed(): nonlocal dead_letter_observer if dead_letter_observer is not None: dead_letter_observer.on_completed() observer.on_completed() return source.subscribe( on_next=on_next, on_error=on_error, on_completed=on_completed, scheduler=scheduler, ) return rs.MuxObservable(on_subscribe)
def _map(source): def on_subscribe(observer, scheduler): def on_next(i): if type(i) is rs.OnErrorMux: try: print("error") ii = mapper(i.error) observer.on_next( rs.OnNextMux( key=i.key, item=ii, store=i.store, )) except Exception as e: observer.on_error(e) else: observer.on_next(i) return source.subscribe(on_next=on_next, on_completed=observer.on_completed, on_error=observer.on_error, scheduler=scheduler) return rs.MuxObservable(on_subscribe)
def _process_many(*args, connectable, zip, combine): sources = list(args) def subscribe_mux(observer, scheduler): n = len(sources) queue = [] has_next = array('B') def on_next(i, x): if isinstance(x, rs.OnCreateMux): if i == 0: if zip is True or combine is True: append_count = (x.key[0] + 1) * n - len(queue) if append_count > 0: for _ in range(append_count): queue.append(None) has_next.append(False) observer.on_next(x) return elif isinstance(x, rs.OnCompletedMux): if i == n - 1: observer.on_next(x) if zip is True or combine is True: base_index = x.key[0] * n queue[base_index + i] = None has_next[base_index + i] = False return elif not isinstance(x, rs.OnNextMux): observer.on_next(x) return if zip is True or combine is True: base_index = x.key[0] * n index = base_index + i queue[index] = x.item has_next[index] = True if zip is True: _next = has_next[base_index:base_index + n] if all(_next): try: _queue = queue[base_index:base_index + n] res = tuple(_queue) res = rs.OnNextMux(x.key, res, x.store) for index in range(n): has_next[base_index + index] = False queue[base_index + index] = None except Exception as ex: # pylint: disable=broad-except observer.on_error(ex) return observer.on_next(res) else: try: _queue = queue[base_index:base_index + n] res = tuple(_queue) res = rs.OnNextMux(x.key, res, x.store) except Exception as ex: # pylint: disable=broad-except observer.on_error(ex) return observer.on_next(res) else: observer.on_next(x) subscriptions = [None] * n for i in range(n): subscriptions[i] = sources[i].subscribe_( on_next=functools.partial(on_next, i), on_error=observer.on_error, on_completed=observer.on_completed, scheduler=scheduler, ) subscriptions.append(connectable.connect()) return CompositeDisposable(subscriptions) def subscribe(observer, scheduler): n = len(sources) queue = [None] * n has_next = [False] * n is_done = [False] * n def on_next(i, x): if zip is True: queue[i] = x has_next[i] = True if all(has_next): try: res = tuple(queue) for index in range(n): has_next[index] = False except Exception as ex: # pylint: disable=broad-except observer.on_error(ex) return observer.on_next(res) elif combine is True: queue[i] = x has_next[i] = True res = tuple(queue) observer.on_next(res) else: observer.on_next(x) def done(i): is_done[i] = True if all(is_done): observer.on_completed() subscriptions = [None] * n for i in range(n): subscriptions[i] = sources[i].subscribe_( functools.partial(on_next, i), observer.on_error, functools.partial(done, i), scheduler) subscriptions.append(connectable.connect()) return CompositeDisposable(subscriptions) if isinstance(connectable, rs.MuxObservable): return rs.MuxObservable(subscribe_mux) else: return rx.create(subscribe)
def _roll(source): def subscribe(observer, scheduler=None): state_n = None state_w = None def on_next(i): nonlocal state_n nonlocal state_w if isinstance(i, rs.OnNextMux): n = i.store.get_state(state_n, i.key) if (n % stride) == 0: offset = (n // stride) % density index = i.key[0] * density + offset i.store.set_state(state_w, (index, i.key), n) observer.on_next( rs.OnCreateMux((index, i.key), i.store)) for offset in range(density): index = i.key[0] * density + offset w_value = i.store.get_state(state_w, (index, i.key)) if w_value != -1: observer.on_next(i._replace(key=(index, i.key))) count = n - w_value + 1 if count == window: i.store.set_state(state_w, (index, i.key), -1) observer.on_next( rs.OnCompletedMux((index, i.key), i.store)) n_value = i.store.get_state(state_n, i.key) i.store.set_state(state_n, i.key, n_value + 1) elif isinstance(i, rs.OnCreateMux): i.store.add_key(state_n, (i.key[0], i.key)) for offset in range(density): i.store.add_key(state_w, (i.key[0] * density + offset, i.key)) outer_observer.on_next(i) elif isinstance(i, rs.OnCompletedMux): kindex = i.key[0] i.store.set_state(state_n, (kindex, i.key), 0) for offset in range(density): index = i.key[0] * density + offset if i.store.get_state(state_w, (index, i.key)) != -1: observer.on_next(i._replace(key=(index, i.key))) i.store.set_state(state_w, (index, i.key), -1) outer_observer.on_next(i) elif isinstance(i, rs.OnErrorMux): kindex = i.key[0] i.store.set_state(state_n, (kindex, i.key), 0) for offset in range(density): index = i.key[0] * density + offset if i.store.get_state(state_w, (index, i.key)) != -1: observer.on_next(i._replace(key=(index, i.key))) i.store.set_state(state_w, (index, i.key), -1) outer_observer.on_next(i) elif type(i) is rs.state.ProbeStateTopology: state_n = i.topology.create_state(name="roll", data_type='uint', default_value=0) state_w = i.topology.create_state(name="roll", data_type=int, default_value=-1) observer.on_next(i) else: observer.on_next(i) return source.subscribe(on_next=on_next, on_error=observer.on_error, on_completed=observer.on_completed, scheduler=scheduler) return rs.MuxObservable(subscribe)
def test_create_aggobservable(): obs = rs.MuxObservable(lambda o, s: None)
def _time_split(source): def on_subscribe(observer, scheduler): state_start = None state_last = None def on_next(i): nonlocal state_start nonlocal state_last if type(i) is rs.OnNextMux: new_timestamp = time_mapper(i.item) start_timestamp = i.store.get_state(state_start, i.key) last_timestamp = i.store.get_state(state_last, i.key) if start_timestamp is rs.state.markers.STATE_NOTSET: start_timestamp = new_timestamp last_timestamp = new_timestamp i.store.set_state(state_start, i.key, start_timestamp) i.store.set_state(state_last, i.key, last_timestamp) observer.on_next( rs.OnCreateMux((i.key[0], i.key), i.store)) if _session_has_expired(start_timestamp, last_timestamp, new_timestamp): i.store.set_state(state_start, i.key, new_timestamp) i.store.set_state(state_last, i.key, new_timestamp) observer.on_next( rs.OnCompletedMux((i.key[0], i.key), i.store)) observer.on_next( rs.OnCreateMux((i.key[0], i.key), i.store)) elif closing_mapper is not None and closing_mapper( i.item) is True: i.store.set_state(state_start, i.key, new_timestamp) i.store.set_state(state_last, i.key, new_timestamp) if include_closing_item is True: observer.on_next(i._replace(key=(i.key[0], i.key))) observer.on_next( rs.OnCompletedMux((i.key[0], i.key), i.store)) observer.on_next( rs.OnCreateMux((i.key[0], i.key), i.store)) if include_closing_item is True: return else: i.store.set_state(state_last, i.key, new_timestamp) observer.on_next(i._replace(key=(i.key[0], i.key))) elif type(i) is rs.OnCreateMux: i.store.add_key(state_start, i.key) i.store.add_key(state_last, i.key) outer_observer.on_next(i) elif type(i) in [rs.OnCompletedMux, rs.OnErrorMux]: observer.on_next(i._replace(key=(i.key[0], i.key))) i.store.del_key(state_start, i.key) i.store.del_key(state_last, i.key) outer_observer.on_next(i) elif type(i) is rs.state.ProbeStateTopology: state_start = i.topology.create_state(name='time_split', data_type='obj') state_last = i.topology.create_state(name='time_split', data_type='obj') observer.on_next(i) outer_observer.on_next(i) else: if state_start is None or state_last is None: observer.on_error( ValueError( "No state configured in time split operator. A state store operator is probably missing in the graph" )) observer.on_next(i) return source.subscribe( on_next=on_next, on_completed=observer.on_completed, on_error=observer.on_error, ) return rs.MuxObservable(on_subscribe)