Example #1
0
            def on_next(x):
                writer = None
                element = None
                duration = None
                key = None

                try:
                    key = key_selector(x)
                except Exception as e:
                    for w in mapping.values():
                        w.on_error(e)

                    observer.on_error(e)
                    return
                else:
                    serialized_key = key_serializer(key)

                fire_new_map_entry = False
                try:
                    writer = mapping.get(serialized_key)
                    if not writer:
                        writer = Subject()
                        mapping[serialized_key] = writer
                        fire_new_map_entry = True

                except Exception as e:
                    for w in mapping.values():
                        w.on_error(e)

                    observer.on_error(e)
                    return

                if fire_new_map_entry:
                    group = GroupedObservable(key, writer,
                                              ref_count_disposable)
                    duration_group = GroupedObservable(key, writer)
                    try:
                        duration = duration_selector(duration_group)
                    except Exception as e:
                        for w in mapping.values():
                            w.on_error(e)

                        observer.on_error(e)
                        return

                    observer.on_next(group)
                    md = SingleAssignmentDisposable()
                    group_disposable.add(md)

                    def expire():
                        if mapping[serialized_key]:
                            del mapping[serialized_key]
                            writer.on_completed()

                        group_disposable.remove(md)

                    def on_next(value):
                        pass

                    def on_error(exn):
                        print("on_error()", exn)
                        for wr in mapping.values():
                            wr.on_error(exn)
                        observer.on_error(exn)

                    def on_completed():
                        expire()

                    md.set_disposable(
                        duration.take(1).subscribe(on_next, on_error,
                                                   on_completed))

                try:
                    element = element_selector(x)
                except Exception as e:
                    for w in mapping.values():
                        w.on_error(e)

                    observer.on_error(e)
                    return

                writer.on_next(element)
            def on_next(x):
                writer = None
                element = None
                duration = None
                key = None
                
                try:
                    key = key_selector(x)
                except Exception as e:
                    for w in mapping.values():
                        w.on_error(e)
                    
                    observer.on_error(e)
                    return
                else:
                    serialized_key = key_serializer(key)
                
                fire_new_map_entry = False
                try:
                    writer = mapping.get(serialized_key)
                    if not writer:
                        writer = Subject()
                        mapping[serialized_key] = writer
                        fire_new_map_entry = True
                    
                except Exception as e:
                    for w in mapping.values():
                        w.on_error(e)
                    
                    observer.on_error(e)
                    return
                
                if fire_new_map_entry:
                    group = GroupedObservable(key, writer, ref_count_disposable)
                    duration_group = GroupedObservable(key, writer)
                    try:
                        duration = duration_selector(duration_group)
                    except Exception as e:
                        for w in mapping.values():
                            w.on_error(e)
                        
                        observer.on_error(e)
                        return
                    
                    observer.on_next(group)
                    md = SingleAssignmentDisposable()
                    group_disposable.add(md)
                    
                    def expire():
                        if mapping[serialized_key]:
                            del mapping[serialized_key]
                            writer.on_completed()
                        
                        group_disposable.remove(md)
                    
                    def on_next(value):
                        pass

                    def on_error(exn):
                        print ("on_error()", exn)
                        for wr in mapping.values():
                            wr.on_error(exn)
                        observer.on_error(exn)

                    def on_completed():
                        expire()

                    md.set_disposable(duration.take(1).subscribe(on_next, on_error, on_completed))
                
                try:
                    element = element_selector(x)
                except Exception as e:
                    for w in mapping.values():
                        w.on_error(e)
                    
                    observer.on_error(e)
                    return
                
                writer.on_next(element)