文件操作 - pexpect.html
返回文件管理
返回主菜单
删除本文件
文件: /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>
修改文件时间
将文件时间修改为当前时间的前一年
删除文件