pty —- Pseudo-terminal utilities

Source code:Lib/pty.py

The pty module defines operations for handling the pseudo-terminalconcept: starting another process and being able to write to and read from itscontrolling terminal programmatically.

Because pseudo-terminal handling is highly platform dependent, there is code todo it only for Linux. (The Linux code is supposed to work on other platforms,but hasn't been tested yet.)

The pty module defines the following functions:

• pty.fork()
• Fork. Connect the child's controlling terminal to a pseudo-terminal. Returnvalue is (pid, fd). Note that the child gets pid 0, and the fd isinvalid. The parent's return value is the pid of the child, and fd is afile descriptor connected to the child's controlling terminal (and also to thechild's standard input and output).

• pty.openpty()
• Open a new pseudo-terminal pair, using os.openpty() if possible, oremulation code for generic Unix systems. Return a pair of file descriptors(master, slave), for the master and the slave end, respectively.

• pty.spawn(argv[, master_read[, stdin_read]])
• Spawn a process, and connect its controlling terminal with the currentprocess's standard io. This is often used to baffle programs which insist onreading from the controlling terminal. It is expected that the processspawned behind the pty will eventually terminate, and when it does _spawn_will return.

The functions master_read and stdin_read are passed a file descriptorwhich they should read from, and they should always return a byte string. Inorder to force spawn to return before the child process exits anOSError should be thrown.

The default implementation for both functions will read and return up to 1024bytes each time the function is called. The master_read callback is passedthe pseudoterminal’s master file descriptor to read output from the childprocess, and stdin_read is passed file descriptor 0, to read from theparent process's standard input.

Returning an empty byte string from either callback is interpreted as anend-of-file (EOF) condition, and that callback will not be called afterthat. If stdin_read signals EOF the controlling terminal can no longercommunicate with the parent process OR the child process. Unless the childprocess will quit without any input, spawn will then loop forever. Ifmaster_read signals EOF the same behavior results (on linux at least).

If both callbacks signal EOF then spawn will probably never return, unlessselect throws an error on your platform when passed three empty lists. Thisis a bug, documented in issue 26228.

在 3.4 版更改: spawn() now returns the status value from os.waitpid()on the child process.

示例

The following program acts like the Unix command script(1), using apseudo-terminal to record all input and output of a terminal session in a"typescript".

import argparse
import os
import pty
import sys
import time
 
parser = argparse.ArgumentParser()
parser.add_argument('-a', dest='append', action='store_true')
parser.add_argument('-p', dest='use_python', action='store_true')
parser.add_argument('filename', nargs='?', default='typescript')
options = parser.parse_args()
 
shell = sys.executable if options.use_python else os.environ.get('SHELL', 'sh')
filename = options.filename
mode = 'ab' if options.append else 'wb'
 
with open(filename, mode) as script:
    def read(fd):
        data = os.read(fd, 1024)
        script.write(data)
        return data
 
    print('Script started, file is', filename)
    script.write(('Script started on %s\n' % time.asctime()).encode())
 
    pty.spawn(shell, read)
 
    script.write(('Script done on %s\n' % time.asctime()).encode())
    print('Script done, file is', filename)