Skip to main content

An easy module for building data pipe in python.

Project description

# 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.

## Limits

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.

## Installation

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

## Tests

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

Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

pypeup-0.9.5.tar.gz (4.7 kB view hashes)

Uploaded source

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page