0

I want to remote control a python application which uses urwid for the user interface.

My idea was to create a file, pass it's name as command line argument to the application and whenever I write to the file the application reads from that file.

Urwid's event loop has a method watch_file(fd, callback). This method is described as "Call callback() when fd has some data to read." This sounds exactly like what I want to have, but it causes an infinite loop. callback is executed as often as possible, despite the fact that the file is empty. Even if I delete the file, callback is still called.

#!/usr/bin/env python3

import urwid
import atexit

def onkeypress(key, size=None):
    if key == 'q':
        raise urwid.ExitMainLoop()
    text.set_text(key)

def onfilechange():
    text.set_text(cmdfile.read())
    # clear file so that I don't read already executed commands again
    # and don't run into an infinite loop - but I am doing that anyway
    with open(cmdfile.name, 'w') as f:
        pass

cmdfile = open('/tmp/cmd', 'rt')
atexit.register(cmdfile.close)

text = urwid.Text("hello world")
filler = urwid.Filler(text)
loop = urwid.MainLoop(filler, unhandled_input=onkeypress)
loop.watch_file(cmdfile, onfilechange)

if __name__ == '__main__':
    loop.run()

(My initial idea was to open the file only for reading instead of keeping it open all the time but fd has to be a file object, not a path.)

Urwid offers several different event loops. By default, SelectEventLoop is used. GLibEventLoop has the same behaviour, it runs into an infinite loop. AsyncioEventLoop instead throws an "operation not permitted" exception. TwistedEventLoop and TornadoEventLoop would need additional software to be installed.

I have considered using the independent watchdog library but it seems accessing the user interface from another thread would require to write a new loop, see this stack overflow question. The answer to that question recommends polling instead which I would prefer to avoid.

If urwid specifically provides a method to watch a file I cannot believe that it does not work in any implementation. So what am I doing wrong?

How do I react to a file change in a python/urwid application?

EDIT: I have tried using named pipes (and removed the code to clear the file) but visually it has the same behaviour: the app does not start. Audibly, however, there is a great difference: It does not go into the infinite loop until I write to the file. Before I write to the file callback is not called but the app is not started either, it just does nothing. After I write to the file, it behaves as described above for regular files.

jakun
  • 624
  • 5
  • 13

1 Answers1

0

I have found the following work around: read a named pipe in another thread, safe each line in a queue and poll in the UI thread to see if something is in the queue.

Create the named pipe with mkfifo /tmp/mypipe. Then write to it with echo >>/tmp/mypipe "some text".

#!/usr/bin/env python3

import os
import threading
import queue

import urwid


class App:

    POLL_TIME_S = .5

    def __init__(self):
        self.text = urwid.Text("hello world")
        self.filler = urwid.Filler(self.text)
        self.loop = urwid.MainLoop(self.filler, unhandled_input=self.onkeypress)


    def watch_pipe(self, path):
        self._cmd_pipe = path
        self.queue = queue.Queue()
        threading.Thread(target=self._read_pipe_thread, args=(path,)).start()
        self.loop.set_alarm_in(0, self._poll_queue)

    def _read_pipe_thread(self, path):
        while self._cmd_pipe:
            with open(path, 'rt') as pipe:
                for ln in pipe:
                    self.queue.put(ln)

        self.queue.put("!! EOF !!")

    def _poll_queue(self, loop, args):
        while not self.queue.empty():
            ln = self.queue.get()
            self.text.set_text(ln)
        self.loop.set_alarm_in(self.POLL_TIME_S, self._poll_queue)

    def close(self):
        path = self._cmd_pipe

        # stop reading
        self._cmd_pipe = None
        with open(path, 'wt') as pipe:
            pipe.write("")

        os.remove(path)


    def run(self):
        self.loop.run()


    def onkeypress(self, key, size=None):
        if key == 'q':
            raise urwid.ExitMainLoop()
        self.text.set_text(key)


if __name__ == '__main__':
    a = App()
    a.watch_pipe('/tmp/mypipe')
    a.run()
    a.close()
jakun
  • 624
  • 5
  • 13