How to use RxPY (or RxJS) combine_latest with a group_by observable

Question

In ReactiveX I can take the latest value out of each of a number of observables, which each may or may not be emitting at different frequencies, as follows (using RxPY):

from __future__ import print_function

from rx import Observable
import time
import IPython
import random

random.seed(123)

x1 = Observable.interval(random.randint(50, 500))
x2 = Observable.interval(random.randint(50, 500))
x3 = Observable.interval(random.randint(50, 500))

xc = Observable.combine_latest(x1, x2, x3, lambda a1, a2, a3: [a1, a2, a3])

xc.subscribe(lambda s: print(s))

input("Press Enter to end")

However, how would I do the same thing, that is, print the latest value from each of a set of observables, whenever any of the observables emits a value, when said observables were created using a group_by?

from __future__ import print_function

from rx import Observable
import time
import IPython
import random

random.seed(123)

n = 5
xx = Observable.interval(random.randint(50, 500)).group_by(lambda x: x % 5) # create n observables
print(xx)

Thing is this returns an observable group object:

<rx.core.anonymousobservable.AnonymousObservable object at 0xb631bb10>

So for any given n how would I perform the same combine_latest operation on this object?

I understand that in this stylized example the observables will emit at the same rate, but I need the solution to generalize to different emission frequencies as per the explicit example at the top.

Given that the structure of RxPY and RxJS are so similar, I am happy to consider analogous RxJS answers.

Answer 1

Edit: If the number of groups is finite and pretty small, this is a cleaner way you can go about this without sacrificing much performance:

groups$.scan(lambda prev, group$: [
               Observable.combineLatest(prev + [group$])\
                         .map(lambda nest: nest[0] + [nest[1]] if len(nest) == 2 else nest)
             ], [])

Here, scan builds an Observable that emits any time any group emits. It does this by nesting the emissions from the list of groups in the previous iteration. Because prev is an observable of arrays, we flatting using map with list concat. The arrays wrapping the scan results accommodate the base case of the first group.

---

Edit: I realized a little after writing the answer below the line that its behavior, which doesn't emit any items until all streams have emitted one more, is probably not wanted. Off the top of my head, the shortest but certainly not the cleanest solution is to stash the latest values and start each stream with them, like so:

def group_combine(groups$):
  last = []

  def mutate_last(v): # too bad this isn't JS :/
    last = v

  return groups$.scan(lambda streams, next_stream: streams + [next_stream], [])\
                .switch_map(lambda streams: Observable.combine_latest(
                  [stream.start_with(last[i]) if i < len(last) else stream\
                     for i, stream in enumerate(streams)]
                ))\
                .for_each(mutate_last)

---

Give this a try:

// groups$ = x.group_by(...)
groups$.scan(lambda streams, next_stream: streams + [next_stream], [])\
       .switch_map(lambda streams: Observable.combine_latest(streams))\
       .subscribe(lambda values: ...)

First, we accumulate the group streams into a growing list, then we keep switching to the combine_latest over that list.