Pause Execution in Python

Question

I am implementing a Python plugin that is part of a larger C++ program. The goal of this program is to allow the user to input a command's actions in Python. It currently receives a string from the C++ function and runs it via the exec() function. The user can then use an API to affect changes on the larger C++ program.

The current feature I am working on is a pause execution feature. It needs to remember where it is in the code execution as well as the state of any local variables, and resume execution once a condition has been met. I am not very familiar with Python, and I would like some advice how to implement this feature. My first design ideas:

1) Using the yield command. This seemed to be a good idea at the start since when you use the next command it remembers everything I needed it to, but the problem is that yield only returns to the previous level in the call stack as far as I can tell. So if the user calls a function that yields it will simply return to the user's code, and not the larger C++ program. As far as I can tell there isn't a way to propagate the yield command up the stack???

2) Threading Create a main python thread that creates a thread for each command. This main thread would spawn a thread for each command executed and kill it when it is done. If it needs to be suspended and restarted it could do so through a queue of locks.

Those were the only two options I came up with. I am not sure the yield function would work or is what it was designed to do. I think the Threading approach would work but might be overkill, and take a long time to develop. I also was looking for some sort of Task Module in Python, but couldn't find exactly what I was looking for. I was wondering if anyone has any other suggestions as I am not very familiar with Python.

EDIT: As mentioned in the comments I did not explain what needs to happen when the script "Pauses". The python plugin needs to allow the C++ program to continue execution. In my mind this means A) returning if we are talking about a single threaded approach, or B) Sending a message(Function call?) to C++

EDIT EDIT: As stated I didn't fully explain the problem description. I will make another post that has a better statement of what currently exists, and what needs to happen as well as providing some sudo code. I am new to Stack Overflow, so if this is not the appropriate response please let me know.

Answer 1

Whenever a signal is sent in Python, execution is immediately paused until whatever signal handler function is being used is finished executing; at that point, the execution continues right where it left off. My suggestion would be to use one of the user-defined signals ( signal.SIGUSR1 and signal.SIGUSR2 ). Take a look at the signal documentation here:

https://docs.python.org/2/library/signal.html

At the beginning of the program, you'd define a signal handler function like so:

def signal_pause(signum, frame):
  if signum == signal.SIGUSR1:
    # Do your pause here - function processing, etc
  else:
    pass

Then in the main program somewhere, you'll switch out the default signal handler for the one you just created:

signal.signal(signal.SIGUSR1, signal_pause)

And finally, whenever you want to pause, you'll send the SIGUSR1 signal like so:

os.kill(os.getpid(),signal.SIGUSR1)

Your code will immediately pause, saving its state, and head to the signal_pause function to do whatever you need to do. Once that function exits, normal program execution will resume.

EDIT: this assumes you want to do something sophisticated while you're pausing the program. If all you want to do is wait a few seconds or ask for some user input, there are some much easier ways ( time.sleep or input respectively).

EDIT EDIT: this assumes you're on a Unix system.

Answer 2

If you need to communicate with a C program, then sockets are probably the way to go.

https://docs.python.org/2/library/socket.html

One of your two programs acts as the socket server, and the other connects to it as the socket client. When you want the C++ program to continue, you use socket.send() to transmit a continue message. Then your Python program would use socket.recv() , which will cause it to wait around until it receives a message back from the C++ program.

If you need two programs to send signals to each other, this is probably the safest way to go about it.