An easy module for building data pipe in python.

python, data, pipeline
pip install pypeup==0.9.5


pypeup - Piping Up with Python

Build Status

This is a simple python module to help you to build a data pipe in python.

First Glance

Suppose you have a bunch of functions dealing with data of the same structure (e.g they are all array, integer, ...etc) and you want to pipe them up for complex computations, pypeup is here at your service.

With pypeup, you can write something like this:

from pypeup import DataPipe

# Note that these two funtion all return the same data structure and their
# first arguments are all data.
# In this example, the data are all of type list.

def fun1(data, x):
    x: <number>
    data: <list>
    return [a + x for a in data]

def fun2(data, ind):
    ind: <integer>
    data: <list>
    return data[:min(ind, len(data) - 1)]

class MyPipe(DataPipe):

my_pipe = MyPipe([1, 2, 3, 4, 5])
my_pipe.register(fun1)      # Use register method to add any method you like 
my_pipe.register(fun2)      # for your data.

my_pipe.fun1(1).fun2(3).fun2(2).fun1(3) # Pipe the function up at your wish                # Access the data by the `data` attribute
# >>> [5, 6]

Also, you can build up the pipe by one class declairation:

from pypeup import DataPipe
import numpy as np

class MyPipe2(DataPipe):

    def add(self, x):
        return + x

    def sub(self, x):
        return - x

    def mul(self, x):
        return * x

pipe2 = MyPipe2(np.array([1, 2, 3]))
# >>> np.array([8, 12, 16])

You can use private method as normal python:

from pypeup import DataPipe
import math

class MyPipe(DataPipe):

    def fun(self, x):
        return self._magic(x)

    def _magic(self, x):
        print "Where the magic happens!"
        return + math.sin(x)

pipe = MyPipe(0.)
print / 2).data
# >>> Where the magic happens!
# >>> 1.

In order to protect the data inside the pipe, any modification to the data which is outside of the execution context of the methods of the pipe is not allowed and an ExecutionContextError will be raised.

from pypeup import DataPipe

class MyPipe(DataPipe):

    def addOne(self):
        return + 1

pipe = MyPipe(10)
pipe.addOne(1)     # OK. = 11     # Not OK.

There are some limits on the functions which can be applied to pypeup. See Limits for detail.


As mentioned above, there are few limits on the functions that can be used with pypeup:

  • The current data can be access through
    • is a property defined in DataPipe, which means that if you want to overwrite it, you must be sure your implementation is OK.
  • All the functions' first argument must be data. (But not method, see below)
    • It doesn't mean you have to name it as data, but you have to be sure that all the functions' first argument will hold the data you want to process.
    • If the function is defined as an instance method, you only need to pass all the parameters needed to work with the data which can be access through
    • If the instance method is private method (method with the name start with _ or __) will work just like normal instance method.
  • All the data must be of the same (or compatible) data structure or type.
    • for example, they must be all list, number, numpy.array...etc.
  • All the function must return the data which will be passed through the pipe.


  • Install through pip:
    • Just run pip install pypeup
  • Install from source:
    • run git clone && cd pypeup
    • run python install to install the package.


  • If you haven't installed nose yet, run pip install -r requirements.txt first.
  • run nosetests