# Getting Started with cooperative¶

Write non-blocking computationally expensive code to go along with non-blocking io, without having to think about everything in callbacks.

batch_accumulate will iterate over a generator in batches, yielding to other iterators passed into twisted.internet.task.cooperate

# Examples¶

## Write computation code to cooperative.¶

#!/usr/bin/env python
# _*_ coding: utf-8 _*_
from operator import add

import sys
from twisted.internet import defer
from twisted.internet.task import react
from twisted.python import log

from cooperative import batch_accumulate

def expensive(number):
log.msg("starting {}".format(number))
for value in range(100000):
if 25000 == value:
log.msg("1/4 for {}".format(number))
if 50000 == value:
log.msg("1/2 for {}".format(number))
if 75000 == value:
log.msg("3/4 for {}".format(number))
yield number * value / 3.0

@defer.inlineCallbacks
def do_some_expensive_things(number):
"""
Perform one expensive computation cooperatively with any
other iterator passed into twisted's cooperate, then
use it's result to pass into the second computation.

:param number:
:return:
"""
result = yield batch_accumulate(1000, expensive(number))
total = reduce(add, result, 0)
log.msg("first for {}: {}".format(number, total))

result = yield batch_accumulate(1000, expensive(int(total/1e9)))
total = reduce(add, result, 0)
log.msg("second for {}: {}".format(number, total))
defer.returnValue(total)

def main(reactor):
d1 = do_some_expensive_things(54.0)
d2 = do_some_expensive_things(42)
d3 = do_some_expensive_things(10)
d4 = do_some_expensive_things(34)

# Enqueue events to simulate handling external events
reactor.callLater(0.3, d5.callback, "########## simulated request 1 ############")