from IPython import parallel
client = parallel.Client()
lbv = client.load_balanced_view()
dview = client[:]
dview

# the real model object is much more involved...
class MyModel(object):
    def maximize(self, r):
        return max(r, 4)

def evaluate(r, model):
    return model.maximize(r)

import cPickle as pickle

m = MyModel()
print pickle.dumps(m)

model = MyModel()
lbv.apply_sync(evaluate, 2, model)

class MyModel1(object):
    def maximize(self, r):
        return max(r, 0)

%%px
class MyModel1(object):
    def maximize(self, r):
        return max(r, 0)

model = MyModel1()
lbv.apply_sync(evaluate, 1, model)

class MyModel2(object):
    def maximize(self, r):
        return max(r, 2)

# this just executes the previous cell on all our engines
# (note that In[-1] is *this* cell, so In[-2] is the previous one)
dview.execute(In[-2], block=True)

model = MyModel2()
lbv.apply_sync(evaluate, 1, model)

class MyModel3(object):
    def maximize(self, r):
        return max(r, 3)

dview['MyModel3'] = MyModel3

model = MyModel3()
lbv.apply_sync(evaluate, 0, model)

%%px --local
# the real model object is much more involved...
class MyModel4(object):
    def maximize(self, r):
        return max(r, 4)

model = MyModel4()
lbv.apply_sync(evaluate, 2, model)

class MyModel5(object):
    def maximize(self, r):
        return max(r, 5)

@parallel.require(MyModel5)
def evaluate(r, model):
    return model.maximize(r)

model = MyModel5()
lbv.apply_sync(evaluate, 2, model)