To use, import at least pipeline from functional_pipeline:

from functional_pipeline import pipeline

pipeline takes 2 arguments, value and operations.

value is the starting value of the pipeline. This is what gets passed in to the first function in operations.

operations is a List of either functions or tuples.

Pipeline passes the value from one operation to the next. When all of the operations are complete, the result is returned.

The main use of pipelines is to simplify code and reduce unnessiary variables in long chained operations.

For Example:

def add_1(x):
    return x + 1

def multiply_2(x):
    return x * 2

def divide_3(x):
    return x / 3

def subtract_1(x):
    return x - 1

start = 5
first = add_1(start)
second = mulitply_2(first)
third = divide_3(second)
final = subtract_1(third)

In this simple example, 3 variables are created, used once, then never again. They often arent needed. One might rewrite this example as

start = 5
final = subtact_1(divide_3(multiply_2(add_1(start))))

This refactored code gets rid of the unused variables, but it becomes harder to read. The order of operations becomes nested, which means you have to read backwards to get the innermost action first. Pipelines fix both of these problems

final = pipeline(

The order of operations is very clear and there is no messy unused variables.

Pipelines also allow you to clear up the one off functions in this case. Instead of defining all of these single use named functions, we can use pipelines tuple operation paired with the base operator classes.

from operator import add, mul, truediv, sub
from functional_pipeline import pipeline

start = 5

final = pipeline(
        (add, 1),
        (mul, 2),
        (truediv, 3),
        (sub, 1),

By changing from functions to tuples in the operations list, we allowed for partial application of functions.