9

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!!

3 Answers 3

3

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.

Sign up to request clarification or add additional context in comments.

Comments

1

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)

3 Comments

I tried doing that actually, I got a message saying "Can't pickle 'lock' object: <thread.lock object at ... >". I'm looking into it now.
Yeah, it has limitations which you may/may not be able to work around to do what you want: docs.python.org/library/…
if you're using a lock, you probably need to take another path like sockets or pipes to provide locked access to your class
0

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.

1 Comment

Yeah I think that's what i'll have to do seeing as I can't serialize the the Foo object easily.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.