| Current File : //proc/self/root/usr/share/doc/pexpect-2.3/doc/pexpect.html |
<!doctype html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html><head><title>Python: module pexpect</title>
</head><body bgcolor="#f0f0f8">
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="heading">
<tr bgcolor="#7799ee">
<td valign=bottom> <br>
<font color="#ffffff" face="helvetica, arial"> <br><big><big><strong>pexpect</strong></big></big> (version 2.3)</font></td
><td align=right valign=bottom
><font color="#ffffff" face="helvetica, arial"><a href=".">index</a><br><a href="file:/home/noah/pexpect/trunk/pexpect/pexpect.py">/home/noah/pexpect/trunk/pexpect/pexpect.py</a></font></td></tr></table>
<p><tt>Pexpect is a Python module for spawning child applications and controlling<br>
them automatically. Pexpect can be used for automating interactive applications<br>
such as ssh, ftp, passwd, telnet, etc. It can be used to a automate setup<br>
scripts for duplicating software package installations on different servers. It<br>
can be used for automated software testing. Pexpect is in the spirit of Don<br>
Libes' Expect, but Pexpect is pure Python. Other Expect-like modules for Python<br>
require TCL and Expect or require C extensions to be compiled. Pexpect does not<br>
use C, Expect, or TCL extensions. It should work on any platform that supports<br>
the standard Python pty module. The Pexpect interface focuses on ease of use so<br>
that simple tasks are easy.<br>
<br>
There are two main interfaces to Pexpect -- the function, <a href="#-run">run</a>() and the class,<br>
<a href="#spawn">spawn</a>. You can call the <a href="#-run">run</a>() function to execute a command and return the<br>
output. This is a handy replacement for os.system().<br>
<br>
For example::<br>
<br>
pexpect.<a href="#-run">run</a>('ls -la')<br>
<br>
The more powerful interface is the <a href="#spawn">spawn</a> class. You can use this to <a href="#spawn">spawn</a> an<br>
external child command and then interact with the child by sending lines and<br>
expecting responses.<br>
<br>
For example::<br>
<br>
child = pexpect.<a href="#spawn">spawn</a>('scp foo myname@host.example.com:.')<br>
child.expect ('Password:')<br>
child.sendline (mypassword)<br>
<br>
This works even for commands that ask for passwords or other input outside of<br>
the normal stdio streams.<br>
<br>
Credits: Noah Spurrier, Richard Holden, Marco Molteni, Kimberley Burchett,<br>
Robert Stone, Hartmut Goebel, Chad Schroeder, Erick Tryzelaar, Dave Kirby, Ids<br>
vander Molen, George Todd, Noel Taylor, Nicolas D. Cesar, Alexander Gattin,<br>
Geoffrey Marshall, Francisco Lourenco, Glen Mabey, Karthik Gurusamy, Fernando<br>
Perez, Corey Minyard, Jon Cohen, Guillaume Chazarain, Andrew Ryan, Nick<br>
Craig-Wood, Andrew Stone, Jorgen Grahn (Let me know if I forgot anyone.)<br>
<br>
Free, open source, and all that good stuff.<br>
<br>
Permission is hereby granted, free of charge, to any person obtaining a copy of<br>
this software and associated documentation files (the "Software"), to deal in<br>
the Software without restriction, including without limitation the rights to<br>
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies<br>
of the Software, and to permit persons to whom the Software is furnished to do<br>
so, subject to the following conditions:<br>
<br>
The above copyright notice and this permission notice shall be included in all<br>
copies or substantial portions of the Software.<br>
<br>
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR<br>
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,<br>
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE<br>
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER<br>
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,<br>
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE<br>
SOFTWARE.<br>
<br>
Pexpect Copyright (c) 2008 Noah Spurrier<br>
<a href="http://pexpect.sourceforge.net/">http://pexpect.sourceforge.net/</a><br>
<br>
$Id: pexpect.py 507 2007-12-27 02:40:52Z noah $</tt></p>
<p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#aa55cc">
<td colspan=3 valign=bottom> <br>
<font color="#fffff" face="helvetica, arial"><big><strong>Modules</strong></big></font></td></tr>
<tr><td bgcolor="#aa55cc"><tt> </tt></td><td> </td>
<td width="100%"><table width="100%" summary="list"><tr><td width="25%" valign=top><a href="errno.html">errno</a><br>
<a href="fcntl.html">fcntl</a><br>
<a href="os.html">os</a><br>
<a href="pty.html">pty</a><br>
</td><td width="25%" valign=top><a href="re.html">re</a><br>
<a href="resource.html">resource</a><br>
<a href="select.html">select</a><br>
<a href="signal.html">signal</a><br>
</td><td width="25%" valign=top><a href="string.html">string</a><br>
<a href="struct.html">struct</a><br>
<a href="sys.html">sys</a><br>
<a href="termios.html">termios</a><br>
</td><td width="25%" valign=top><a href="time.html">time</a><br>
<a href="traceback.html">traceback</a><br>
<a href="tty.html">tty</a><br>
<a href="types.html">types</a><br>
</td></tr></table></td></tr></table><p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ee77aa">
<td colspan=3 valign=bottom> <br>
<font color="#ffffff" face="helvetica, arial"><big><strong>Classes</strong></big></font></td></tr>
<tr><td bgcolor="#ee77aa"><tt> </tt></td><td> </td>
<td width="100%"><dl>
<dt><font face="helvetica, arial"><a href="__builtin__.html#object">__builtin__.object</a>
</font></dt><dd>
<dl>
<dt><font face="helvetica, arial"><a href="pexpect.html#spawn">spawn</a>
</font></dt></dl>
</dd>
<dt><font face="helvetica, arial"><a href="exceptions.html#Exception">exceptions.Exception</a>(<a href="exceptions.html#BaseException">exceptions.BaseException</a>)
</font></dt><dd>
<dl>
<dt><font face="helvetica, arial"><a href="pexpect.html#ExceptionPexpect">ExceptionPexpect</a>
</font></dt><dd>
<dl>
<dt><font face="helvetica, arial"><a href="pexpect.html#EOF">EOF</a>
</font></dt><dt><font face="helvetica, arial"><a href="pexpect.html#TIMEOUT">TIMEOUT</a>
</font></dt></dl>
</dd>
</dl>
</dd>
</dl>
<p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="EOF">class <strong>EOF</strong></a>(<a href="pexpect.html#ExceptionPexpect">ExceptionPexpect</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>Raised when <a href="#EOF">EOF</a> is read from a child. This usually means the child has exited.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="pexpect.html#EOF">EOF</a></dd>
<dd><a href="pexpect.html#ExceptionPexpect">ExceptionPexpect</a></dd>
<dd><a href="exceptions.html#Exception">exceptions.Exception</a></dd>
<dd><a href="exceptions.html#BaseException">exceptions.BaseException</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods inherited from <a href="pexpect.html#ExceptionPexpect">ExceptionPexpect</a>:<br>
<dl><dt><a name="EOF-__init__"><strong>__init__</strong></a>(self, value)</dt></dl>
<dl><dt><a name="EOF-__str__"><strong>__str__</strong></a>(self)</dt></dl>
<dl><dt><a name="EOF-get_trace"><strong>get_trace</strong></a>(self)</dt><dd><tt>This returns an abbreviated stack trace with lines that only concern<br>
the caller. In other words, the stack trace inside the Pexpect module<br>
is not included.</tt></dd></dl>
<hr>
Data descriptors inherited from <a href="pexpect.html#ExceptionPexpect">ExceptionPexpect</a>:<br>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="exceptions.html#Exception">exceptions.Exception</a>:<br>
<dl><dt><strong>__new__</strong> = <built-in method __new__ of type object at 0x81400e0><dd><tt>T.<a href="#EOF-__new__">__new__</a>(S, ...) -> a new <a href="__builtin__.html#object">object</a> with type S, a subtype of T</tt></dl>
<hr>
Methods inherited from <a href="exceptions.html#BaseException">exceptions.BaseException</a>:<br>
<dl><dt><a name="EOF-__delattr__"><strong>__delattr__</strong></a>(...)</dt><dd><tt>x.<a href="#EOF-__delattr__">__delattr__</a>('name') <==> del x.name</tt></dd></dl>
<dl><dt><a name="EOF-__getattribute__"><strong>__getattribute__</strong></a>(...)</dt><dd><tt>x.<a href="#EOF-__getattribute__">__getattribute__</a>('name') <==> x.name</tt></dd></dl>
<dl><dt><a name="EOF-__getitem__"><strong>__getitem__</strong></a>(...)</dt><dd><tt>x.<a href="#EOF-__getitem__">__getitem__</a>(y) <==> x[y]</tt></dd></dl>
<dl><dt><a name="EOF-__getslice__"><strong>__getslice__</strong></a>(...)</dt><dd><tt>x.<a href="#EOF-__getslice__">__getslice__</a>(i, j) <==> x[i:j]<br>
<br>
Use of negative indices is not supported.</tt></dd></dl>
<dl><dt><a name="EOF-__reduce__"><strong>__reduce__</strong></a>(...)</dt></dl>
<dl><dt><a name="EOF-__repr__"><strong>__repr__</strong></a>(...)</dt><dd><tt>x.<a href="#EOF-__repr__">__repr__</a>() <==> repr(x)</tt></dd></dl>
<dl><dt><a name="EOF-__setattr__"><strong>__setattr__</strong></a>(...)</dt><dd><tt>x.<a href="#EOF-__setattr__">__setattr__</a>('name', value) <==> x.name = value</tt></dd></dl>
<dl><dt><a name="EOF-__setstate__"><strong>__setstate__</strong></a>(...)</dt></dl>
<hr>
Data descriptors inherited from <a href="exceptions.html#BaseException">exceptions.BaseException</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
</dl>
<dl><dt><strong>args</strong></dt>
</dl>
<dl><dt><strong>message</strong></dt>
<dd><tt>exception message</tt></dd>
</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="ExceptionPexpect">class <strong>ExceptionPexpect</strong></a>(<a href="exceptions.html#Exception">exceptions.Exception</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>Base class for all exceptions raised by this module.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="pexpect.html#ExceptionPexpect">ExceptionPexpect</a></dd>
<dd><a href="exceptions.html#Exception">exceptions.Exception</a></dd>
<dd><a href="exceptions.html#BaseException">exceptions.BaseException</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="ExceptionPexpect-__init__"><strong>__init__</strong></a>(self, value)</dt></dl>
<dl><dt><a name="ExceptionPexpect-__str__"><strong>__str__</strong></a>(self)</dt></dl>
<dl><dt><a name="ExceptionPexpect-get_trace"><strong>get_trace</strong></a>(self)</dt><dd><tt>This returns an abbreviated stack trace with lines that only concern<br>
the caller. In other words, the stack trace inside the Pexpect module<br>
is not included.</tt></dd></dl>
<hr>
Data descriptors defined here:<br>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="exceptions.html#Exception">exceptions.Exception</a>:<br>
<dl><dt><strong>__new__</strong> = <built-in method __new__ of type object at 0x81400e0><dd><tt>T.<a href="#ExceptionPexpect-__new__">__new__</a>(S, ...) -> a new <a href="__builtin__.html#object">object</a> with type S, a subtype of T</tt></dl>
<hr>
Methods inherited from <a href="exceptions.html#BaseException">exceptions.BaseException</a>:<br>
<dl><dt><a name="ExceptionPexpect-__delattr__"><strong>__delattr__</strong></a>(...)</dt><dd><tt>x.<a href="#ExceptionPexpect-__delattr__">__delattr__</a>('name') <==> del x.name</tt></dd></dl>
<dl><dt><a name="ExceptionPexpect-__getattribute__"><strong>__getattribute__</strong></a>(...)</dt><dd><tt>x.<a href="#ExceptionPexpect-__getattribute__">__getattribute__</a>('name') <==> x.name</tt></dd></dl>
<dl><dt><a name="ExceptionPexpect-__getitem__"><strong>__getitem__</strong></a>(...)</dt><dd><tt>x.<a href="#ExceptionPexpect-__getitem__">__getitem__</a>(y) <==> x[y]</tt></dd></dl>
<dl><dt><a name="ExceptionPexpect-__getslice__"><strong>__getslice__</strong></a>(...)</dt><dd><tt>x.<a href="#ExceptionPexpect-__getslice__">__getslice__</a>(i, j) <==> x[i:j]<br>
<br>
Use of negative indices is not supported.</tt></dd></dl>
<dl><dt><a name="ExceptionPexpect-__reduce__"><strong>__reduce__</strong></a>(...)</dt></dl>
<dl><dt><a name="ExceptionPexpect-__repr__"><strong>__repr__</strong></a>(...)</dt><dd><tt>x.<a href="#ExceptionPexpect-__repr__">__repr__</a>() <==> repr(x)</tt></dd></dl>
<dl><dt><a name="ExceptionPexpect-__setattr__"><strong>__setattr__</strong></a>(...)</dt><dd><tt>x.<a href="#ExceptionPexpect-__setattr__">__setattr__</a>('name', value) <==> x.name = value</tt></dd></dl>
<dl><dt><a name="ExceptionPexpect-__setstate__"><strong>__setstate__</strong></a>(...)</dt></dl>
<hr>
Data descriptors inherited from <a href="exceptions.html#BaseException">exceptions.BaseException</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
</dl>
<dl><dt><strong>args</strong></dt>
</dl>
<dl><dt><strong>message</strong></dt>
<dd><tt>exception message</tt></dd>
</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="TIMEOUT">class <strong>TIMEOUT</strong></a>(<a href="pexpect.html#ExceptionPexpect">ExceptionPexpect</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>Raised when a read time exceeds the timeout.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="pexpect.html#TIMEOUT">TIMEOUT</a></dd>
<dd><a href="pexpect.html#ExceptionPexpect">ExceptionPexpect</a></dd>
<dd><a href="exceptions.html#Exception">exceptions.Exception</a></dd>
<dd><a href="exceptions.html#BaseException">exceptions.BaseException</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods inherited from <a href="pexpect.html#ExceptionPexpect">ExceptionPexpect</a>:<br>
<dl><dt><a name="TIMEOUT-__init__"><strong>__init__</strong></a>(self, value)</dt></dl>
<dl><dt><a name="TIMEOUT-__str__"><strong>__str__</strong></a>(self)</dt></dl>
<dl><dt><a name="TIMEOUT-get_trace"><strong>get_trace</strong></a>(self)</dt><dd><tt>This returns an abbreviated stack trace with lines that only concern<br>
the caller. In other words, the stack trace inside the Pexpect module<br>
is not included.</tt></dd></dl>
<hr>
Data descriptors inherited from <a href="pexpect.html#ExceptionPexpect">ExceptionPexpect</a>:<br>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="exceptions.html#Exception">exceptions.Exception</a>:<br>
<dl><dt><strong>__new__</strong> = <built-in method __new__ of type object at 0x81400e0><dd><tt>T.<a href="#TIMEOUT-__new__">__new__</a>(S, ...) -> a new <a href="__builtin__.html#object">object</a> with type S, a subtype of T</tt></dl>
<hr>
Methods inherited from <a href="exceptions.html#BaseException">exceptions.BaseException</a>:<br>
<dl><dt><a name="TIMEOUT-__delattr__"><strong>__delattr__</strong></a>(...)</dt><dd><tt>x.<a href="#TIMEOUT-__delattr__">__delattr__</a>('name') <==> del x.name</tt></dd></dl>
<dl><dt><a name="TIMEOUT-__getattribute__"><strong>__getattribute__</strong></a>(...)</dt><dd><tt>x.<a href="#TIMEOUT-__getattribute__">__getattribute__</a>('name') <==> x.name</tt></dd></dl>
<dl><dt><a name="TIMEOUT-__getitem__"><strong>__getitem__</strong></a>(...)</dt><dd><tt>x.<a href="#TIMEOUT-__getitem__">__getitem__</a>(y) <==> x[y]</tt></dd></dl>
<dl><dt><a name="TIMEOUT-__getslice__"><strong>__getslice__</strong></a>(...)</dt><dd><tt>x.<a href="#TIMEOUT-__getslice__">__getslice__</a>(i, j) <==> x[i:j]<br>
<br>
Use of negative indices is not supported.</tt></dd></dl>
<dl><dt><a name="TIMEOUT-__reduce__"><strong>__reduce__</strong></a>(...)</dt></dl>
<dl><dt><a name="TIMEOUT-__repr__"><strong>__repr__</strong></a>(...)</dt><dd><tt>x.<a href="#TIMEOUT-__repr__">__repr__</a>() <==> repr(x)</tt></dd></dl>
<dl><dt><a name="TIMEOUT-__setattr__"><strong>__setattr__</strong></a>(...)</dt><dd><tt>x.<a href="#TIMEOUT-__setattr__">__setattr__</a>('name', value) <==> x.name = value</tt></dd></dl>
<dl><dt><a name="TIMEOUT-__setstate__"><strong>__setstate__</strong></a>(...)</dt></dl>
<hr>
Data descriptors inherited from <a href="exceptions.html#BaseException">exceptions.BaseException</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
</dl>
<dl><dt><strong>args</strong></dt>
</dl>
<dl><dt><strong>message</strong></dt>
<dd><tt>exception message</tt></dd>
</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="spawn">class <strong>spawn</strong></a>(<a href="__builtin__.html#object">__builtin__.object</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>This is the main class interface for Pexpect. Use this class to start<br>
and control child applications.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%">Methods defined here:<br>
<dl><dt><a name="spawn-__del__"><strong>__del__</strong></a>(self)</dt><dd><tt>This makes sure that no system resources are left open. Python only<br>
garbage collects Python objects. OS file descriptors are not Python<br>
objects, so they must be handled explicitly. If the child file<br>
descriptor was opened outside of this class (passed to the constructor)<br>
then this does not close it.</tt></dd></dl>
<dl><dt><a name="spawn-__init__"><strong>__init__</strong></a>(self, command, args<font color="#909090">=[]</font>, timeout<font color="#909090">=30</font>, maxread<font color="#909090">=2000</font>, searchwindowsize<font color="#909090">=None</font>, logfile<font color="#909090">=None</font>, cwd<font color="#909090">=None</font>, env<font color="#909090">=None</font>)</dt><dd><tt>This is the constructor. The command parameter may be a string that<br>
includes a command and any arguments to the command. For example::<br>
<br>
child = pexpect.<a href="#spawn">spawn</a> ('/usr/bin/ftp')<br>
child = pexpect.<a href="#spawn">spawn</a> ('/usr/bin/ssh user@example.com')<br>
child = pexpect.<a href="#spawn">spawn</a> ('ls -latr /tmp')<br>
<br>
You may also construct it with a list of arguments like so::<br>
<br>
child = pexpect.<a href="#spawn">spawn</a> ('/usr/bin/ftp', [])<br>
child = pexpect.<a href="#spawn">spawn</a> ('/usr/bin/ssh', ['user@example.com'])<br>
child = pexpect.<a href="#spawn">spawn</a> ('ls', ['-latr', '/tmp'])<br>
<br>
After this the child application will be created and will be ready to<br>
talk to. For normal use, see <a href="#spawn-expect">expect</a>() and <a href="#spawn-send">send</a>() and <a href="#spawn-sendline">sendline</a>().<br>
<br>
Remember that Pexpect does NOT interpret shell meta characters such as<br>
redirect, pipe, or wild cards (>, |, or *). This is a common mistake.<br>
If you want to run a command and pipe it through another command then<br>
you must also start a shell. For example::<br>
<br>
child = pexpect.<a href="#spawn">spawn</a>('/bin/bash -c "ls -l | grep LOG > log_list.txt"')<br>
child.<a href="#spawn-expect">expect</a>(pexpect.<a href="#EOF">EOF</a>)<br>
<br>
The second form of <a href="#spawn">spawn</a> (where you pass a list of arguments) is useful<br>
in situations where you wish to <a href="#spawn">spawn</a> a command and pass it its own<br>
argument list. This can make syntax more clear. For example, the<br>
following is equivalent to the previous example::<br>
<br>
shell_cmd = 'ls -l | grep LOG > log_list.txt'<br>
child = pexpect.<a href="#spawn">spawn</a>('/bin/bash', ['-c', shell_cmd])<br>
child.<a href="#spawn-expect">expect</a>(pexpect.<a href="#EOF">EOF</a>)<br>
<br>
The maxread attribute sets the read buffer size. This is maximum number<br>
of bytes that Pexpect will try to read from a TTY at one time. Setting<br>
the maxread size to 1 will turn off buffering. Setting the maxread<br>
value higher may help performance in cases where large amounts of<br>
output are read back from the child. This feature is useful in<br>
conjunction with searchwindowsize.<br>
<br>
The searchwindowsize attribute sets the how far back in the incomming<br>
seach buffer Pexpect will search for pattern matches. Every time<br>
Pexpect reads some data from the child it will append the data to the<br>
incomming buffer. The default is to search from the beginning of the<br>
imcomming buffer each time new data is read from the child. But this is<br>
very inefficient if you are running a command that generates a large<br>
amount of data where you want to match The searchwindowsize does not<br>
effect the size of the incomming data buffer. You will still have<br>
access to the full buffer after <a href="#spawn-expect">expect</a>() returns.<br>
<br>
The logfile member turns on or off logging. All input and output will<br>
be copied to the given file <a href="__builtin__.html#object">object</a>. Set logfile to None to stop<br>
logging. This is the default. Set logfile to sys.stdout to echo<br>
everything to standard output. The logfile is flushed after each write.<br>
<br>
Example log input and output to a file::<br>
<br>
child = pexpect.<a href="#spawn">spawn</a>('some_command')<br>
fout = file('mylog.txt','w')<br>
child.logfile = fout<br>
<br>
Example log to stdout::<br>
<br>
child = pexpect.<a href="#spawn">spawn</a>('some_command')<br>
child.logfile = sys.stdout<br>
<br>
The logfile_read and logfile_send members can be used to separately log<br>
the input from the child and output sent to the child. Sometimes you<br>
don't want to see everything you write to the child. You only want to<br>
log what the child sends back. For example::<br>
<br>
child = pexpect.<a href="#spawn">spawn</a>('some_command')<br>
child.logfile_read = sys.stdout<br>
<br>
To separately log output sent to the child use logfile_send::<br>
<br>
self.<strong>logfile_send</strong> = fout<br>
<br>
The delaybeforesend helps overcome a weird behavior that many users<br>
were experiencing. The typical problem was that a user would <a href="#spawn-expect">expect</a>() a<br>
"Password:" prompt and then immediately call <a href="#spawn-sendline">sendline</a>() to send the<br>
password. The user would then see that their password was echoed back<br>
to them. Passwords don't normally echo. The problem is caused by the<br>
fact that most applications print out the "Password" prompt and then<br>
turn off stdin echo, but if you send your password before the<br>
application turned off echo, then you get your password echoed.<br>
Normally this wouldn't be a problem when interacting with a human at a<br>
real keyboard. If you introduce a slight delay just before writing then<br>
this seems to clear up the problem. This was such a common problem for<br>
many users that I decided that the default pexpect behavior should be<br>
to sleep just before writing to the child application. 1/20th of a<br>
second (50 ms) seems to be enough to clear up the problem. You can set<br>
delaybeforesend to 0 to return to the old behavior. Most Linux machines<br>
don't like this to be below 0.03. I don't know why.<br>
<br>
Note that <a href="#spawn">spawn</a> is clever about finding commands on your path.<br>
It uses the same logic that "which" uses to find executables.<br>
<br>
If you wish to get the exit status of the child you must call the<br>
<a href="#spawn-close">close</a>() method. The exit or signal status of the child will be stored<br>
in self.<strong>exitstatus</strong> or self.<strong>signalstatus</strong>. If the child exited normally<br>
then exitstatus will store the exit return code and signalstatus will<br>
be None. If the child was terminated abnormally with a signal then<br>
signalstatus will store the signal value and exitstatus will be None.<br>
If you need more detail you can also read the self.<strong>status</strong> member which<br>
stores the status returned by os.waitpid. You can interpret this using<br>
os.WIFEXITED/os.WEXITSTATUS or os.WIFSIGNALED/os.TERMSIG.</tt></dd></dl>
<dl><dt><a name="spawn-__iter__"><strong>__iter__</strong></a>(self)</dt><dd><tt>This is to support iterators over a file-like <a href="__builtin__.html#object">object</a>.</tt></dd></dl>
<dl><dt><a name="spawn-__str__"><strong>__str__</strong></a>(self)</dt><dd><tt>This returns a human-readable string that represents the state of<br>
the <a href="__builtin__.html#object">object</a>.</tt></dd></dl>
<dl><dt><a name="spawn-close"><strong>close</strong></a>(self, force<font color="#909090">=True</font>)</dt><dd><tt>This closes the connection with the child application. Note that<br>
calling <a href="#spawn-close">close</a>() more than once is valid. This emulates standard Python<br>
behavior with files. Set force to True if you want to make sure that<br>
the child is terminated (SIGKILL is sent if the child ignores SIGHUP<br>
and SIGINT).</tt></dd></dl>
<dl><dt><a name="spawn-compile_pattern_list"><strong>compile_pattern_list</strong></a>(self, patterns)</dt><dd><tt>This compiles a pattern-string or a list of pattern-strings.<br>
Patterns must be a StringType, <a href="#EOF">EOF</a>, <a href="#TIMEOUT">TIMEOUT</a>, SRE_Pattern, or a list of<br>
those. Patterns may also be None which results in an empty list (you<br>
might do this if waiting for an <a href="#EOF">EOF</a> or <a href="#TIMEOUT">TIMEOUT</a> condition without<br>
expecting any pattern).<br>
<br>
This is used by <a href="#spawn-expect">expect</a>() when calling <a href="#spawn-expect_list">expect_list</a>(). Thus <a href="#spawn-expect">expect</a>() is<br>
nothing more than::<br>
<br>
cpl = <a href="#spawn-compile_pattern_list">compile_pattern_list</a>(pl)<br>
return <a href="#spawn-expect_list">expect_list</a>(cpl, timeout)<br>
<br>
If you are using <a href="#spawn-expect">expect</a>() within a loop it may be more<br>
efficient to compile the patterns first and then call <a href="#spawn-expect_list">expect_list</a>().<br>
This avoid calls in a loop to <a href="#spawn-compile_pattern_list">compile_pattern_list</a>()::<br>
<br>
cpl = <a href="#spawn-compile_pattern_list">compile_pattern_list</a>(my_pattern)<br>
while some_condition:<br>
...<br>
i = <a href="#spawn-expect_list">expect_list</a>(clp, timeout)<br>
...</tt></dd></dl>
<dl><dt><a name="spawn-eof"><strong>eof</strong></a>(self)</dt><dd><tt>This returns True if the <a href="#EOF">EOF</a> exception was ever raised.</tt></dd></dl>
<dl><dt><a name="spawn-expect"><strong>expect</strong></a>(self, pattern, timeout<font color="#909090">=-1</font>, searchwindowsize<font color="#909090">=None</font>)</dt><dd><tt>This seeks through the stream until a pattern is matched. The<br>
pattern is overloaded and may take several types. The pattern can be a<br>
StringType, <a href="#EOF">EOF</a>, a compiled re, or a list of any of those types.<br>
Strings will be compiled to re types. This returns the index into the<br>
pattern list. If the pattern was not a list this returns index 0 on a<br>
successful match. This may raise exceptions for <a href="#EOF">EOF</a> or <a href="#TIMEOUT">TIMEOUT</a>. To<br>
avoid the <a href="#EOF">EOF</a> or <a href="#TIMEOUT">TIMEOUT</a> exceptions add <a href="#EOF">EOF</a> or <a href="#TIMEOUT">TIMEOUT</a> to the pattern<br>
list. That will cause expect to match an <a href="#EOF">EOF</a> or <a href="#TIMEOUT">TIMEOUT</a> condition<br>
instead of raising an exception.<br>
<br>
If you pass a list of patterns and more than one matches, the first match<br>
in the stream is chosen. If more than one pattern matches at that point,<br>
the leftmost in the pattern list is chosen. For example::<br>
<br>
# the input is 'foobar'<br>
index = p.expect (['bar', 'foo', 'foobar'])<br>
# returns 1 ('foo') even though 'foobar' is a "better" match<br>
<br>
Please note, however, that buffering can affect this behavior, since<br>
input arrives in unpredictable chunks. For example::<br>
<br>
# the input is 'foobar'<br>
index = p.expect (['foobar', 'foo'])<br>
# returns 0 ('foobar') if all input is available at once,<br>
# but returs 1 ('foo') if parts of the final 'bar' arrive late<br>
<br>
After a match is found the instance attributes 'before', 'after' and<br>
'match' will be set. You can see all the data read before the match in<br>
'before'. You can see the data that was matched in 'after'. The<br>
re.MatchObject used in the re match will be in 'match'. If an error<br>
occurred then 'before' will be set to all the data read so far and<br>
'after' and 'match' will be None.<br>
<br>
If timeout is -1 then timeout will be set to the self.<strong>timeout</strong> value.<br>
<br>
A list entry may be <a href="#EOF">EOF</a> or <a href="#TIMEOUT">TIMEOUT</a> instead of a string. This will<br>
catch these exceptions and return the index of the list entry instead<br>
of raising the exception. The attribute 'after' will be set to the<br>
exception type. The attribute 'match' will be None. This allows you to<br>
write code like this::<br>
<br>
index = p.expect (['good', 'bad', pexpect.<a href="#EOF">EOF</a>, pexpect.<a href="#TIMEOUT">TIMEOUT</a>])<br>
if index == 0:<br>
do_something()<br>
elif index == 1:<br>
do_something_else()<br>
elif index == 2:<br>
do_some_other_thing()<br>
elif index == 3:<br>
do_something_completely_different()<br>
<br>
instead of code like this::<br>
<br>
try:<br>
index = p.expect (['good', 'bad'])<br>
if index == 0:<br>
do_something()<br>
elif index == 1:<br>
do_something_else()<br>
except <a href="#EOF">EOF</a>:<br>
do_some_other_thing()<br>
except <a href="#TIMEOUT">TIMEOUT</a>:<br>
do_something_completely_different()<br>
<br>
These two forms are equivalent. It all depends on what you want. You<br>
can also just expect the <a href="#EOF">EOF</a> if you are waiting for all output of a<br>
child to finish. For example::<br>
<br>
p = pexpect.<a href="#spawn">spawn</a>('/bin/ls')<br>
p.expect (pexpect.<a href="#EOF">EOF</a>)<br>
print p.before<br>
<br>
If you are trying to optimize for speed then see <a href="#spawn-expect_list">expect_list</a>().</tt></dd></dl>
<dl><dt><a name="spawn-expect_exact"><strong>expect_exact</strong></a>(self, pattern_list, timeout<font color="#909090">=-1</font>, searchwindowsize<font color="#909090">=-1</font>)</dt><dd><tt>This is similar to <a href="#spawn-expect">expect</a>(), but uses plain string matching instead<br>
of compiled regular expressions in 'pattern_list'. The 'pattern_list'<br>
may be a string; a list or other sequence of strings; or <a href="#TIMEOUT">TIMEOUT</a> and<br>
<a href="#EOF">EOF</a>.<br>
<br>
This call might be faster than <a href="#spawn-expect">expect</a>() for two reasons: string<br>
searching is faster than RE matching and it is possible to limit the<br>
search to just the end of the input buffer.<br>
<br>
This method is also useful when you don't want to have to worry about<br>
escaping regular expression characters that you want to match.</tt></dd></dl>
<dl><dt><a name="spawn-expect_list"><strong>expect_list</strong></a>(self, pattern_list, timeout<font color="#909090">=-1</font>, searchwindowsize<font color="#909090">=-1</font>)</dt><dd><tt>This takes a list of compiled regular expressions and returns the<br>
index into the pattern_list that matched the child output. The list may<br>
also contain <a href="#EOF">EOF</a> or <a href="#TIMEOUT">TIMEOUT</a> (which are not compiled regular<br>
expressions). This method is similar to the <a href="#spawn-expect">expect</a>() method except that<br>
<a href="#spawn-expect_list">expect_list</a>() does not recompile the pattern list on every call. This<br>
may help if you are trying to optimize for speed, otherwise just use<br>
the <a href="#spawn-expect">expect</a>() method. This is called by <a href="#spawn-expect">expect</a>(). If timeout==-1 then<br>
the self.<strong>timeout</strong> value is used. If searchwindowsize==-1 then the<br>
self.<strong>searchwindowsize</strong> value is used.</tt></dd></dl>
<dl><dt><a name="spawn-expect_loop"><strong>expect_loop</strong></a>(self, searcher, timeout<font color="#909090">=-1</font>, searchwindowsize<font color="#909090">=-1</font>)</dt><dd><tt>This is the common loop used inside expect. The 'searcher' should be<br>
an instance of searcher_re or searcher_string, which describes how and what<br>
to search for in the input.<br>
<br>
See <a href="#spawn-expect">expect</a>() for other arguments, return value and exceptions.</tt></dd></dl>
<dl><dt><a name="spawn-fileno"><strong>fileno</strong></a>(self)</dt><dd><tt>This returns the file descriptor of the pty for the child.</tt></dd></dl>
<dl><dt><a name="spawn-flush"><strong>flush</strong></a>(self)</dt><dd><tt>This does nothing. It is here to support the interface for a<br>
File-like <a href="__builtin__.html#object">object</a>.</tt></dd></dl>
<dl><dt><a name="spawn-getecho"><strong>getecho</strong></a>(self)</dt><dd><tt>This returns the terminal echo mode. This returns True if echo is<br>
on or False if echo is off. Child applications that are expecting you<br>
to enter a password often set ECHO False. See <a href="#spawn-waitnoecho">waitnoecho</a>().</tt></dd></dl>
<dl><dt><a name="spawn-getwinsize"><strong>getwinsize</strong></a>(self)</dt><dd><tt>This returns the terminal window size of the child tty. The return<br>
value is a tuple of (rows, cols).</tt></dd></dl>
<dl><dt><a name="spawn-interact"><strong>interact</strong></a>(self, escape_character<font color="#909090">='<font color="#c040c0">\x1d</font>'</font>, input_filter<font color="#909090">=None</font>, output_filter<font color="#909090">=None</font>)</dt><dd><tt>This gives control of the child process to the interactive user (the<br>
human at the keyboard). Keystrokes are sent to the child process, and<br>
the stdout and stderr output of the child process is printed. This<br>
simply echos the child stdout and child stderr to the real stdout and<br>
it echos the real stdin to the child stdin. When the user types the<br>
escape_character this method will stop. The default for<br>
escape_character is ^]. This should not be confused with ASCII 27 --<br>
the ESC character. ASCII 29 was chosen for historical merit because<br>
this is the character used by 'telnet' as the escape character. The<br>
escape_character will not be sent to the child process.<br>
<br>
You may pass in optional input and output filter functions. These<br>
functions should take a string and return a string. The output_filter<br>
will be passed all the output from the child process. The input_filter<br>
will be passed all the keyboard input from the user. The input_filter<br>
is run BEFORE the check for the escape_character.<br>
<br>
Note that if you change the window size of the parent the SIGWINCH<br>
signal will not be passed through to the child. If you want the child<br>
window size to change when the parent's window size changes then do<br>
something like the following example::<br>
<br>
import pexpect, struct, fcntl, termios, signal, sys<br>
def sigwinch_passthrough (sig, data):<br>
s = struct.pack("HHHH", 0, 0, 0, 0)<br>
a = struct.unpack('hhhh', fcntl.ioctl(sys.stdout.<a href="#spawn-fileno">fileno</a>(), termios.TIOCGWINSZ , s))<br>
global p<br>
p.<a href="#spawn-setwinsize">setwinsize</a>(a[0],a[1])<br>
p = pexpect.<a href="#spawn">spawn</a>('/bin/bash') # Note this is global and used in sigwinch_passthrough.<br>
signal.signal(signal.SIGWINCH, sigwinch_passthrough)<br>
p.<a href="#spawn-interact">interact</a>()</tt></dd></dl>
<dl><dt><a name="spawn-isalive"><strong>isalive</strong></a>(self)</dt><dd><tt>This tests if the child process is running or not. This is<br>
non-blocking. If the child was terminated then this will read the<br>
exitstatus or signalstatus of the child. This returns True if the child<br>
process appears to be running or False if not. It can take literally<br>
SECONDS for Solaris to return the right status.</tt></dd></dl>
<dl><dt><a name="spawn-isatty"><strong>isatty</strong></a>(self)</dt><dd><tt>This returns True if the file descriptor is open and connected to a<br>
tty(-like) device, else False.</tt></dd></dl>
<dl><dt><a name="spawn-kill"><strong>kill</strong></a>(self, sig)</dt><dd><tt>This sends the given signal to the child application. In keeping<br>
with UNIX tradition it has a misleading name. It does not necessarily<br>
kill the child unless you send the right signal.</tt></dd></dl>
<dl><dt><a name="spawn-next"><strong>next</strong></a>(self)</dt><dd><tt>This is to support iterators over a file-like <a href="__builtin__.html#object">object</a>.</tt></dd></dl>
<dl><dt><a name="spawn-read"><strong>read</strong></a>(self, size<font color="#909090">=-1</font>)</dt><dd><tt>This reads at most "size" bytes from the file (less if the read hits<br>
<a href="#EOF">EOF</a> before obtaining size bytes). If the size argument is negative or<br>
omitted, read all data until <a href="#EOF">EOF</a> is reached. The bytes are returned as<br>
a string <a href="__builtin__.html#object">object</a>. An empty string is returned when <a href="#EOF">EOF</a> is encountered<br>
immediately.</tt></dd></dl>
<dl><dt><a name="spawn-read_nonblocking"><strong>read_nonblocking</strong></a>(self, size<font color="#909090">=1</font>, timeout<font color="#909090">=-1</font>)</dt><dd><tt>This reads at most size characters from the child application. It<br>
includes a timeout. If the read does not complete within the timeout<br>
period then a <a href="#TIMEOUT">TIMEOUT</a> exception is raised. If the end of file is read<br>
then an <a href="#EOF">EOF</a> exception will be raised. If a log file was set using<br>
<a href="#spawn-setlog">setlog</a>() then all data will also be written to the log file.<br>
<br>
If timeout is None then the read may block indefinitely. If timeout is -1<br>
then the self.<strong>timeout</strong> value is used. If timeout is 0 then the child is<br>
polled and if there was no data immediately ready then this will raise<br>
a <a href="#TIMEOUT">TIMEOUT</a> exception.<br>
<br>
The timeout refers only to the amount of time to read at least one<br>
character. This is not effected by the 'size' parameter, so if you call<br>
<a href="#spawn-read_nonblocking">read_nonblocking</a>(size=100, timeout=30) and only one character is<br>
available right away then one character will be returned immediately.<br>
It will not wait for 30 seconds for another 99 characters to come in.<br>
<br>
This is a wrapper around os.<a href="#spawn-read">read</a>(). It uses select.select() to<br>
implement the timeout.</tt></dd></dl>
<dl><dt><a name="spawn-readline"><strong>readline</strong></a>(self, size<font color="#909090">=-1</font>)</dt><dd><tt>This reads and returns one entire line. A trailing newline is kept<br>
in the string, but may be absent when a file ends with an incomplete<br>
line. Note: This <a href="#spawn-readline">readline</a>() looks for a \r\n pair even on UNIX<br>
because this is what the pseudo tty device returns. So contrary to what<br>
you may expect you will receive the newline as \r\n. An empty string<br>
is returned when <a href="#EOF">EOF</a> is hit immediately. Currently, the size argument is<br>
mostly ignored, so this behavior is not standard for a file-like<br>
<a href="__builtin__.html#object">object</a>. If size is 0 then an empty string is returned.</tt></dd></dl>
<dl><dt><a name="spawn-readlines"><strong>readlines</strong></a>(self, sizehint<font color="#909090">=-1</font>)</dt><dd><tt>This reads until <a href="#EOF">EOF</a> using <a href="#spawn-readline">readline</a>() and returns a list containing<br>
the lines thus read. The optional "sizehint" argument is ignored.</tt></dd></dl>
<dl><dt><a name="spawn-send"><strong>send</strong></a>(self, s)</dt><dd><tt>This sends a string to the child process. This returns the number of<br>
bytes written. If a log file was set then the data is also written to<br>
the log.</tt></dd></dl>
<dl><dt><a name="spawn-sendcontrol"><strong>sendcontrol</strong></a>(self, char)</dt><dd><tt>This sends a control character to the child such as Ctrl-C or<br>
Ctrl-D. For example, to send a Ctrl-G (ASCII 7)::<br>
<br>
child.<a href="#spawn-sendcontrol">sendcontrol</a>('g')<br>
<br>
See also, <a href="#spawn-sendintr">sendintr</a>() and <a href="#spawn-sendeof">sendeof</a>().</tt></dd></dl>
<dl><dt><a name="spawn-sendeof"><strong>sendeof</strong></a>(self)</dt><dd><tt>This sends an <a href="#EOF">EOF</a> to the child. This sends a character which causes<br>
the pending parent output buffer to be sent to the waiting child<br>
program without waiting for end-of-line. If it is the first character<br>
of the line, the <a href="#spawn-read">read</a>() in the user program returns 0, which signifies<br>
end-of-file. This means to work as expected a <a href="#spawn-sendeof">sendeof</a>() has to be<br>
called at the beginning of a line. This method does not send a newline.<br>
It is the responsibility of the caller to ensure the eof is sent at the<br>
beginning of a line.</tt></dd></dl>
<dl><dt><a name="spawn-sendintr"><strong>sendintr</strong></a>(self)</dt><dd><tt>This sends a SIGINT to the child. It does not require<br>
the SIGINT to be the first character on a line.</tt></dd></dl>
<dl><dt><a name="spawn-sendline"><strong>sendline</strong></a>(self, s<font color="#909090">=''</font>)</dt><dd><tt>This is like <a href="#spawn-send">send</a>(), but it adds a line feed (os.linesep). This<br>
returns the number of bytes written.</tt></dd></dl>
<dl><dt><a name="spawn-setecho"><strong>setecho</strong></a>(self, state)</dt><dd><tt>This sets the terminal echo mode on or off. Note that anything the<br>
child sent before the echo will be lost, so you should be sure that<br>
your input buffer is empty before you call <a href="#spawn-setecho">setecho</a>(). For example, the<br>
following will work as expected::<br>
<br>
p = pexpect.<a href="#spawn">spawn</a>('cat')<br>
p.sendline ('1234') # We will see this twice (once from tty echo and again from cat).<br>
p.expect (['1234'])<br>
p.expect (['1234'])<br>
p.<a href="#spawn-setecho">setecho</a>(False) # Turn off tty echo<br>
p.sendline ('abcd') # We will set this only once (echoed by cat).<br>
p.sendline ('wxyz') # We will set this only once (echoed by cat)<br>
p.expect (['abcd'])<br>
p.expect (['wxyz'])<br>
<br>
The following WILL NOT WORK because the lines sent before the setecho<br>
will be lost::<br>
<br>
p = pexpect.<a href="#spawn">spawn</a>('cat')<br>
p.sendline ('1234') # We will see this twice (once from tty echo and again from cat).<br>
p.<a href="#spawn-setecho">setecho</a>(False) # Turn off tty echo<br>
p.sendline ('abcd') # We will set this only once (echoed by cat).<br>
p.sendline ('wxyz') # We will set this only once (echoed by cat)<br>
p.expect (['1234'])<br>
p.expect (['1234'])<br>
p.expect (['abcd'])<br>
p.expect (['wxyz'])</tt></dd></dl>
<dl><dt><a name="spawn-setlog"><strong>setlog</strong></a>(self, fileobject)</dt><dd><tt>This method is no longer supported or allowed.</tt></dd></dl>
<dl><dt><a name="spawn-setmaxread"><strong>setmaxread</strong></a>(self, maxread)</dt><dd><tt>This method is no longer supported or allowed. I don't like getters<br>
and setters without a good reason.</tt></dd></dl>
<dl><dt><a name="spawn-setwinsize"><strong>setwinsize</strong></a>(self, r, c)</dt><dd><tt>This sets the terminal window size of the child tty. This will cause<br>
a SIGWINCH signal to be sent to the child. This does not change the<br>
physical window size. It changes the size reported to TTY-aware<br>
applications like vi or curses -- applications that respond to the<br>
SIGWINCH signal.</tt></dd></dl>
<dl><dt><a name="spawn-terminate"><strong>terminate</strong></a>(self, force<font color="#909090">=False</font>)</dt><dd><tt>This forces a child process to terminate. It starts nicely with<br>
SIGHUP and SIGINT. If "force" is True then moves onto SIGKILL. This<br>
returns True if the child was terminated. This returns False if the<br>
child could not be terminated.</tt></dd></dl>
<dl><dt><a name="spawn-wait"><strong>wait</strong></a>(self)</dt><dd><tt>This waits until the child exits. This is a blocking call. This will<br>
not read any data from the child, so this will block forever if the<br>
child has unread output and has terminated. In other words, the child<br>
may have printed output then called exit(); but, technically, the child<br>
is still alive until its output is read.</tt></dd></dl>
<dl><dt><a name="spawn-waitnoecho"><strong>waitnoecho</strong></a>(self, timeout<font color="#909090">=-1</font>)</dt><dd><tt>This waits until the terminal ECHO flag is set False. This returns<br>
True if the echo mode is off. This returns False if the ECHO flag was<br>
not set False before the timeout. This can be used to detect when the<br>
child is waiting for a password. Usually a child application will turn<br>
off echo mode when it is waiting for the user to enter a password. For<br>
example, instead of expecting the "password:" prompt you can wait for<br>
the child to set ECHO off::<br>
<br>
p = pexpect.<a href="#spawn">spawn</a> ('ssh user@example.com')<br>
p.<a href="#spawn-waitnoecho">waitnoecho</a>()<br>
p.<a href="#spawn-sendline">sendline</a>(mypassword)<br>
<br>
If timeout is None then this method to block forever until ECHO flag is<br>
False.</tt></dd></dl>
<dl><dt><a name="spawn-write"><strong>write</strong></a>(self, s)</dt><dd><tt>This is similar to <a href="#spawn-send">send</a>() except that there is no return value.</tt></dd></dl>
<dl><dt><a name="spawn-writelines"><strong>writelines</strong></a>(self, sequence)</dt><dd><tt>This calls <a href="#spawn-write">write</a>() for each element in the sequence. The sequence<br>
can be any iterable <a href="__builtin__.html#object">object</a> producing strings, typically a list of<br>
strings. This does not add line separators There is no return value.</tt></dd></dl>
<hr>
Data descriptors defined here:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
</td></tr></table></td></tr></table><p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#eeaa77">
<td colspan=3 valign=bottom> <br>
<font color="#ffffff" face="helvetica, arial"><big><strong>Functions</strong></big></font></td></tr>
<tr><td bgcolor="#eeaa77"><tt> </tt></td><td> </td>
<td width="100%"><dl><dt><a name="-run"><strong>run</strong></a>(command, timeout<font color="#909090">=-1</font>, withexitstatus<font color="#909090">=False</font>, events<font color="#909090">=None</font>, extra_args<font color="#909090">=None</font>, logfile<font color="#909090">=None</font>, cwd<font color="#909090">=None</font>, env<font color="#909090">=None</font>)</dt><dd><tt>This function runs the given command; waits for it to finish; then<br>
returns all output as a string. STDERR is included in output. If the full<br>
path to the command is not given then the path is searched.<br>
<br>
Note that lines are terminated by CR/LF (\r\n) combination even on<br>
UNIX-like systems because this is the standard for pseudo ttys. If you set<br>
'withexitstatus' to true, then run will return a tuple of (command_output,<br>
exitstatus). If 'withexitstatus' is false then this returns just<br>
command_output.<br>
<br>
The <a href="#-run">run</a>() function can often be used instead of creating a <a href="#spawn">spawn</a> instance.<br>
For example, the following code uses <a href="#spawn">spawn</a>::<br>
<br>
from pexpect import *<br>
child = <a href="#spawn">spawn</a>('scp foo myname@host.example.com:.')<br>
child.expect ('(?i)password')<br>
child.sendline (mypassword)<br>
<br>
The previous code can be replace with the following::<br>
<br>
from pexpect import *<br>
run ('scp foo myname@host.example.com:.', events={'(?i)password': mypassword})<br>
<br>
Examples<br>
========<br>
<br>
Start the apache daemon on the local machine::<br>
<br>
from pexpect import *<br>
run ("/usr/local/apache/bin/apachectl start")<br>
<br>
Check in a file using SVN::<br>
<br>
from pexpect import *<br>
run ("svn ci -m 'automatic commit' my_file.py")<br>
<br>
Run a command and capture exit status::<br>
<br>
from pexpect import *<br>
(command_output, exitstatus) = run ('ls -l /bin', withexitstatus=1)<br>
<br>
Tricky Examples<br>
===============<br>
<br>
The following will run SSH and execute 'ls -l' on the remote machine. The<br>
password 'secret' will be sent if the '(?i)password' pattern is ever seen::<br>
<br>
run ("ssh username@machine.example.com 'ls -l'", events={'(?i)password':'secret\n'})<br>
<br>
This will start mencoder to rip a video from DVD. This will also display<br>
progress ticks every 5 seconds as it runs. For example::<br>
<br>
from pexpect import *<br>
def print_ticks(d):<br>
print d['event_count'],<br>
run ("mencoder dvd://1 -o video.avi -oac copy -ovc copy", events={<a href="#TIMEOUT">TIMEOUT</a>:print_ticks}, timeout=5)<br>
<br>
The 'events' argument should be a dictionary of patterns and responses.<br>
Whenever one of the patterns is seen in the command out <a href="#-run">run</a>() will send the<br>
associated response string. Note that you should put newlines in your<br>
string if Enter is necessary. The responses may also contain callback<br>
functions. Any callback is function that takes a dictionary as an argument.<br>
The dictionary contains all the locals from the <a href="#-run">run</a>() function, so you can<br>
access the child <a href="#spawn">spawn</a> <a href="__builtin__.html#object">object</a> or any other variable defined in <a href="#-run">run</a>()<br>
(event_count, child, and extra_args are the most useful). A callback may<br>
return True to stop the current run process otherwise <a href="#-run">run</a>() continues until<br>
the next event. A callback may also return a string which will be sent to<br>
the child. 'extra_args' is not used by directly <a href="#-run">run</a>(). It provides a way to<br>
pass data to a callback function through <a href="#-run">run</a>() through the locals<br>
dictionary passed to a callback.</tt></dd></dl>
<dl><dt><a name="-split_command_line"><strong>split_command_line</strong></a>(command_line)</dt><dd><tt>This splits a command line into a list of arguments. It splits arguments<br>
on spaces, but handles embedded quotes, doublequotes, and escaped<br>
characters. It's impossible to do this with a regular expression, so I<br>
wrote a little state machine to parse the command line.</tt></dd></dl>
<dl><dt><a name="-which"><strong>which</strong></a>(filename)</dt><dd><tt>This takes a given filename; tries to find it in the environment path;<br>
then checks if it is executable. This returns the full path to the filename<br>
if found and executable. Otherwise this returns None.</tt></dd></dl>
</td></tr></table><p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#55aa55">
<td colspan=3 valign=bottom> <br>
<font color="#ffffff" face="helvetica, arial"><big><strong>Data</strong></big></font></td></tr>
<tr><td bgcolor="#55aa55"><tt> </tt></td><td> </td>
<td width="100%"><strong>__all__</strong> = ['ExceptionPexpect', 'EOF', 'TIMEOUT', 'spawn', 'run', 'which', 'split_command_line', '__version__', '__revision__']<br>
<strong>__revision__</strong> = '$Revision: 399 $'<br>
<strong>__version__</strong> = '2.3'</td></tr></table>
</body></html>