def flatten(): stack = get_stack_lines() def op_func(source: Flowable): return source.flat_map(func=lambda v: v, stack=stack) return PipeOperation(op_func)
def controlled_zip( right: FlowableMixin, request_left: Callable[[Any, Any], bool] = None, request_right: Callable[[Any, Any], bool] = None, match_func: Callable[[Any, Any], bool] = None, ): """ Creates a new Flowable from two Flowables by combining their elements in pairs. Which element gets paired with an element from the other Flowable is determined by two functions called `request_left` and `request_right`. :param right: other Flowable :param request_left: a function that returns True, if a new element from the left \ Flowable is requested to build the the next pair :param request_right: a function that returns True, if a new element from the left \ Flowable is requested to build the the next pair :param match_func: a filter function that returns True, if the current pair is sent \ downstream :return: zipped Flowable """ stack = get_stack_lines() def op_func(left: Flowable): return left.controlled_zip( right=right, stack=stack, request_left=request_left, request_right=request_right, match_func=match_func, ) return PipeOperation(op_func)
def zip_with_index(): """ Zip each item emitted by the source with the enumerated index. """ def op_func(left: Flowable): return left.zip_with_index() return PipeOperation(op_func)
def first_or_default(lazy_val: Callable[[], Any]): """ Emit the first element only and stop the Flowable sequence thereafter. """ def op_func(source: Flowable): return source.first_or_default(lazy_val=lazy_val) return PipeOperation(op_func)
def buffer(buffer_size: int = None): """ Buffer the element emitted by the source without back-pressure until the buffer is full. """ def op_func(source: Flowable): return source.buffer(buffer_size=buffer_size) return PipeOperation(op_func)
def pairwise(): """ Create a Flowable that emits a pair for each consecutive pairs of elements in the Flowable sequence. """ def op_func(source: Flowable): return source.pairwise() return PipeOperation(op_func)
def repeat_first(): """ Return a Flowable that repeats the first element it receives from the source forever (until disposed). """ def op_func(source: Flowable): return source.repeat_first() return PipeOperation(op_func)
def set_base(val: Any): """ Overwrite the base of the current Flowable sequence. """ def op_func(source: IndexedFlowable): return source.set_base(val=val) return PipeOperation(op_func)
def to_list(): """ Create a new Flowable that collects the elements from the source sequence, and emits a single element of type List. """ def op_func(source: Flowable): return source.to_list() return PipeOperation(op_func)
def strategy(overflow_strategy: OverflowStrategy): """ Buffer the element emitted by the source use overflow strategy. """ def op_func(source: Flowable): return source.strategy(overflow_strategy=overflow_strategy) return PipeOperation(op_func)
def map(func: Callable[[Any], Any]): """ Map each element emitted by the source by applying the given function. :param func: function that defines the mapping applied to each element of the \ Flowable sequence. """ def op_func(source: Flowable): return source.map(func=func) return PipeOperation(op_func)
def merge(*others: Flowable): """ Merge the elements of this and the other Flowable sequences into a single *Flowable*. :param sources: other Flowables that get merged to this Flowable. """ def op_func(left: Flowable): return left.merge(*others) return PipeOperation(op_func)
def default_if_empty(lazy_val: Callable[[], Any]): """ Only the elements of the source or a default value if the source is an empty sequence :param lazy_val: a function that returns the default value """ def op_func(left: Flowable): return left.default_if_empty(lazy_val=lazy_val) return PipeOperation(op_func)
def fast_filter(predicate: Callable[[Any], bool]): """ Only emit those elements for which the given predicate holds. :param predicate: a function that returns True, if the current element passes the filter :return: filtered Flowable """ def op_func(left: Flowable): return left.fast_filter(predicate=predicate) return PipeOperation(op_func)
def map_to_iterator(func: Callable[[ValueType], Iterator[ValueType]], ): """ Create a Flowable that maps each element emitted by the source to an iterator and emits each element of these iterators. :param func: function that defines the mapping applied to each element to an iterator. """ def op_func(source: Flowable): return source.map_to_iterator(func=func) return PipeOperation(op_func)
def concat(*sources: FlowableMixin): """ Concatentates Flowables sequences together by back-pressuring the tail Flowables until the current Flowable has completed. :param sources: other Flowables that get concatenate to this Flowable. """ def op_func(left: Flowable): return left.concat(*sources) return PipeOperation(op_func)
def observe_on(scheduler: Scheduler): """ Schedule elements emitted by the source on a dedicated scheduler. :param scheduler: a rxbackpressure scheduler :return: an Flowable running on specified scheduler """ def op_func(source: Flowable): return source.observe_on(scheduler=scheduler) return PipeOperation(op_func)
def zip(*others: Flowable): """ Create a new Flowable from one or more Flowables by combining their item in pairs in a strict sequence. :param others: :param sources: other Flowables that get zipped to this Flowable. """ stack = get_stack_lines() def op_func(left: Flowable): return left.zip(others=others, stack=stack) return PipeOperation(op_func)
def debug_base( base: Any, name: str = None, ): stack = get_stack_lines() def op_func(source: IndexedFlowable): return source.debug_base( base=base, stack=stack, name=name, ) return PipeOperation(op_func)
def scan(func: Callable[[Any, Any], Any], initial: Any): """ Apply an accumulator function over a Flowable sequence and return each intermediate result. The initial value is used as the initial accumulator value. :param func: An accumulator function to be invoked on each element :param initial: The initial accumulator value :return: a Flowable that emits the accumulated values """ def op_func(source: Flowable): return source.scan(func=func, initial=initial) return PipeOperation(op_func)
def do_action( on_next: Callable[[Any], None] = None, on_completed: Callable[[], None] = None, on_error: Callable[[Exception], None] = None, on_disposed: Callable[[], None] = None, ): def op_func(left: Flowable): return left.do_action( on_next=on_next, on_completed=on_completed, on_error=on_error, on_disposed=on_disposed, ) return PipeOperation(op_func)
def reduce( func: Callable[[Any, Any], Any], initial: Any, ): """ Apply an accumulator function over a Flowable sequence and emits a single element. :param func: An accumulator function to be invoked on each element :param initial: The initial accumulator value :return: a Flowable that emits the final accumulated value """ def op_func(source: Flowable): return source.reduce(func=func, initial=initial) return PipeOperation(op_func)
def flat_map(func: Callable[[Any], Flowable]): """ Apply a function to each item emitted by the source and flattens the result. The specified function must return a Flowable. The resulting Flowable concatenates the elements of each inner Flowables. The resulting Flowable concatenates the items of each inner Flowable. """ stack = get_stack_lines() def op_func(source: Flowable): return source.flat_map(func=func, stack=stack) return PipeOperation(op_func)
def subscribe_on(scheduler: Scheduler): """ Subscribe on the specified scheduler. This only performs the side-effects of subscription and unsubscription on the specified scheduler. In order to invoke observer callbacks on a scheduler, use observe_on. :param scheduler: a rxbackpressure scheduler """ def op_func(source: Flowable): return source.subscribe_on(scheduler=scheduler) return PipeOperation(op_func)
def match( *others: IndexedFlowable, ): """ Create a new Flowable from this and other Flowables by first filtering and duplicating (if necessary) the elements of each Flowable and zip the resulting Flowable sequences together. :param sources: other Flowables that get matched with this Flowable. """ stack = get_stack_lines() def op_func(left: IndexedFlowable): return left.match( *others, stack=stack, ) return PipeOperation(op_func)
def last(): """ Emit the last element of the Flowable sequence The `raise_exception` argument needs to be given as follows: :: rxbp.op.last(raise_exception=lambda f: f()) The `raise_exception` argument is called in case there is no element. Like RxPY, a SequenceContainsNoElementsError is risen. But on top of that the place where the `last` argument is used is added to the traceback by providing the `raise_exception` argument. """ stack = get_stack_lines() def op_func(source: Flowable): return source.last(stack=stack) return PipeOperation(op_func)
def debug( name: str, on_next: Callable[[Any], Ack] = None, on_completed: Callable[[], None] = None, on_error: Callable[[Exception], None] = None, on_sync_ack: Callable[[Ack], None] = None, on_async_ack: Callable[[Ack], None] = None, on_observe: Callable[[ObserverInfo], None] = None, on_subscribe: Callable[[Subscriber], None] = None, on_raw_ack: Callable[[Ack], None] = None, verbose: bool = None, ): """ Print debug messages to the console when providing the `name` argument :on_next: customize the on next debug console print """ stack = get_stack_lines() def op_func(source: Flowable): return source.debug( name=name, on_next=on_next, on_completed=on_completed, on_error=on_error, on_observe=on_observe, on_subscribe=on_subscribe, on_sync_ack=on_sync_ack, on_async_ack=on_async_ack, on_raw_ack=on_raw_ack, stack=stack, verbose=verbose, ) return PipeOperation(op_func)