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)
