pypeup  Piping Up with Python
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):
pass
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
my_pipe.data # 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 self.data + x
def sub(self, x):
return self.data  x
def mul(self, x):
return self.data * x
pipe2 = MyPipe2(np.array([1, 2, 3]))
pipe2.add(3).sub(2).mul(4)
pipe2.data
# >>> 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 self.data + math.sin(x)
pipe = MyPipe(0.)
print pipe.fun(math.pi / 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 self.data + 1
pipe = MyPipe(10)
pipe.addOne(1) # OK.
pipe.data = 11 # Not OK.
There are some limits on the functions which can be applied to pypeup
.
See Limits for detail.
Limits
As mentioned above, there are few limits on the functions that can be used with pypeup
:
 The current data can be access through
self.data
.
self.data
is aproperty
defined inDataPipe
, 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
self.data
.  If the instance method is private method (method with the name start with
_
or__
) will work just like normal instance method.
 It doesn't mean you have to name it as
 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.
 for example, they must be all
 All the function must return the data which will be passed through the pipe.
Installation
 Install through
pip
: Just run
pip install pypeup
 Just run
 Install from source:
 run
git clone https://github.com/dboyliao/pypeup.git && cd pypeup
 run
python setup.py install
to install the package.
 run
Tests
 If you haven't installed
nose
yet, runpip install r requirements.txt
first.  run
nosetests