Python continuously parse console input

Question

I am writing a little Python script that parses the input from a QR reader (which is seen as a keyboard by the system).

At the moment I am using raw_input() but this function waits for an EOF/end-of-line symbol in order to submit the received string to the program. I am wondering if there is a way to continuously parse the input string and not just in chunks limited by a line end.

In practice: - is there a way in python to asynchronously and continuously parse a console input ? - is there a way to change raw_input() (or an equivalent function) to look for another character in order to submit the string read into the program?

You might try [`curses.window.getch`](http://docs.python.org/3/library/curses.html#curses.window.getch) in no-delay mode. — Gareth Rees, Dec 18 '13 at 15:56
What is responsible for handling IO with this device? I think you need to run that component in a subprocess — wim, Dec 18 '13 at 15:57
Does the QR reader driver software have an API function for retrieving individual characters? Also there may be an OS-dependent way to read single characters from input sources, like `msvcrt.getch()` on Windows for reading keyboard characters. — martineau, Dec 18 '13 at 16:14
maybe this helps: http://stackoverflow.com/questions/510357/python-read-a-single-character-from-the-user — shengy, Dec 18 '13 at 16:59

score 1 · Answer 1 · answered Dec 27 '13 at 08:19

It seems like you're generally trying to solve two problems:

Read input in chunks
Parse that input asynchronously

For the first part, it will vary greatly based on the specifics of the input function your calling, but for standard input you could use something like

sys.stdin.read(1)

As for parsing asynchronously, there are a number of approaches you could take. Python is synchronous, so you will necessarily have to involve some subprocess calls. Manually spawning a function using the subprocess library is one option. You could also use something like Redis or some lightweight job queue to pop input chunks on and have them read and processed by another background script. Finally, gevent is a very popular coroutine based library for spawning asynchronous processes. Using gevent, this whole set up would look something like this:

class QRLoader(object):
    def __init__(self):
        self.data = []

    def add_data(data):
        self.data.append(data)

        # if self._data constitutes a full QR code
        # do something with data
        gevent.spawn(parse_async)

def parse_async():
    # do something with qr_loader.data

qr_loader = QRLoader()

while True:
    data = sys.stdin.read(1)
    if data:
        qr_loader.add_data(data)

Python continuously parse console input

1 Answers1