Debugging a program with Python pdb is trivial. You just run import pdb;
pdb.set_trace() (or just breakpoint() introduced in Python 3.7), and the
debugger will take action.
However, when the program being debugged has a stdin redirection, this is a
source of trouble. This happens because your program may be reading, for
instance, input with input() (which comes from file because of the
redirection) and, when entering the debugger, it continues to read what is on
the file as commands to Pdb, which almost certainly is not what you want.
More specifically, Python uses sys.stdin for functions such as input(). The
pdb module, which contains Pdb class, uses the cmd module, which contains
Cmd. Cmd, by itself, uses input(), which is why you have the behaviour
described above. Pdb class accepts a stdin kwarg, but for Cmd to accept
stdin, you must set use_rawinput to False, which is only set by Pdb
when you also set stdout.
The most common shells has 3 file descriptors already passed to every command run from console, which are stdin (fd 0), stdout (fd 1) and stderr (fd 2). This comes from UNIX.
A common Python program reads its input (for instance, when you run input()
to read the content a user might type) from fd 0, which the shell is telling
stdin by default. When you run something like this
$ python3 <file.txt
the input of your program comes not from what you type, but from what it's in the file. In effect, the command above is the same as
$ python3 0<file.txt
at least for the most common shells.
So, to the solution. The first and the most obvious way is not to use stdin
redirection but to open the file normally with open(). In this case, the file
is hardcoded in the file. The second way is to read the file name from the
command-line interface, but involves more boilerplate than the next solution.
The third solution is to read from another fd other than the 3 default fd's already supplied by default (see above). So you can use something like this:
import sys
sys.stdin = open('/dev/fd/3')
When using the debugger, as said above, you have to specify you're going to use
stdin explicly. Otherwise, Pdb, which uses Cwd, will use what you set
sys.stdin to. So, instead of import pdb; pdb.set_trace() as suggested by
the documentation, do:
import pdb; pdb.Pdb(stdin=sys.__stdin__, stdout=sys.__stdout__).set_trace()
at the point you want to breakpoint. Don't forget to import sys if you didn't
already done.
sys.__stdin__ is what sys.stdin is set when you run Python. Now, on the
shell, to run your program, you do something like this:
$ python3 3<file.txt
and that's it. Now your program are reading the file from fd 3, and your fd 0
is freed to be used by Pdb.