1 """Pexpect is a Python module for spawning child applications and controlling
2 them automatically. Pexpect can be used for automating interactive applications
3 such as ssh, ftp, passwd, telnet, etc. It can be used to a automate setup
4 scripts for duplicating software package installations on different servers. It
5 can be used for automated software testing. Pexpect is in the spirit of Don
6 Libes' Expect, but Pexpect is pure Python. Other Expect-like modules for Python
7 require TCL and Expect or require C extensions to be compiled. Pexpect does not
8 use C, Expect, or TCL extensions. It should work on any platform that supports
9 the standard Python pty module. The Pexpect interface focuses on ease of use so
10 that simple tasks are easy.
12 There are two main interfaces to Pexpect -- the function, run() and the class,
13 spawn. You can call the run() function to execute a command and return the
14 output. This is a handy replacement for os.system().
19 The more powerful interface is the spawn class. You can use this to spawn an
20 external child command and then interact with the child by sending lines and
24 child = pexpect.spawn('scp foo myname@host.example.com:.')
25 child.expect ('Password:')
26 child.sendline (mypassword)
28 This works even for commands that ask for passwords or other input outside of
29 the normal stdio streams.
32 Noah Spurrier, Richard Holden, Marco Molteni, Kimberley Burchett, Robert Stone,
33 Hartmut Goebel, Chad Schroeder, Erick Tryzelaar, Dave Kirby, Ids vander Molen,
34 George Todd, Noel Taylor, Nicolas D. Cesar, Alexander Gattin,
35 Geoffrey Marshall, Francisco Lourenco, Glen Mabey, Karthik Gurusamy,
37 (Let me know if I forgot anyone.)
39 Free, open source, and all that good stuff.
41 Permission is hereby granted, free of charge, to any person obtaining a copy of
42 this software and associated documentation files (the "Software"), to deal in
43 the Software without restriction, including without limitation the rights to
44 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
45 of the Software, and to permit persons to whom the Software is furnished to do
46 so, subject to the following conditions:
48 The above copyright notice and this permission notice shall be included in all
49 copies or substantial portions of the Software.
51 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
52 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
53 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
54 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
55 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
56 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
59 Pexpect Copyright (c) 2006 Noah Spurrier
60 http://pexpect.sourceforge.net/
63 $Date: 2006-05-31 20:07:18 -0700 (Wed, 31 May 2006) $
80 except ImportError, e:
81 raise ImportError (str(e) + """
82 A critical module was not found. Probably this operating system does not support it.
83 Pexpect is intended for UNIX-like operating systems.""")
86 __revision__ = '$Revision: 395 $'
87 __all__ = ['ExceptionPexpect', 'EOF', 'TIMEOUT', 'spawn', 'run', 'which', 'split_command_line',
88 '__version__', '__revision__']
90 # Exception classes used by this module.
91 class ExceptionPexpect(Exception):
92 """Base class for all exceptions raised by this module.
94 def __init__(self, value):
97 return str(self.value)
99 """This returns an abbreviated stack trace with lines that only concern the caller.
100 In other words, the stack trace inside the Pexpect module is not included.
102 tblist = traceback.extract_tb(sys.exc_info()[2])
103 tblist = filter(self.__filter_not_pexpect, tblist)
104 tblist = traceback.format_list(tblist)
105 return ''.join(tblist)
106 def __filter_not_pexpect(self, trace_list_item):
107 if trace_list_item[0].find('pexpect.py') == -1:
111 class EOF(ExceptionPexpect):
112 """Raised when EOF is read from a child.
114 class TIMEOUT(ExceptionPexpect):
115 """Raised when a read time exceeds the timeout.
117 ##class TIMEOUT_PATTERN(TIMEOUT):
118 ## """Raised when the pattern match time exceeds the timeout.
119 ## This is different than a read TIMEOUT because the child process may
120 ## give output, thus never give a TIMEOUT, but the output
121 ## may never match a pattern.
123 ##class MAXBUFFER(ExceptionPexpect):
124 ## """Raised when a scan buffer fills before matching an expected pattern."""
126 def run (command, timeout=-1, withexitstatus=False, events=None, extra_args=None, logfile=None):
127 """This function runs the given command; waits for it to finish;
128 then returns all output as a string. STDERR is included in output.
129 If the full path to the command is not given then the path is searched.
131 Note that lines are terminated by CR/LF (\\r\\n) combination
132 even on UNIX-like systems because this is the standard for pseudo ttys.
133 If you set withexitstatus to true, then run will return a tuple of
134 (command_output, exitstatus). If withexitstatus is false then this
135 returns just command_output.
137 The run() function can often be used instead of creating a spawn instance.
138 For example, the following code uses spawn:
139 from pexpect import *
140 child = spawn('scp foo myname@host.example.com:.')
141 child.expect ('(?i)password')
142 child.sendline (mypassword)
143 The previous code can be replace with the following, which you may
144 or may not find simpler:
145 from pexpect import *
146 run ('scp foo myname@host.example.com:.', events={'(?i)password': mypassword})
149 Start the apache daemon on the local machine:
150 from pexpect import *
151 run ("/usr/local/apache/bin/apachectl start")
152 Check in a file using SVN:
153 from pexpect import *
154 run ("svn ci -m 'automatic commit' my_file.py")
155 Run a command and capture exit status:
156 from pexpect import *
157 (command_output, exitstatus) = run ('ls -l /bin', withexitstatus=1)
160 The following will run SSH and execute 'ls -l' on the remote machine.
161 The password 'secret' will be sent if the '(?i)password' pattern is ever seen.
162 run ("ssh username@machine.example.com 'ls -l'", events={'(?i)password':'secret\n'})
164 This will start mencoder to rip a video from DVD. This will also display
165 progress ticks every 5 seconds as it runs.
166 from pexpect import *
168 print d['event_count'],
169 run ("mencoder dvd://1 -o video.avi -oac copy -ovc copy", events={TIMEOUT:print_ticks}, timeout=5)
171 The 'events' argument should be a dictionary of patterns and responses.
172 Whenever one of the patterns is seen in the command out
173 run() will send the associated response string. Note that you should
174 put newlines in your string if Enter is necessary.
175 The responses may also contain callback functions.
176 Any callback is function that takes a dictionary as an argument.
177 The dictionary contains all the locals from the run() function, so
178 you can access the child spawn object or any other variable defined
179 in run() (event_count, child, and extra_args are the most useful).
180 A callback may return True to stop the current run process otherwise
181 run() continues until the next event.
182 A callback may also return a string which will be sent to the child.
183 'extra_args' is not used by directly run(). It provides a way to pass data to
184 a callback function through run() through the locals dictionary passed to a callback.
187 child = spawn(command, maxread=2000, logfile=logfile)
189 child = spawn(command, timeout=timeout, maxread=2000, logfile=logfile)
190 if events is not None:
191 patterns = events.keys()
192 responses = events.values()
194 patterns=None # We assume that EOF or TIMEOUT will save us.
196 child_result_list = []
200 index = child.expect (patterns)
201 if type(child.after) is types.StringType:
202 child_result_list.append(child.before + child.after)
203 else: # child.after may have been a TIMEOUT or EOF, so don't cat those.
204 child_result_list.append(child.before)
205 if type(responses[index]) is types.StringType:
206 child.send(responses[index])
207 elif type(responses[index]) is types.FunctionType:
208 callback_result = responses[index](locals())
210 if type(callback_result) is types.StringType:
211 child.send(callback_result)
212 elif callback_result:
215 raise TypeError ('The callback must be a string or function type.')
216 event_count = event_count + 1
218 child_result_list.append(child.before)
221 child_result_list.append(child.before)
223 child_result = ''.join(child_result_list)
226 return (child_result, child.exitstatus)
230 class spawn (object):
231 """This is the main class interface for Pexpect.
232 Use this class to start and control child applications.
235 def __init__(self, command, args=[], timeout=30, maxread=2000, searchwindowsize=None, logfile=None, env=None):
236 """This is the constructor. The command parameter may be a string
237 that includes a command and any arguments to the command. For example:
238 p = pexpect.spawn ('/usr/bin/ftp')
239 p = pexpect.spawn ('/usr/bin/ssh user@example.com')
240 p = pexpect.spawn ('ls -latr /tmp')
241 You may also construct it with a list of arguments like so:
242 p = pexpect.spawn ('/usr/bin/ftp', [])
243 p = pexpect.spawn ('/usr/bin/ssh', ['user@example.com'])
244 p = pexpect.spawn ('ls', ['-latr', '/tmp'])
245 After this the child application will be created and
246 will be ready to talk to. For normal use, see expect() and
247 send() and sendline().
249 The maxread attribute sets the read buffer size.
250 This is maximum number of bytes that Pexpect will try to read
251 from a TTY at one time.
252 Seeting the maxread size to 1 will turn off buffering.
253 Setting the maxread value higher may help performance in cases
254 where large amounts of output are read back from the child.
255 This feature is useful in conjunction with searchwindowsize.
257 The searchwindowsize attribute sets the how far back in
258 the incomming seach buffer Pexpect will search for pattern matches.
259 Every time Pexpect reads some data from the child it will append the data to
260 the incomming buffer. The default is to search from the beginning of the
261 imcomming buffer each time new data is read from the child.
262 But this is very inefficient if you are running a command that
263 generates a large amount of data where you want to match
264 The searchwindowsize does not effect the size of the incomming data buffer.
265 You will still have access to the full buffer after expect() returns.
267 The logfile member turns on or off logging.
268 All input and output will be copied to the given file object.
269 Set logfile to None to stop logging. This is the default.
270 Set logfile to sys.stdout to echo everything to standard output.
271 The logfile is flushed after each write.
273 child = pexpect.spawn('some_command')
274 fout = file('mylog.txt','w')
277 child = pexpect.spawn('some_command')
278 child.logfile = sys.stdout
280 The delaybeforesend helps overcome a weird behavior that many users were experiencing.
281 The typical problem was that a user would expect() a "Password:" prompt and
282 then immediately call sendline() to send the password. The user would then
283 see that their password was echoed back to them. Passwords don't
284 normally echo. The problem is caused by the fact that most applications
285 print out the "Password" prompt and then turn off stdin echo, but if you
286 send your password before the application turned off echo, then you get
287 your password echoed. Normally this wouldn't be a problem when interacting
288 with a human at a real heyboard. If you introduce a slight delay just before
289 writing then this seems to clear up the problem. This was such a common problem
290 for many users that I decided that the default pexpect behavior
291 should be to sleep just before writing to the child application.
292 1/10th of a second (100 ms) seems to be enough to clear up the problem.
293 You can set delaybeforesend to 0 to return to the old behavior.
295 Note that spawn is clever about finding commands on your path.
296 It uses the same logic that "which" uses to find executables.
298 If you wish to get the exit status of the child you must call
299 the close() method. The exit or signal status of the child will be
300 stored in self.exitstatus or self.signalstatus.
301 If the child exited normally then exitstatus will store the exit return code and
302 signalstatus will be None.
303 If the child was terminated abnormally with a signal then signalstatus will store
304 the signal value and exitstatus will be None.
305 If you need more detail you can also read the self.status member which stores
306 the status returned by os.waitpid. You can interpret this using
307 os.WIFEXITED/os.WEXITSTATUS or os.WIFSIGNALED/os.TERMSIG.
309 self.STDIN_FILENO = pty.STDIN_FILENO
310 self.STDOUT_FILENO = pty.STDOUT_FILENO
311 self.STDERR_FILENO = pty.STDERR_FILENO
312 self.stdin = sys.stdin
313 self.stdout = sys.stdout
314 self.stderr = sys.stderr
317 self.ignorecase = False
321 self.match_index = None
322 self.terminated = True
323 self.exitstatus = None
324 self.signalstatus = None
325 self.status = None # status returned by os.waitpid
326 self.flag_eof = False
328 self.child_fd = -1 # initially closed
329 self.timeout = timeout
331 self.logfile = logfile
332 self.maxread = maxread # Max bytes to read at one time into buffer.
333 self.buffer = '' # This is the read buffer. See maxread.
334 self.searchwindowsize = searchwindowsize # Anything before searchwindowsize point is preserved, but not searched.
335 self.delaybeforesend = 0.1 # Sets sleep time used just before sending data to child.
336 self.delayafterclose = 0.1 # Sets delay in close() method to allow kernel time to update process status.
337 self.delayafterterminate = 0.1 # Sets delay in terminate() method to allow kernel time to update process status.
338 self.softspace = False # File-like object.
339 self.name = '<' + repr(self) + '>' # File-like object.
340 self.encoding = None # File-like object.
341 self.closed = True # File-like object.
343 self.__irix_hack = sys.platform.lower().find('irix') >= 0 # This flags if we are running on irix
344 self.use_native_pty_fork = not (sys.platform.lower().find('solaris') >= 0) # Solaris uses internal __fork_pty(). All other use pty.fork().
347 # allow dummy instances for subclasses that may not use command or args.
351 self.name = '<pexpect factory incomplete>'
354 # If command is an int type then it may represent a file descriptor.
355 if type(command) == type(0):
356 raise ExceptionPexpect ('Command is an int type. If this is a file descriptor then maybe you want to use fdpexpect.fdspawn which takes an existing file descriptor instead of a command string.')
358 if type (args) != type([]):
359 raise TypeError ('The argument, args, must be a list.')
362 self.args = split_command_line(command)
363 self.command = self.args[0]
365 self.args = args[:] # work with a copy
366 self.args.insert (0, command)
367 self.command = command
369 command_with_path = which(self.command)
370 if command_with_path is None:
371 raise ExceptionPexpect ('The command was not found or was not executable: %s.' % self.command)
372 self.command = command_with_path
373 self.args[0] = self.command
375 self.name = '<' + ' '.join (self.args) + '>'
379 """This makes sure that no system resources are left open.
380 Python only garbage collects Python objects. OS file descriptors
381 are not Python objects, so they must be handled explicitly.
382 If the child file descriptor was opened outside of this class
383 (passed to the constructor) then this does not close it.
389 """This returns the current state of the pexpect object as a string.
393 s.append('version: ' + __version__ + ' (' + __revision__ + ')')
394 s.append('command: ' + str(self.command))
395 s.append('args: ' + str(self.args))
396 if self.patterns is None:
397 s.append('patterns: None')
399 s.append('patterns:')
400 for p in self.patterns:
401 if type(p) is type(re.compile('')):
402 s.append(' ' + str(p.pattern))
404 s.append(' ' + str(p))
405 s.append('buffer (last 100 chars): ' + str(self.buffer)[-100:])
406 s.append('before (last 100 chars): ' + str(self.before)[-100:])
407 s.append('after: ' + str(self.after))
408 s.append('match: ' + str(self.match))
409 s.append('match_index: ' + str(self.match_index))
410 s.append('exitstatus: ' + str(self.exitstatus))
411 s.append('flag_eof: ' + str(self.flag_eof))
412 s.append('pid: ' + str(self.pid))
413 s.append('child_fd: ' + str(self.child_fd))
414 s.append('closed: ' + str(self.closed))
415 s.append('timeout: ' + str(self.timeout))
416 s.append('delimiter: ' + str(self.delimiter))
417 s.append('logfile: ' + str(self.logfile))
418 s.append('maxread: ' + str(self.maxread))
419 s.append('ignorecase: ' + str(self.ignorecase))
420 s.append('searchwindowsize: ' + str(self.searchwindowsize))
421 s.append('delaybeforesend: ' + str(self.delaybeforesend))
422 s.append('delayafterclose: ' + str(self.delayafterclose))
423 s.append('delayafterterminate: ' + str(self.delayafterterminate))
427 """This starts the given command in a child process.
428 This does all the fork/exec type of stuff for a pty.
429 This is called by __init__.
431 # The pid and child_fd of this object get set by this method.
432 # Note that it is difficult for this method to fail.
433 # You cannot detect if the child process cannot start.
434 # So the only way you can tell if the child process started
435 # or not is to try to read from the file descriptor. If you get
436 # EOF immediately then it means that the child is already dead.
437 # That may not necessarily be bad because you may haved spawned a child
438 # that performs some task; creates no stdout output; and then dies.
440 assert self.pid is None, 'The pid member should be None.'
441 assert self.command is not None, 'The command member should not be None.'
443 if self.use_native_pty_fork:
445 self.pid, self.child_fd = pty.fork()
447 raise ExceptionPexpect('Error! pty.fork() failed: ' + str(e))
448 else: # Use internal __fork_pty
449 self.pid, self.child_fd = self.__fork_pty()
451 if self.pid == 0: # Child
453 self.child_fd = sys.stdout.fileno() # used by setwinsize()
454 self.setwinsize(24, 80)
456 # Some platforms do not like setwinsize (Cygwin).
457 # This will cause problem when running applications that
458 # are very picky about window size.
459 # This is a serious limitation, but not a show stopper.
461 # Do not allow child to inherit open file descriptors from parent.
462 max_fd = resource.getrlimit(resource.RLIMIT_NOFILE)[0]
463 for i in range (3, max_fd):
469 # I don't know why this works, but ignoring SIGHUP fixes a
470 # problem when trying to start a Java daemon with sudo
471 # (specifically, Tomcat).
472 signal.signal(signal.SIGHUP, signal.SIG_IGN)
475 os.execv(self.command, self.args)
477 os.execvpe(self.command, self.args, self.env)
480 self.terminated = False
483 def __fork_pty(self):
484 """This implements a substitute for the forkpty system call.
485 This should be more portable than the pty.fork() function.
486 Specifically, this should work on Solaris.
488 Modified 10.06.05 by Geoff Marshall:
489 Implemented __fork_pty() method to resolve the issue with Python's
490 pty.fork() not supporting Solaris, particularly ssh.
491 Based on patch to posixmodule.c authored by Noah Spurrier:
492 http://mail.python.org/pipermail/python-dev/2003-May/035281.html
494 parent_fd, child_fd = os.openpty()
495 if parent_fd < 0 or child_fd < 0:
496 raise ExceptionPexpect, "Error! Could not open pty with os.openpty()."
500 raise ExceptionPexpect, "Error! Failed os.fork()."
504 self.__pty_make_controlling_tty(child_fd)
516 return pid, parent_fd
518 def __pty_make_controlling_tty(self, tty_fd):
519 """This makes the pseudo-terminal the controlling tty.
520 This should be more portable than the pty.fork() function.
521 Specifically, this should work on Solaris.
523 child_name = os.ttyname(tty_fd)
525 # Disconnect from controlling tty if still connected.
526 fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY);
532 # Verify we are disconnected from controlling tty
534 fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY);
537 raise ExceptionPexpect, "Error! We are not disconnected from a controlling tty."
539 # Good! We are disconnected from a controlling tty.
542 # Verify we can open child pty.
543 fd = os.open(child_name, os.O_RDWR);
545 raise ExceptionPexpect, "Error! Could not open child pty, " + child_name
549 # Verify we now have a controlling tty.
550 fd = os.open("/dev/tty", os.O_WRONLY)
552 raise ExceptionPexpect, "Error! Could not open controlling tty, /dev/tty"
556 def fileno (self): # File-like object.
557 """This returns the file descriptor of the pty for the child.
561 def close (self, force=True): # File-like object.
562 """This closes the connection with the child application.
563 Note that calling close() more than once is valid.
564 This emulates standard Python behavior with files.
565 Set force to True if you want to make sure that the child is terminated
566 (SIGKILL is sent if the child ignores SIGHUP and SIGINT).
570 os.close (self.child_fd)
573 time.sleep(self.delayafterclose) # Give kernel time to update process status.
575 if not self.terminate(force):
576 raise ExceptionPexpect ('close() could not terminate the child using terminate()')
578 def flush (self): # File-like object.
579 """This does nothing. It is here to support the interface for a File-like object.
583 def isatty (self): # File-like object.
584 """This returns True if the file descriptor is open and connected to a tty(-like) device, else False.
586 return os.isatty(self.child_fd)
588 def setecho (self, state):
589 """This sets the terminal echo mode on or off.
590 Note that anything the child sent before the echo will be lost, so
591 you should be sure that your input buffer is empty before you setecho.
592 For example, the following will work as expected.
593 p = pexpect.spawn('cat')
594 p.sendline ('1234') # We will see this twice (once from tty echo and again from cat).
597 p.setecho(False) # Turn off tty echo
598 p.sendline ('abcd') # We will set this only once (echoed by cat).
599 p.sendline ('wxyz') # We will set this only once (echoed by cat)
602 The following WILL NOT WORK because the lines sent before the setecho
604 p = pexpect.spawn('cat')
605 p.sendline ('1234') # We will see this twice (once from tty echo and again from cat).
606 p.setecho(False) # Turn off tty echo
607 p.sendline ('abcd') # We will set this only once (echoed by cat).
608 p.sendline ('wxyz') # We will set this only once (echoed by cat)
615 new = termios.tcgetattr(self.child_fd)
617 new[3] = new[3] | termios.ECHO
619 new[3] = new[3] & ~termios.ECHO
620 # I tried TCSADRAIN and TCSAFLUSH, but these were inconsistent
621 # and blocked on some platforms. TCSADRAIN is probably ideal if it worked.
622 termios.tcsetattr(self.child_fd, termios.TCSANOW, new)
624 def read_nonblocking (self, size = 1, timeout = -1):
625 """This reads at most size characters from the child application.
626 It includes a timeout. If the read does not complete within the
627 timeout period then a TIMEOUT exception is raised.
628 If the end of file is read then an EOF exception will be raised.
629 If a log file was set using setlog() then all data will
630 also be written to the log file.
632 If timeout==None then the read may block indefinitely.
633 If timeout==-1 then the self.timeout value is used.
634 If timeout==0 then the child is polled and
635 if there was no data immediately ready then this will raise a TIMEOUT exception.
637 The "timeout" refers only to the amount of time to read at least one character.
638 This is not effected by the 'size' parameter, so if you call
639 read_nonblocking(size=100, timeout=30) and only one character is
640 available right away then one character will be returned immediately.
641 It will not wait for 30 seconds for another 99 characters to come in.
643 This is a wrapper around os.read().
644 It uses select.select() to implement a timeout.
647 raise ValueError ('I/O operation on closed file in read_nonblocking().')
650 timeout = self.timeout
652 # Note that some systems such as Solaris do not give an EOF when
653 # the child dies. In fact, you can still try to read
654 # from the child_fd -- it will block forever or until TIMEOUT.
655 # For this case, I test isalive() before doing any reading.
656 # If isalive() is false, then I pretend that this is the same as EOF.
657 if not self.isalive():
658 r,w,e = self.__select([self.child_fd], [], [], 0) # timeout of 0 means "poll"
661 raise EOF ('End Of File (EOF) in read_nonblocking(). Braindead platform.')
662 elif self.__irix_hack:
663 # This is a hack for Irix. It seems that Irix requires a long delay before checking isalive.
664 # This adds a 2 second delay, but only when the child is terminated.
665 r, w, e = self.__select([self.child_fd], [], [], 2)
666 if not r and not self.isalive():
668 raise EOF ('End Of File (EOF) in read_nonblocking(). Pokey platform.')
670 r,w,e = self.__select([self.child_fd], [], [], timeout)
673 if not self.isalive():
674 # Some platforms, such as Irix, will claim that their processes are alive;
675 # then timeout on the select; and then finally admit that they are not alive.
677 raise EOF ('End of File (EOF) in read_nonblocking(). Very pokey platform.')
679 raise TIMEOUT ('Timeout exceeded in read_nonblocking().')
681 if self.child_fd in r:
683 s = os.read(self.child_fd, size)
684 except OSError, e: # Linux does this
686 raise EOF ('End Of File (EOF) in read_nonblocking(). Exception style platform.')
687 if s == '': # BSD style
689 raise EOF ('End Of File (EOF) in read_nonblocking(). Empty string style platform.')
691 if self.logfile is not None:
692 self.logfile.write (s)
697 raise ExceptionPexpect ('Reached an unexpected state in read_nonblocking().')
699 def read (self, size = -1): # File-like object.
700 """This reads at most "size" bytes from the file
701 (less if the read hits EOF before obtaining size bytes).
702 If the size argument is negative or omitted,
703 read all data until EOF is reached.
704 The bytes are returned as a string object.
705 An empty string is returned when EOF is encountered immediately.
710 self.expect (self.delimiter) # delimiter default is EOF
713 # I could have done this more directly by not using expect(), but
714 # I deliberately decided to couple read() to expect() so that
715 # I would catch any bugs early and ensure consistant behavior.
716 # It's a little less efficient, but there is less for me to
717 # worry about if I have to later modify read() or expect().
718 # Note, it's OK if size==-1 in the regex. That just means it
719 # will never match anything in which case we stop only on EOF.
720 cre = re.compile('.{%d}' % size, re.DOTALL)
721 index = self.expect ([cre, self.delimiter]) # delimiter default is EOF
723 return self.after ### self.before should be ''. Should I assert this?
726 def readline (self, size = -1): # File-like object.
727 """This reads and returns one entire line. A trailing newline is kept in
728 the string, but may be absent when a file ends with an incomplete line.
729 Note: This readline() looks for a \\r\\n pair even on UNIX because
730 this is what the pseudo tty device returns. So contrary to what you
731 may expect you will receive the newline as \\r\\n.
732 An empty string is returned when EOF is hit immediately.
733 Currently, the size agument is mostly ignored, so this behavior is not
734 standard for a file-like object. If size is 0 then an empty string
739 index = self.expect (['\r\n', self.delimiter]) # delimiter default is EOF
741 return self.before + '\r\n'
745 def __iter__ (self): # File-like object.
746 """This is to support iterators over a file-like object.
750 def next (self): # File-like object.
751 """This is to support iterators over a file-like object.
753 result = self.readline()
758 def readlines (self, sizehint = -1): # File-like object.
759 """This reads until EOF using readline() and returns a list containing
760 the lines thus read. The optional "sizehint" argument is ignored.
764 line = self.readline()
770 def write(self, str): # File-like object.
771 """This is similar to send() except that there is no return value.
775 def writelines (self, sequence): # File-like object.
776 """This calls write() for each element in the sequence.
777 The sequence can be any iterable object producing strings,
778 typically a list of strings. This does not add line separators
779 There is no return value.
785 """This sends a string to the child process.
786 This returns the number of bytes written.
787 If a log file was set then the data is also written to the log.
789 time.sleep(self.delaybeforesend)
790 if self.logfile is not None:
791 self.logfile.write (str)
793 c = os.write(self.child_fd, str)
796 def sendline(self, str=''):
797 """This is like send(), but it adds a line feed (os.linesep).
798 This returns the number of bytes written.
801 n = n + self.send (os.linesep)
805 """This sends an EOF to the child.
806 This sends a character which causes the pending parent output
807 buffer to be sent to the waiting child program without
808 waiting for end-of-line. If it is the first character of the
809 line, the read() in the user program returns 0, which
810 signifies end-of-file. This means to work as expected
811 a sendeof() has to be called at the begining of a line.
812 This method does not send a newline. It is the responsibility
813 of the caller to ensure the eof is sent at the beginning of a line.
815 ### Hmmm... how do I send an EOF?
816 ###C if ((m = write(pty, *buf, p - *buf)) < 0)
817 ###C return (errno == EWOULDBLOCK) ? n : -1;
818 fd = sys.stdin.fileno()
819 old = termios.tcgetattr(fd) # remember current state
820 new = termios.tcgetattr(fd)
821 new[3] = new[3] | termios.ICANON # ICANON must be set to recognize EOF
822 try: # use try/finally to ensure state gets restored
823 termios.tcsetattr(fd, termios.TCSADRAIN, new)
824 if 'CEOF' in dir(termios):
825 os.write (self.child_fd, '%c' % termios.CEOF)
827 os.write (self.child_fd, '%c' % 4) # Silly platform does not define CEOF so assume CTRL-D
828 finally: # restore state
829 termios.tcsetattr(fd, termios.TCSADRAIN, old)
832 """This returns True if the EOF exception was ever raised.
836 def terminate(self, force=False):
837 """This forces a child process to terminate.
838 It starts nicely with SIGHUP and SIGINT. If "force" is True then
840 This returns True if the child was terminated.
841 This returns False if the child could not be terminated.
843 if not self.isalive():
845 self.kill(signal.SIGHUP)
846 time.sleep(self.delayafterterminate)
847 if not self.isalive():
849 self.kill(signal.SIGCONT)
850 time.sleep(self.delayafterterminate)
851 if not self.isalive():
853 self.kill(signal.SIGINT)
854 time.sleep(self.delayafterterminate)
855 if not self.isalive():
858 self.kill(signal.SIGKILL)
859 time.sleep(self.delayafterterminate)
860 if not self.isalive():
865 #raise ExceptionPexpect ('terminate() could not terminate child process. Try terminate(force=True)?')
868 """This waits until the child exits. This is a blocking call.
869 This will not read any data from the child, so this will block forever
870 if the child has unread output and has terminated. In other words, the child
871 may have printed output then called exit(); but, technically, the child is
872 still alive until its output is read.
875 pid, status = os.waitpid(self.pid, 0)
877 raise ExceptionPexpect ('Cannot wait for dead child process.')
878 self.exitstatus = os.WEXITSTATUS(status)
879 if os.WIFEXITED (status):
881 self.exitstatus = os.WEXITSTATUS(status)
882 self.signalstatus = None
883 self.terminated = True
884 elif os.WIFSIGNALED (status):
886 self.exitstatus = None
887 self.signalstatus = os.WTERMSIG(status)
888 self.terminated = True
889 elif os.WIFSTOPPED (status):
890 raise ExceptionPexpect ('Wait was called for a child process that is stopped. This is not supported. Is some other process attempting job control with our child pid?')
891 return self.exitstatus
894 """This tests if the child process is running or not.
895 This is non-blocking. If the child was terminated then this
896 will read the exitstatus or signalstatus of the child.
897 This returns True if the child process appears to be running or False if not.
898 It can take literally SECONDS for Solaris to return the right status.
904 # This is for Linux, which requires the blocking form of waitpid to get
905 # status of a defunct process. This is super-lame. The flag_eof would have
906 # been set in read_nonblocking(), so this should be safe.
909 waitpid_options = os.WNOHANG
912 pid, status = os.waitpid(self.pid, waitpid_options)
913 except OSError, e: # No child processes
914 if e[0] == errno.ECHILD:
915 raise ExceptionPexpect ('isalive() encountered condition where "terminated" is 0, but there was no child process. Did someone else call waitpid() on our process?')
919 # I have to do this twice for Solaris. I can't even believe that I figured this out...
920 # If waitpid() returns 0 it means that no child process wishes to
921 # report, and the value of status is undefined.
924 pid, status = os.waitpid(self.pid, waitpid_options) ### os.WNOHANG) # Solaris!
925 except OSError, e: # This should never happen...
926 if e[0] == errno.ECHILD:
927 raise ExceptionPexpect ('isalive() encountered condition that should never happen. There was no child process. Did someone else call waitpid() on our process?')
931 # If pid is still 0 after two calls to waitpid() then
932 # the process really is alive. This seems to work on all platforms, except
933 # for Irix which seems to require a blocking call on waitpid or select, so I let read_nonblocking
934 # take care of this situation (unfortunately, this requires waiting through the timeout).
941 if os.WIFEXITED (status):
943 self.exitstatus = os.WEXITSTATUS(status)
944 self.signalstatus = None
945 self.terminated = True
946 elif os.WIFSIGNALED (status):
948 self.exitstatus = None
949 self.signalstatus = os.WTERMSIG(status)
950 self.terminated = True
951 elif os.WIFSTOPPED (status):
952 raise ExceptionPexpect ('isalive() encountered condition where child process is stopped. This is not supported. Is some other process attempting job control with our child pid?')
956 """This sends the given signal to the child application.
957 In keeping with UNIX tradition it has a misleading name.
958 It does not necessarily kill the child unless
959 you send the right signal.
961 # Same as os.kill, but the pid is given for you.
963 os.kill(self.pid, sig)
965 def compile_pattern_list(self, patterns):
966 """This compiles a pattern-string or a list of pattern-strings.
967 Patterns must be a StringType, EOF, TIMEOUT, SRE_Pattern, or
968 a list of those. Patterns may also be None which results in
971 This is used by expect() when calling expect_list().
972 Thus expect() is nothing more than::
973 cpl = self.compile_pattern_list(pl)
974 return self.expect_list(clp, timeout)
976 If you are using expect() within a loop it may be more
977 efficient to compile the patterns first and then call expect_list().
978 This avoid calls in a loop to compile_pattern_list():
979 cpl = self.compile_pattern_list(my_pattern)
980 while some_condition:
982 i = self.expect_list(clp, timeout)
987 if type(patterns) is not types.ListType:
988 patterns = [patterns]
990 compile_flags = re.DOTALL # Allow dot to match \n
992 compile_flags = compile_flags | re.IGNORECASE
993 compiled_pattern_list = []
995 if type(p) is types.StringType:
996 compiled_pattern_list.append(re.compile(p, compile_flags))
998 compiled_pattern_list.append(EOF)
1000 compiled_pattern_list.append(TIMEOUT)
1001 elif type(p) is type(re.compile('')):
1002 compiled_pattern_list.append(p)
1004 raise TypeError ('Argument must be one of StringType, EOF, TIMEOUT, SRE_Pattern, or a list of those type. %s' % str(type(p)))
1006 return compiled_pattern_list
1008 def expect(self, pattern, timeout = -1, searchwindowsize=None):
1010 """This seeks through the stream until a pattern is matched.
1011 The pattern is overloaded and may take several types including a list.
1012 The pattern can be a StringType, EOF, a compiled re, or a list of
1013 those types. Strings will be compiled to re types. This returns the
1014 index into the pattern list. If the pattern was not a list this
1015 returns index 0 on a successful match. This may raise exceptions for
1016 EOF or TIMEOUT. To avoid the EOF or TIMEOUT exceptions add
1017 EOF or TIMEOUT to the pattern list.
1019 After a match is found the instance attributes
1020 'before', 'after' and 'match' will be set.
1021 You can see all the data read before the match in 'before'.
1022 You can see the data that was matched in 'after'.
1023 The re.MatchObject used in the re match will be in 'match'.
1024 If an error occured then 'before' will be set to all the
1025 data read so far and 'after' and 'match' will be None.
1027 If timeout is -1 then timeout will be set to the self.timeout value.
1029 Note: A list entry may be EOF or TIMEOUT instead of a string.
1030 This will catch these exceptions and return the index
1031 of the list entry instead of raising the exception.
1032 The attribute 'after' will be set to the exception type.
1033 The attribute 'match' will be None.
1034 This allows you to write code like this:
1035 index = p.expect (['good', 'bad', pexpect.EOF, pexpect.TIMEOUT])
1041 do_some_other_thing()
1043 do_something_completely_different()
1044 instead of code like this:
1046 index = p.expect (['good', 'bad'])
1052 do_some_other_thing()
1054 do_something_completely_different()
1055 These two forms are equivalent. It all depends on what you want.
1056 You can also just expect the EOF if you are waiting for all output
1057 of a child to finish. For example:
1058 p = pexpect.spawn('/bin/ls')
1059 p.expect (pexpect.EOF)
1062 If you are trying to optimize for speed then see expect_list().
1064 compiled_pattern_list = self.compile_pattern_list(pattern)
1065 return self.expect_list(compiled_pattern_list, timeout, searchwindowsize)
1067 def expect_list(self, pattern_list, timeout = -1, searchwindowsize = -1):
1068 """This takes a list of compiled regular expressions and returns
1069 the index into the pattern_list that matched the child output.
1070 The list may also contain EOF or TIMEOUT (which are not
1071 compiled regular expressions). This method is similar to
1072 the expect() method except that expect_list() does not
1073 recompile the pattern list on every call.
1074 This may help if you are trying to optimize for speed, otherwise
1075 just use the expect() method. This is called by expect().
1076 If timeout==-1 then the self.timeout value is used.
1077 If searchwindowsize==-1 then the self.searchwindowsize value is used.
1080 self.patterns = pattern_list
1083 timeout = self.timeout
1084 if timeout is not None:
1085 end_time = time.time() + timeout
1086 if searchwindowsize == -1:
1087 searchwindowsize = self.searchwindowsize
1090 incoming = self.buffer
1091 while True: # Keep reading until exception or return.
1092 # Sequence through the list of patterns looking for a match.
1094 for cre in pattern_list:
1095 if cre is EOF or cre is TIMEOUT:
1096 continue # The patterns for PexpectExceptions are handled differently.
1097 if searchwindowsize is None: # search everything
1098 match = cre.search(incoming)
1100 startpos = max(0, len(incoming) - searchwindowsize)
1101 match = cre.search(incoming, startpos)
1104 if first_match > match.start() or first_match == -1:
1105 first_match = match.start()
1107 self.match_index = pattern_list.index(cre)
1108 if first_match > -1:
1109 self.buffer = incoming[self.match.end() : ]
1110 self.before = incoming[ : self.match.start()]
1111 self.after = incoming[self.match.start() : self.match.end()]
1112 #print "MATCH--", self.after, "--EOM"
1113 return self.match_index
1114 # No match at this point
1115 if timeout < 0 and timeout is not None:
1116 raise TIMEOUT ('Timeout exceeded in expect_list().')
1117 # Still have time left, so read more data
1118 c = self.read_nonblocking (self.maxread, timeout)
1120 incoming = incoming + c
1122 #print "INCOMING--", c, "--EOI"
1123 if timeout is not None:
1124 timeout = end_time - time.time()
1127 self.before = incoming
1129 if EOF in pattern_list:
1131 self.match_index = pattern_list.index(EOF)
1132 return self.match_index
1135 self.match_index = None
1136 raise EOF (str(e) + '\n' + str(self))
1138 self.before = incoming
1139 self.after = TIMEOUT
1140 if TIMEOUT in pattern_list:
1141 self.match = TIMEOUT
1142 self.match_index = pattern_list.index(TIMEOUT)
1143 return self.match_index
1146 self.match_index = None
1147 raise TIMEOUT (str(e) + '\n' + str(self))
1149 self.before = incoming
1152 self.match_index = None
1155 def getwinsize(self):
1156 """This returns the terminal window size of the child tty.
1157 The return value is a tuple of (rows, cols).
1159 if 'TIOCGWINSZ' in dir(termios):
1160 TIOCGWINSZ = termios.TIOCGWINSZ
1162 TIOCGWINSZ = 1074295912L # assume if not defined
1163 s = struct.pack('HHHH', 0, 0, 0, 0)
1164 x = fcntl.ioctl(self.fileno(), TIOCGWINSZ, s)
1165 return struct.unpack('HHHH', x)[0:2]
1167 def setwinsize(self, r, c):
1168 """This sets the terminal window size of the child tty.
1169 This will cause a SIGWINCH signal to be sent to the child.
1170 This does not change the physical window size.
1171 It changes the size reported to TTY-aware applications like
1172 vi or curses -- applications that respond to the SIGWINCH signal.
1174 # Check for buggy platforms. Some Python versions on some platforms
1175 # (notably OSF1 Alpha and RedHat 7.1) truncate the value for
1176 # termios.TIOCSWINSZ. It is not clear why this happens.
1177 # These platforms don't seem to handle the signed int very well;
1178 # yet other platforms like OpenBSD have a large negative value for
1179 # TIOCSWINSZ and they don't have a truncate problem.
1180 # Newer versions of Linux have totally different values for TIOCSWINSZ.
1181 # Note that this fix is a hack.
1182 if 'TIOCSWINSZ' in dir(termios):
1183 TIOCSWINSZ = termios.TIOCSWINSZ
1185 TIOCSWINSZ = -2146929561
1186 if TIOCSWINSZ == 2148037735L: # L is not required in Python >= 2.2.
1187 TIOCSWINSZ = -2146929561 # Same bits, but with sign.
1188 # Note, assume ws_xpixel and ws_ypixel are zero.
1189 s = struct.pack('HHHH', r, c, 0, 0)
1190 fcntl.ioctl(self.fileno(), TIOCSWINSZ, s)
1192 def interact(self, escape_character = chr(29), input_filter = None, output_filter = None):
1193 """This gives control of the child process to the interactive user
1194 (the human at the keyboard).
1195 Keystrokes are sent to the child process, and the stdout and stderr
1196 output of the child process is printed.
1197 This simply echos the child stdout and child stderr to the real
1198 stdout and it echos the real stdin to the child stdin.
1199 When the user types the escape_character this method will stop.
1200 The default for escape_character is ^]. This should not be confused
1201 with ASCII 27 -- the ESC character. ASCII 29 was chosen
1202 for historical merit because this is the character used
1203 by 'telnet' as the escape character. The escape_character will
1204 not be sent to the child process.
1206 You may pass in optional input and output filter functions.
1207 These functions should take a string and return a string.
1208 The output_filter will be passed all the output from the child process.
1209 The input_filter will be passed all the keyboard input from the user.
1210 The input_filter is run BEFORE the check for the escape_character.
1212 Note that if you change the window size of the parent
1213 the SIGWINCH signal will not be passed through to the child.
1214 If you want the child window size to change when the parent's
1215 window size changes then do something like the following example:
1216 import pexpect, struct, fcntl, termios, signal, sys
1217 def sigwinch_passthrough (sig, data):
1218 s = struct.pack("HHHH", 0, 0, 0, 0)
1219 a = struct.unpack('hhhh', fcntl.ioctl(sys.stdout.fileno(), termios.TIOCGWINSZ , s))
1221 p.setwinsize(a[0],a[1])
1222 p = pexpect.spawn('/bin/bash') # Note this is global and used in sigwinch_passthrough.
1223 signal.signal(signal.SIGWINCH, sigwinch_passthrough)
1227 self.stdout.write (self.buffer)
1230 mode = tty.tcgetattr(self.STDIN_FILENO)
1231 tty.setraw(self.STDIN_FILENO)
1233 self.__interact_copy(escape_character, input_filter, output_filter)
1235 tty.tcsetattr(self.STDIN_FILENO, tty.TCSAFLUSH, mode)
1237 def __interact_writen(self, fd, data):
1238 """This is used by the interact() method.
1240 while data != '' and self.isalive():
1241 n = os.write(fd, data)
1243 def __interact_read(self, fd):
1244 """This is used by the interact() method.
1246 return os.read(fd, 1000)
1247 def __interact_copy(self, escape_character = None, input_filter = None, output_filter = None):
1248 """This is used by the interact() method.
1250 while self.isalive():
1251 r,w,e = self.__select([self.child_fd, self.STDIN_FILENO], [], [])
1252 if self.child_fd in r:
1253 data = self.__interact_read(self.child_fd)
1254 if output_filter: data = output_filter(data)
1255 if self.logfile is not None:
1256 self.logfile.write (data)
1257 self.logfile.flush()
1258 os.write(self.STDOUT_FILENO, data)
1259 if self.STDIN_FILENO in r:
1260 data = self.__interact_read(self.STDIN_FILENO)
1261 if input_filter: data = input_filter(data)
1262 i = data.rfind(escape_character)
1265 self.__interact_writen(self.child_fd, data)
1267 self.__interact_writen(self.child_fd, data)
1268 def __select (self, iwtd, owtd, ewtd, timeout=None):
1269 """This is a wrapper around select.select() that ignores signals.
1270 If select.select raises a select.error exception and errno is an EINTR error then
1271 it is ignored. Mainly this is used to ignore sigwinch (terminal resize).
1273 # if select() is interrupted by a signal (errno==EINTR) then
1274 # we loop back and enter the select() again.
1275 if timeout is not None:
1276 end_time = time.time() + timeout
1279 return select.select (iwtd, owtd, ewtd, timeout)
1280 except select.error, e:
1281 if e[0] == errno.EINTR:
1282 # if we loop back we have to subtract the amount of time we already waited.
1283 if timeout is not None:
1284 timeout = end_time - time.time()
1287 else: # something else caused the select.error, so this really is an exception
1290 ##############################################################################
1291 # The following methods are no longer supported or allowed..
1292 def setmaxread (self, maxread):
1293 """This method is no longer supported or allowed.
1294 I don't like getters and setters without a good reason.
1296 raise ExceptionPexpect ('This method is no longer supported or allowed. Just assign a value to the maxread member variable.')
1297 def expect_exact (self, pattern_list, timeout = -1):
1298 """This method is no longer supported or allowed.
1299 It was too hard to maintain and keep it up to date with expect_list.
1300 Few people used this method. Most people favored reliability over speed.
1301 The implementation is left in comments in case anyone needs to hack this
1302 feature back into their copy.
1303 If someone wants to diff this with expect_list and make them work
1304 nearly the same then I will consider adding this make in.
1306 raise ExceptionPexpect ('This method is no longer supported or allowed.')
1307 def setlog (self, fileobject):
1308 """This method is no longer supported or allowed.
1310 raise ExceptionPexpect ('This method is no longer supported or allowed. Just assign a value to the logfile member variable.')
1312 ##############################################################################
1313 # End of spawn class
1314 ##############################################################################
1316 def which (filename):
1317 """This takes a given filename; tries to find it in the environment path;
1318 then checks if it is executable.
1319 This returns the full path to the filename if found and executable.
1320 Otherwise this returns None.
1322 # Special case where filename already contains a path.
1323 if os.path.dirname(filename) != '':
1324 if os.access (filename, os.X_OK):
1327 if not os.environ.has_key('PATH') or os.environ['PATH'] == '':
1330 p = os.environ['PATH']
1332 # Oddly enough this was the one line that made Pexpect
1333 # incompatible with Python 1.5.2.
1334 #pathlist = p.split (os.pathsep)
1335 pathlist = string.split (p, os.pathsep)
1337 for path in pathlist:
1338 f = os.path.join(path, filename)
1339 if os.access(f, os.X_OK):
1343 def split_command_line(command_line):
1344 """This splits a command line into a list of arguments.
1345 It splits arguments on spaces, but handles
1346 embedded quotes, doublequotes, and escaped characters.
1347 It's impossible to do this with a regular expression, so
1348 I wrote a little state machine to parse the command line.
1353 # Constants to name the states we can be in.
1356 state_singlequote = 2
1357 state_doublequote = 3
1358 state_whitespace = 4 # The state of consuming whitespace between commands.
1361 for c in command_line:
1362 if state == state_basic or state == state_whitespace:
1363 if c == '\\': # Escape the next character
1365 elif c == r"'": # Handle single quote
1366 state = state_singlequote
1367 elif c == r'"': # Handle double quote
1368 state = state_doublequote
1370 # Add arg to arg_list if we aren't in the middle of whitespace.
1371 if state == state_whitespace:
1374 arg_list.append(arg)
1376 state = state_whitespace
1380 elif state == state_esc:
1383 elif state == state_singlequote:
1388 elif state == state_doublequote:
1395 arg_list.append(arg)