Python: how to share an object instance across multiple invocations of a script

Question

I'm use a library which provides a python interface to an external program. This allows me to create:

foo = Foo()

The code above starts a new instance of the Foo program that I can control from within python.

I have a python scripts which needs to be invoked multiple times and depending on external parameters, tell a single instance of the external Foo program to do different things. Obvious I can't do

foo = Foo() everytime,

since that creates a new instance of Foo every time my script runs.

What I want to do is to create foo= Foo() once, and have multiple invocations share the same instance. Currently I'm thinkibng of just creating it once, serialize it, and have my scripts deserialize it. Does this approach work? Is there a better alternative?

Thanks!!

Answer 1

This can be done if you follow an approach similar to that given in this answer. Or you can use Pyro, which is compared to multiprocessing in this answer.

Answer 2

You might be able to use pickle. Here's a simple example:

import os, pickle

class Foo(object):
    def __init__(self, bar):
        self.bar = bar

# use previous pickled instance if found
if os.path.exists('foo.pickle'):
    with open('foo.pickle') as f:
        foo = pickle.load(f)
else:
    foo = Foo(42)

# print current foo.bar
print foo.bar

# change foo.bar and pickle
foo.bar = raw_input('new bar: ')
with open('foo.pickle', 'w') as f:
    pickle.dump(foo, f)

Answer 3

You can change the design so that Foo() just connects you to an existing process, and then you create a new function, call it startFoo() that you previously call once (or if Foo() fails). Even better would be to make the program that Foo() connects to a service that you connect to over a socket. You might also want to just switch to the multiprocessing module.