CODEWITHSUNDEEP
pythonmultithreadingiopipestdin
dcfg
dcfg

Reputation: 891

python - force input() to read newline character from a different thread and forward execution

I want to figure out a way to programmatically avoid the builtin input() method stopping and waiting for user input. Here is a snippet showing what I'm trying to do:

import sys
from threading import Thread

def kill_input():
    sys.stdout.write('\n')
    sys.stdout.flush()   # just to make sure the output is really written to stdout and not bufferized

t = Thread(target=kill_input)
t.start()
foo = input('Press some key')
print('input() method has been bypassed')

Expected behavior: the script executes and terminates without waiting for enter key to be pressed.

On the contrary, what's happening is the program stopping to wait for user entering some input.

In my thoughts input() should read the newline character ('\n') printed on stdout by the other thread and terminates by executing the final print statement. That thread should simulate a user pressing the enter key. I do not understand what's going on behind

Maybe one other possible way is to close the stdin file descriptor from the non-main thread and catching the exception on the main one.

def kill_input():
    sys.stdin.close()

Possibly I would like to avoid this option and rather understand what's going on behind this logic and find a way to force the main thread to read some mock characters from the stdin.

Edit - using subprocess module

Based on these related posts I've had a look to the subprocess module. I've thought this is the case for the Popen class to come in handy, so I've modified my script to exploit pipes

import sys
from subprocess import Popen, PIPE

def kill_input():
     proc = Popen(['python3', '-c', 'pass'], stdin=PIPE)
     proc.stdin.write('some text just to force parent proc to read'.encode())
     proc.stdin.flush()
     proc.stdin.close()
 
t = Thread(target=kill_input)
t.start()
sys.stdin.read()
print('input() method has been bypassed')

From my understanding, that should create a process with the Popen (the commend python3 -c 'pass' acts like a placeholder) whose (should?) stdin is a unix pipe opened with the parent process. What I'm expecting is anything written to the child process stdin to go straight to the stdin of the parent in order to be read by the sys.stdin.read(). So the program shouldn't stop to wait for any user input and it should terminates instantly. Unfortunately, it doesn't happen and the script still waits for me pressing enter. I cannot really find out a workaround for this.

[Python version: 3.8.5]

Upvotes: 3

Views: 224

Answers (1)

xavc
xavc

Reputation: 1295

In your first piece of code, you were writing to sys.stdout, which by default won't effect the contents of sys.stdin. Also, by default, you can't directly write to sys.stdin, but you can change it to a different file. To do this, you can use os.pipe(), which will return a tuple of a file descriptor for reading from the new pipe, and a file descriptor for writing to the pipe.

We can then use os.fdopen on these file descriptors, and assign sys.stdin to the read end of the pipe, while in another thread we write to the other end of the pipe.

import sys
import os
from threading import Thread

fake_stdin_read_fd, fake_stdin_write_fd = os.pipe()
fake_stdin_read = os.fdopen(fake_stdin_read_fd, 'r')
fake_stdin_write = os.fdopen(fake_stdin_write_fd, 'w')
sys.stdin = fake_stdin_read

def kill_input():
    fake_stdin_write.write('hello\n')
    fake_stdin_write.flush()

thread = Thread(target=kill_input)
thread.start()

input()
print('input() method has been bypassed!')

Upvotes: 1

Related Questions