Handling Stdin before App start (Stdin read before App is started results in ParseError crash)

[yggdr]

A simple program like this

import sys

from textual.app import App
from textual.widgets import Label


class TestApp(App):
    def compose(self):
        yield Label("Running")


if __name__ == "__main__":
    sys.stdin.readlines()
    TestApp().run()

results in the app starting for a split second, then crashing saying that in _parser.py:81 a ParseError is raised because we have reached the end of file.

The documentation doesn't seem to mention anything regarding stdin or pipes or piping (at least not that I could seem to find with the search function), and here in the forums I have seen a few threads were it's detailed that textual reads from stdin during its lifetime, so using stdin while the app runs is a problem.
But using the readlines or read method on either sys.stdin or sys.__stdin__ or their buffer attribute always seems to somehow close stdin for textual, even though sys.stdin.readable() remains True.

Any help here is appreciated. Is this documented anywhere?

[TomJGooding]

Could you clarify your question with the command you're running and what you expect to happen?

[yggdr]

So sorry, I must have had a brainfart when posting earlier, leaving out the rest of the issue

I want to pipe into the program: echo somedata | my_textual_program.py. When I do this, I get

┌──╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮        
│ /home/yggdrasil/.virtualenvs/pipewelder-dev/lib/python3.11/site-packages/textual/drivers/linux_d │           
│ river.py:339 in _run_input_thread                                                                │           
│                                                                                                  │           
│   336 │   │   an exception                                                                       │           
│   337 │   │   """                                                                                │           
│   338 │   │   try:                                                                               │           
│ ❱ 339 │   │   │   self.run_input_thread()                                                        │           
│   340 │   │   except BaseException as error:                                                     │           
│   341 │   │   │   import rich.traceback                                                          │           
│   342                                                                                            │           
│                                                                                                  │           
│ /home/yggdrasil/.virtualenvs/pipewelder-dev/lib/python3.11/site-packages/textual/drivers/linux_d │           
│ river.py:379 in run_input_thread                                                                 │           
│                                                                                                  │           
│   376 │   │   │   │   │   │   unicode_data = decode(                                             │           
│   377 │   │   │   │   │   │   │   read(fileno, 1024), final=self.exit_event.is_set()             │           
│   378 │   │   │   │   │   │   )                                                                  │           
│ ❱ 379 │   │   │   │   │   │   for event in feed(unicode_data):                                   │           
│   380 │   │   │   │   │   │   │   self.process_event(event)                                      │           
│   381 │   │   finally:                                                                           │           
│   382 │   │   │   selector.close()                                                               │           
│                                                                                                  │           
│ /home/yggdrasil/.virtualenvs/pipewelder-dev/lib/python3.11/site-packages/textual/_parser.py:81   │           
│ in feed                                                                                          │           
│                                                                                                  │           
│    78 │   │   │   try:                                                                           │           
│    79 │   │   │   │   self._gen.send(self._buffer.getvalue())                                    │           
│    80 │   │   │   except StopIteration:                                                          │           
│ ❱  81 │   │   │   │   raise ParseError("end of file reached") from None                          │           
│    82 │   │   │   while self._tokens:                                                            │           
│    83 │   │   │   │   yield self._tokens.popleft()                                               │           
│    84                                                                                            │           
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯           
ParseError: end of file reached                                      

plus some output on the terminal like [?2026;2$y, and a slightly messed up terminal, so a reset is needed.

Running it directly instead, without a pipeline, makes the program wait for input, then after typing and hitting ctrl_d the program continues on as expected.

[TomJGooding]

Thanks for clarifying. I agree some documentation about how to pipe into Textual apps would definitely be useful.

I think that Toolong has some support for piping so worth having a look at the code there. But I'm afraid this is something I'm not really familiar with.

https://github.com/Textualize/toolong/blob/main/src/toolong/cli.py

[yggdr]

Thank you very much for the pointer. I see now that the problem is, that sys.stdin not being associated with a TTY (as is the case when you pipe into a program) prevents Textual polling stdin continuously for input. Toolong circumvents this by manually opening the controlling terminals stdin and passing that to a subprocess, in which it runs a copy of itself. It then does some polling/selector stuff of its own that I don't entirely understand yet.

I'll probably shelf the piping-into-the-program feature for now until I understand what is going on there. :(