##// END OF EJS Templates
substitute open(...) for file(...)...
Brandon Parsons -
Show More

The requested changes are too big and content was truncated. Show full diff

1 NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
@@ -1,340 +1,340 b''
1 1 # encoding: utf-8
2 2 """
3 3 Paging capabilities for IPython.core
4 4
5 5 Authors:
6 6
7 7 * Brian Granger
8 8 * Fernando Perez
9 9
10 10 Notes
11 11 -----
12 12
13 13 For now this uses ipapi, so it can't be in IPython.utils. If we can get
14 14 rid of that dependency, we could move it there.
15 15 -----
16 16 """
17 17
18 18 #-----------------------------------------------------------------------------
19 19 # Copyright (C) 2008-2011 The IPython Development Team
20 20 #
21 21 # Distributed under the terms of the BSD License. The full license is in
22 22 # the file COPYING, distributed as part of this software.
23 23 #-----------------------------------------------------------------------------
24 24
25 25 #-----------------------------------------------------------------------------
26 26 # Imports
27 27 #-----------------------------------------------------------------------------
28 28
29 29 import os
30 30 import re
31 31 import sys
32 32 import tempfile
33 33
34 34 from io import UnsupportedOperation
35 35
36 36 from IPython.core import ipapi
37 37 from IPython.core.error import TryNext
38 38 from IPython.utils.cursesimport import use_curses
39 39 from IPython.utils.data import chop
40 40 from IPython.utils import io
41 41 from IPython.utils.process import system
42 42 from IPython.utils.terminal import get_terminal_size
43 43
44 44
45 45 #-----------------------------------------------------------------------------
46 46 # Classes and functions
47 47 #-----------------------------------------------------------------------------
48 48
49 49 esc_re = re.compile(r"(\x1b[^m]+m)")
50 50
51 51 def page_dumb(strng, start=0, screen_lines=25):
52 52 """Very dumb 'pager' in Python, for when nothing else works.
53 53
54 54 Only moves forward, same interface as page(), except for pager_cmd and
55 55 mode."""
56 56
57 57 out_ln = strng.splitlines()[start:]
58 58 screens = chop(out_ln,screen_lines-1)
59 59 if len(screens) == 1:
60 60 print >>io.stdout, os.linesep.join(screens[0])
61 61 else:
62 62 last_escape = ""
63 63 for scr in screens[0:-1]:
64 64 hunk = os.linesep.join(scr)
65 65 print >>io.stdout, last_escape + hunk
66 66 if not page_more():
67 67 return
68 68 esc_list = esc_re.findall(hunk)
69 69 if len(esc_list) > 0:
70 70 last_escape = esc_list[-1]
71 71 print >>io.stdout, last_escape + os.linesep.join(screens[-1])
72 72
73 73 def _detect_screen_size(use_curses, screen_lines_def):
74 74 """Attempt to work out the number of lines on the screen.
75 75
76 76 This is called by page(). It can raise an error (e.g. when run in the
77 77 test suite), so it's separated out so it can easily be called in a try block.
78 78 """
79 79 TERM = os.environ.get('TERM',None)
80 80 if (TERM=='xterm' or TERM=='xterm-color') and sys.platform != 'sunos5':
81 81 local_use_curses = use_curses
82 82 else:
83 83 # curses causes problems on many terminals other than xterm, and
84 84 # some termios calls lock up on Sun OS5.
85 85 local_use_curses = False
86 86 if local_use_curses:
87 87 import termios
88 88 import curses
89 89 # There is a bug in curses, where *sometimes* it fails to properly
90 90 # initialize, and then after the endwin() call is made, the
91 91 # terminal is left in an unusable state. Rather than trying to
92 92 # check everytime for this (by requesting and comparing termios
93 93 # flags each time), we just save the initial terminal state and
94 94 # unconditionally reset it every time. It's cheaper than making
95 95 # the checks.
96 96 term_flags = termios.tcgetattr(sys.stdout)
97 97
98 98 # Curses modifies the stdout buffer size by default, which messes
99 99 # up Python's normal stdout buffering. This would manifest itself
100 100 # to IPython users as delayed printing on stdout after having used
101 101 # the pager.
102 102 #
103 103 # We can prevent this by manually setting the NCURSES_NO_SETBUF
104 104 # environment variable. For more details, see:
105 105 # http://bugs.python.org/issue10144
106 106 NCURSES_NO_SETBUF = os.environ.get('NCURSES_NO_SETBUF', None)
107 107 os.environ['NCURSES_NO_SETBUF'] = ''
108 108
109 109 # Proceed with curses initialization
110 110 scr = curses.initscr()
111 111 screen_lines_real,screen_cols = scr.getmaxyx()
112 112 curses.endwin()
113 113
114 114 # Restore environment
115 115 if NCURSES_NO_SETBUF is None:
116 116 del os.environ['NCURSES_NO_SETBUF']
117 117 else:
118 118 os.environ['NCURSES_NO_SETBUF'] = NCURSES_NO_SETBUF
119 119
120 120 # Restore terminal state in case endwin() didn't.
121 121 termios.tcsetattr(sys.stdout,termios.TCSANOW,term_flags)
122 122 # Now we have what we needed: the screen size in rows/columns
123 123 return screen_lines_real
124 124 #print '***Screen size:',screen_lines_real,'lines x',\
125 125 #screen_cols,'columns.' # dbg
126 126 else:
127 127 return screen_lines_def
128 128
129 129 def page(strng, start=0, screen_lines=0, pager_cmd=None):
130 130 """Print a string, piping through a pager after a certain length.
131 131
132 132 The screen_lines parameter specifies the number of *usable* lines of your
133 133 terminal screen (total lines minus lines you need to reserve to show other
134 134 information).
135 135
136 136 If you set screen_lines to a number <=0, page() will try to auto-determine
137 137 your screen size and will only use up to (screen_size+screen_lines) for
138 138 printing, paging after that. That is, if you want auto-detection but need
139 139 to reserve the bottom 3 lines of the screen, use screen_lines = -3, and for
140 140 auto-detection without any lines reserved simply use screen_lines = 0.
141 141
142 142 If a string won't fit in the allowed lines, it is sent through the
143 143 specified pager command. If none given, look for PAGER in the environment,
144 144 and ultimately default to less.
145 145
146 146 If no system pager works, the string is sent through a 'dumb pager'
147 147 written in python, very simplistic.
148 148 """
149 149
150 150 # Some routines may auto-compute start offsets incorrectly and pass a
151 151 # negative value. Offset to 0 for robustness.
152 152 start = max(0, start)
153 153
154 154 # first, try the hook
155 155 ip = ipapi.get()
156 156 if ip:
157 157 try:
158 158 ip.hooks.show_in_pager(strng)
159 159 return
160 160 except TryNext:
161 161 pass
162 162
163 163 # Ugly kludge, but calling curses.initscr() flat out crashes in emacs
164 164 TERM = os.environ.get('TERM','dumb')
165 165 if TERM in ['dumb','emacs'] and os.name != 'nt':
166 166 print strng
167 167 return
168 168 # chop off the topmost part of the string we don't want to see
169 169 str_lines = strng.splitlines()[start:]
170 170 str_toprint = os.linesep.join(str_lines)
171 171 num_newlines = len(str_lines)
172 172 len_str = len(str_toprint)
173 173
174 174 # Dumb heuristics to guesstimate number of on-screen lines the string
175 175 # takes. Very basic, but good enough for docstrings in reasonable
176 176 # terminals. If someone later feels like refining it, it's not hard.
177 177 numlines = max(num_newlines,int(len_str/80)+1)
178 178
179 179 screen_lines_def = get_terminal_size()[1]
180 180
181 181 # auto-determine screen size
182 182 if screen_lines <= 0:
183 183 try:
184 184 screen_lines += _detect_screen_size(use_curses, screen_lines_def)
185 185 except (TypeError, UnsupportedOperation):
186 186 print >>io.stdout, str_toprint
187 187 return
188 188
189 189 #print 'numlines',numlines,'screenlines',screen_lines # dbg
190 190 if numlines <= screen_lines :
191 191 #print '*** normal print' # dbg
192 192 print >>io.stdout, str_toprint
193 193 else:
194 194 # Try to open pager and default to internal one if that fails.
195 195 # All failure modes are tagged as 'retval=1', to match the return
196 196 # value of a failed system command. If any intermediate attempt
197 197 # sets retval to 1, at the end we resort to our own page_dumb() pager.
198 198 pager_cmd = get_pager_cmd(pager_cmd)
199 199 pager_cmd += ' ' + get_pager_start(pager_cmd,start)
200 200 if os.name == 'nt':
201 201 if pager_cmd.startswith('type'):
202 202 # The default WinXP 'type' command is failing on complex strings.
203 203 retval = 1
204 204 else:
205 205 tmpname = tempfile.mktemp('.txt')
206 tmpfile = file(tmpname,'wt')
206 tmpfile = open(tmpname,'wt')
207 207 tmpfile.write(strng)
208 208 tmpfile.close()
209 209 cmd = "%s < %s" % (pager_cmd,tmpname)
210 210 if os.system(cmd):
211 211 retval = 1
212 212 else:
213 213 retval = None
214 214 os.remove(tmpname)
215 215 else:
216 216 try:
217 217 retval = None
218 218 # if I use popen4, things hang. No idea why.
219 219 #pager,shell_out = os.popen4(pager_cmd)
220 220 pager = os.popen(pager_cmd,'w')
221 221 pager.write(strng)
222 222 pager.close()
223 223 retval = pager.close() # success returns None
224 224 except IOError,msg: # broken pipe when user quits
225 225 if msg.args == (32,'Broken pipe'):
226 226 retval = None
227 227 else:
228 228 retval = 1
229 229 except OSError:
230 230 # Other strange problems, sometimes seen in Win2k/cygwin
231 231 retval = 1
232 232 if retval is not None:
233 233 page_dumb(strng,screen_lines=screen_lines)
234 234
235 235
236 236 def page_file(fname, start=0, pager_cmd=None):
237 237 """Page a file, using an optional pager command and starting line.
238 238 """
239 239
240 240 pager_cmd = get_pager_cmd(pager_cmd)
241 241 pager_cmd += ' ' + get_pager_start(pager_cmd,start)
242 242
243 243 try:
244 244 if os.environ['TERM'] in ['emacs','dumb']:
245 245 raise EnvironmentError
246 246 system(pager_cmd + ' ' + fname)
247 247 except:
248 248 try:
249 249 if start > 0:
250 250 start -= 1
251 251 page(open(fname).read(),start)
252 252 except:
253 253 print 'Unable to show file',`fname`
254 254
255 255
256 256 def get_pager_cmd(pager_cmd=None):
257 257 """Return a pager command.
258 258
259 259 Makes some attempts at finding an OS-correct one.
260 260 """
261 261 if os.name == 'posix':
262 262 default_pager_cmd = 'less -r' # -r for color control sequences
263 263 elif os.name in ['nt','dos']:
264 264 default_pager_cmd = 'type'
265 265
266 266 if pager_cmd is None:
267 267 try:
268 268 pager_cmd = os.environ['PAGER']
269 269 except:
270 270 pager_cmd = default_pager_cmd
271 271 return pager_cmd
272 272
273 273
274 274 def get_pager_start(pager, start):
275 275 """Return the string for paging files with an offset.
276 276
277 277 This is the '+N' argument which less and more (under Unix) accept.
278 278 """
279 279
280 280 if pager in ['less','more']:
281 281 if start:
282 282 start_string = '+' + str(start)
283 283 else:
284 284 start_string = ''
285 285 else:
286 286 start_string = ''
287 287 return start_string
288 288
289 289
290 290 # (X)emacs on win32 doesn't like to be bypassed with msvcrt.getch()
291 291 if os.name == 'nt' and os.environ.get('TERM','dumb') != 'emacs':
292 292 import msvcrt
293 293 def page_more():
294 294 """ Smart pausing between pages
295 295
296 296 @return: True if need print more lines, False if quit
297 297 """
298 298 io.stdout.write('---Return to continue, q to quit--- ')
299 299 ans = msvcrt.getch()
300 300 if ans in ("q", "Q"):
301 301 result = False
302 302 else:
303 303 result = True
304 304 io.stdout.write("\b"*37 + " "*37 + "\b"*37)
305 305 return result
306 306 else:
307 307 def page_more():
308 308 ans = raw_input('---Return to continue, q to quit--- ')
309 309 if ans.lower().startswith('q'):
310 310 return False
311 311 else:
312 312 return True
313 313
314 314
315 315 def snip_print(str,width = 75,print_full = 0,header = ''):
316 316 """Print a string snipping the midsection to fit in width.
317 317
318 318 print_full: mode control:
319 319 - 0: only snip long strings
320 320 - 1: send to page() directly.
321 321 - 2: snip long strings and ask for full length viewing with page()
322 322 Return 1 if snipping was necessary, 0 otherwise."""
323 323
324 324 if print_full == 1:
325 325 page(header+str)
326 326 return 0
327 327
328 328 print header,
329 329 if len(str) < width:
330 330 print str
331 331 snip = 0
332 332 else:
333 333 whalf = int((width -5)/2)
334 334 print str[:whalf] + ' <...> ' + str[-whalf:]
335 335 snip = 1
336 336 if snip and print_full == 2:
337 337 if raw_input(header+' Snipped. View (y/n)? [N]').lower() == 'y':
338 338 page(str)
339 339 return snip
340 340
@@ -1,947 +1,947 b''
1 1 """ path.py - An object representing a path to a file or directory.
2 2
3 3 Example:
4 4
5 5 from IPython.external.path import path
6 6 d = path('/home/guido/bin')
7 7 for f in d.files('*.py'):
8 8 f.chmod(0755)
9 9
10 10 This module requires Python 2.5 or later.
11 11
12 12
13 13 URL: http://pypi.python.org/pypi/path.py
14 14 Author: Jason Orendorff <jason.orendorff\x40gmail\x2ecom> (and others - see the url!)
15 15 Date: 9 Mar 2007
16 16 """
17 17
18 18
19 19 # TODO
20 20 # - Tree-walking functions don't avoid symlink loops. Matt Harrison
21 21 # sent me a patch for this.
22 22 # - Bug in write_text(). It doesn't support Universal newline mode.
23 23 # - Better error message in listdir() when self isn't a
24 24 # directory. (On Windows, the error message really sucks.)
25 25 # - Make sure everything has a good docstring.
26 26 # - Add methods for regex find and replace.
27 27 # - guess_content_type() method?
28 28 # - Perhaps support arguments to touch().
29 29
30 30 from __future__ import generators
31 31
32 32 import sys, warnings, os, fnmatch, glob, shutil, codecs
33 33 from hashlib import md5
34 34
35 35 __version__ = '2.2'
36 36 __all__ = ['path']
37 37
38 38 # Platform-specific support for path.owner
39 39 if os.name == 'nt':
40 40 try:
41 41 import win32security
42 42 except ImportError:
43 43 win32security = None
44 44 else:
45 45 try:
46 46 import pwd
47 47 except ImportError:
48 48 pwd = None
49 49
50 50
51 51 class TreeWalkWarning(Warning):
52 52 pass
53 53
54 54 class path(unicode):
55 55 """ Represents a filesystem path.
56 56
57 57 For documentation on individual methods, consult their
58 58 counterparts in os.path.
59 59 """
60 60
61 61 # --- Special Python methods.
62 62
63 63 def __repr__(self):
64 64 return 'path(%s)' % unicode.__repr__(self)
65 65
66 66 # Adding a path and a string yields a path.
67 67 def __add__(self, more):
68 68 try:
69 69 resultStr = unicode.__add__(self, more)
70 70 except TypeError: #Python bug
71 71 resultStr = NotImplemented
72 72 if resultStr is NotImplemented:
73 73 return resultStr
74 74 return self.__class__(resultStr)
75 75
76 76 def __radd__(self, other):
77 77 if isinstance(other, basestring):
78 78 return self.__class__(other.__add__(self))
79 79 else:
80 80 return NotImplemented
81 81
82 82 # The / operator joins paths.
83 83 def __div__(self, rel):
84 84 """ fp.__div__(rel) == fp / rel == fp.joinpath(rel)
85 85
86 86 Join two path components, adding a separator character if
87 87 needed.
88 88 """
89 89 return self.__class__(os.path.join(self, rel))
90 90
91 91 # Make the / operator work even when true division is enabled.
92 92 __truediv__ = __div__
93 93
94 94 def getcwd(cls):
95 95 """ Return the current working directory as a path object. """
96 96 return cls(os.getcwdu())
97 97 getcwd = classmethod(getcwd)
98 98
99 99
100 100 # --- Operations on path strings.
101 101
102 102 def isabs(s): return os.path.isabs(s)
103 103 def abspath(self): return self.__class__(os.path.abspath(self))
104 104 def normcase(self): return self.__class__(os.path.normcase(self))
105 105 def normpath(self): return self.__class__(os.path.normpath(self))
106 106 def realpath(self): return self.__class__(os.path.realpath(self))
107 107 def expanduser(self): return self.__class__(os.path.expanduser(self))
108 108 def expandvars(self): return self.__class__(os.path.expandvars(self))
109 109 def dirname(self): return self.__class__(os.path.dirname(self))
110 110 def basename(s): return os.path.basename(s)
111 111
112 112 def expand(self):
113 113 """ Clean up a filename by calling expandvars(),
114 114 expanduser(), and normpath() on it.
115 115
116 116 This is commonly everything needed to clean up a filename
117 117 read from a configuration file, for example.
118 118 """
119 119 return self.expandvars().expanduser().normpath()
120 120
121 121 def _get_namebase(self):
122 122 base, ext = os.path.splitext(self.name)
123 123 return base
124 124
125 125 def _get_ext(self):
126 126 f, ext = os.path.splitext(unicode(self))
127 127 return ext
128 128
129 129 def _get_drive(self):
130 130 drive, r = os.path.splitdrive(self)
131 131 return self.__class__(drive)
132 132
133 133 parent = property(
134 134 dirname, None, None,
135 135 """ This path's parent directory, as a new path object.
136 136
137 137 For example, path('/usr/local/lib/libpython.so').parent == path('/usr/local/lib')
138 138 """)
139 139
140 140 name = property(
141 141 basename, None, None,
142 142 """ The name of this file or directory without the full path.
143 143
144 144 For example, path('/usr/local/lib/libpython.so').name == 'libpython.so'
145 145 """)
146 146
147 147 namebase = property(
148 148 _get_namebase, None, None,
149 149 """ The same as path.name, but with one file extension stripped off.
150 150
151 151 For example, path('/home/guido/python.tar.gz').name == 'python.tar.gz',
152 152 but path('/home/guido/python.tar.gz').namebase == 'python.tar'
153 153 """)
154 154
155 155 ext = property(
156 156 _get_ext, None, None,
157 157 """ The file extension, for example '.py'. """)
158 158
159 159 drive = property(
160 160 _get_drive, None, None,
161 161 """ The drive specifier, for example 'C:'.
162 162 This is always empty on systems that don't use drive specifiers.
163 163 """)
164 164
165 165 def splitpath(self):
166 166 """ p.splitpath() -> Return (p.parent, p.name). """
167 167 parent, child = os.path.split(self)
168 168 return self.__class__(parent), child
169 169
170 170 def splitdrive(self):
171 171 """ p.splitdrive() -> Return (p.drive, <the rest of p>).
172 172
173 173 Split the drive specifier from this path. If there is
174 174 no drive specifier, p.drive is empty, so the return value
175 175 is simply (path(''), p). This is always the case on Unix.
176 176 """
177 177 drive, rel = os.path.splitdrive(self)
178 178 return self.__class__(drive), rel
179 179
180 180 def splitext(self):
181 181 """ p.splitext() -> Return (p.stripext(), p.ext).
182 182
183 183 Split the filename extension from this path and return
184 184 the two parts. Either part may be empty.
185 185
186 186 The extension is everything from '.' to the end of the
187 187 last path segment. This has the property that if
188 188 (a, b) == p.splitext(), then a + b == p.
189 189 """
190 190 filename, ext = os.path.splitext(self)
191 191 return self.__class__(filename), ext
192 192
193 193 def stripext(self):
194 194 """ p.stripext() -> Remove one file extension from the path.
195 195
196 196 For example, path('/home/guido/python.tar.gz').stripext()
197 197 returns path('/home/guido/python.tar').
198 198 """
199 199 return self.splitext()[0]
200 200
201 201 if hasattr(os.path, 'splitunc'):
202 202 def splitunc(self):
203 203 unc, rest = os.path.splitunc(self)
204 204 return self.__class__(unc), rest
205 205
206 206 def _get_uncshare(self):
207 207 unc, r = os.path.splitunc(self)
208 208 return self.__class__(unc)
209 209
210 210 uncshare = property(
211 211 _get_uncshare, None, None,
212 212 """ The UNC mount point for this path.
213 213 This is empty for paths on local drives. """)
214 214
215 215 def joinpath(self, *args):
216 216 """ Join two or more path components, adding a separator
217 217 character (os.sep) if needed. Returns a new path
218 218 object.
219 219 """
220 220 return self.__class__(os.path.join(self, *args))
221 221
222 222 def splitall(self):
223 223 r""" Return a list of the path components in this path.
224 224
225 225 The first item in the list will be a path. Its value will be
226 226 either os.curdir, os.pardir, empty, or the root directory of
227 227 this path (for example, '/' or 'C:\\'). The other items in
228 228 the list will be strings.
229 229
230 230 path.path.joinpath(*result) will yield the original path.
231 231 """
232 232 parts = []
233 233 loc = self
234 234 while loc != os.curdir and loc != os.pardir:
235 235 prev = loc
236 236 loc, child = prev.splitpath()
237 237 if loc == prev:
238 238 break
239 239 parts.append(child)
240 240 parts.append(loc)
241 241 parts.reverse()
242 242 return parts
243 243
244 244 def relpath(self):
245 245 """ Return this path as a relative path,
246 246 based from the current working directory.
247 247 """
248 248 cwd = self.__class__(os.getcwdu())
249 249 return cwd.relpathto(self)
250 250
251 251 def relpathto(self, dest):
252 252 """ Return a relative path from self to dest.
253 253
254 254 If there is no relative path from self to dest, for example if
255 255 they reside on different drives in Windows, then this returns
256 256 dest.abspath().
257 257 """
258 258 origin = self.abspath()
259 259 dest = self.__class__(dest).abspath()
260 260
261 261 orig_list = origin.normcase().splitall()
262 262 # Don't normcase dest! We want to preserve the case.
263 263 dest_list = dest.splitall()
264 264
265 265 if orig_list[0] != os.path.normcase(dest_list[0]):
266 266 # Can't get here from there.
267 267 return dest
268 268
269 269 # Find the location where the two paths start to differ.
270 270 i = 0
271 271 for start_seg, dest_seg in zip(orig_list, dest_list):
272 272 if start_seg != os.path.normcase(dest_seg):
273 273 break
274 274 i += 1
275 275
276 276 # Now i is the point where the two paths diverge.
277 277 # Need a certain number of "os.pardir"s to work up
278 278 # from the origin to the point of divergence.
279 279 segments = [os.pardir] * (len(orig_list) - i)
280 280 # Need to add the diverging part of dest_list.
281 281 segments += dest_list[i:]
282 282 if len(segments) == 0:
283 283 # If they happen to be identical, use os.curdir.
284 284 relpath = os.curdir
285 285 else:
286 286 relpath = os.path.join(*segments)
287 287 return self.__class__(relpath)
288 288
289 289 # --- Listing, searching, walking, and matching
290 290
291 291 def listdir(self, pattern=None):
292 292 """ D.listdir() -> List of items in this directory.
293 293
294 294 Use D.files() or D.dirs() instead if you want a listing
295 295 of just files or just subdirectories.
296 296
297 297 The elements of the list are path objects.
298 298
299 299 With the optional 'pattern' argument, this only lists
300 300 items whose names match the given pattern.
301 301 """
302 302 names = os.listdir(self)
303 303 if pattern is not None:
304 304 names = fnmatch.filter(names, pattern)
305 305 return [self / child for child in names]
306 306
307 307 def dirs(self, pattern=None):
308 308 """ D.dirs() -> List of this directory's subdirectories.
309 309
310 310 The elements of the list are path objects.
311 311 This does not walk recursively into subdirectories
312 312 (but see path.walkdirs).
313 313
314 314 With the optional 'pattern' argument, this only lists
315 315 directories whose names match the given pattern. For
316 316 example, d.dirs('build-*').
317 317 """
318 318 return [p for p in self.listdir(pattern) if p.isdir()]
319 319
320 320 def files(self, pattern=None):
321 321 """ D.files() -> List of the files in this directory.
322 322
323 323 The elements of the list are path objects.
324 324 This does not walk into subdirectories (see path.walkfiles).
325 325
326 326 With the optional 'pattern' argument, this only lists files
327 327 whose names match the given pattern. For example,
328 328 d.files('*.pyc').
329 329 """
330 330
331 331 return [p for p in self.listdir(pattern) if p.isfile()]
332 332
333 333 def walk(self, pattern=None, errors='strict'):
334 334 """ D.walk() -> iterator over files and subdirs, recursively.
335 335
336 336 The iterator yields path objects naming each child item of
337 337 this directory and its descendants. This requires that
338 338 D.isdir().
339 339
340 340 This performs a depth-first traversal of the directory tree.
341 341 Each directory is returned just before all its children.
342 342
343 343 The errors= keyword argument controls behavior when an
344 344 error occurs. The default is 'strict', which causes an
345 345 exception. The other allowed values are 'warn', which
346 346 reports the error via warnings.warn(), and 'ignore'.
347 347 """
348 348 if errors not in ('strict', 'warn', 'ignore'):
349 349 raise ValueError("invalid errors parameter")
350 350
351 351 try:
352 352 childList = self.listdir()
353 353 except Exception:
354 354 if errors == 'ignore':
355 355 return
356 356 elif errors == 'warn':
357 357 warnings.warn(
358 358 "Unable to list directory '%s': %s"
359 359 % (self, sys.exc_info()[1]),
360 360 TreeWalkWarning)
361 361 return
362 362 else:
363 363 raise
364 364
365 365 for child in childList:
366 366 if pattern is None or child.fnmatch(pattern):
367 367 yield child
368 368 try:
369 369 isdir = child.isdir()
370 370 except Exception:
371 371 if errors == 'ignore':
372 372 isdir = False
373 373 elif errors == 'warn':
374 374 warnings.warn(
375 375 "Unable to access '%s': %s"
376 376 % (child, sys.exc_info()[1]),
377 377 TreeWalkWarning)
378 378 isdir = False
379 379 else:
380 380 raise
381 381
382 382 if isdir:
383 383 for item in child.walk(pattern, errors):
384 384 yield item
385 385
386 386 def walkdirs(self, pattern=None, errors='strict'):
387 387 """ D.walkdirs() -> iterator over subdirs, recursively.
388 388
389 389 With the optional 'pattern' argument, this yields only
390 390 directories whose names match the given pattern. For
391 391 example, mydir.walkdirs('*test') yields only directories
392 392 with names ending in 'test'.
393 393
394 394 The errors= keyword argument controls behavior when an
395 395 error occurs. The default is 'strict', which causes an
396 396 exception. The other allowed values are 'warn', which
397 397 reports the error via warnings.warn(), and 'ignore'.
398 398 """
399 399 if errors not in ('strict', 'warn', 'ignore'):
400 400 raise ValueError("invalid errors parameter")
401 401
402 402 try:
403 403 dirs = self.dirs()
404 404 except Exception:
405 405 if errors == 'ignore':
406 406 return
407 407 elif errors == 'warn':
408 408 warnings.warn(
409 409 "Unable to list directory '%s': %s"
410 410 % (self, sys.exc_info()[1]),
411 411 TreeWalkWarning)
412 412 return
413 413 else:
414 414 raise
415 415
416 416 for child in dirs:
417 417 if pattern is None or child.fnmatch(pattern):
418 418 yield child
419 419 for subsubdir in child.walkdirs(pattern, errors):
420 420 yield subsubdir
421 421
422 422 def walkfiles(self, pattern=None, errors='strict'):
423 423 """ D.walkfiles() -> iterator over files in D, recursively.
424 424
425 425 The optional argument, pattern, limits the results to files
426 426 with names that match the pattern. For example,
427 427 mydir.walkfiles('*.tmp') yields only files with the .tmp
428 428 extension.
429 429 """
430 430 if errors not in ('strict', 'warn', 'ignore'):
431 431 raise ValueError("invalid errors parameter")
432 432
433 433 try:
434 434 childList = self.listdir()
435 435 except Exception:
436 436 if errors == 'ignore':
437 437 return
438 438 elif errors == 'warn':
439 439 warnings.warn(
440 440 "Unable to list directory '%s': %s"
441 441 % (self, sys.exc_info()[1]),
442 442 TreeWalkWarning)
443 443 return
444 444 else:
445 445 raise
446 446
447 447 for child in childList:
448 448 try:
449 449 isfile = child.isfile()
450 450 isdir = not isfile and child.isdir()
451 451 except:
452 452 if errors == 'ignore':
453 453 continue
454 454 elif errors == 'warn':
455 455 warnings.warn(
456 456 "Unable to access '%s': %s"
457 457 % (self, sys.exc_info()[1]),
458 458 TreeWalkWarning)
459 459 continue
460 460 else:
461 461 raise
462 462
463 463 if isfile:
464 464 if pattern is None or child.fnmatch(pattern):
465 465 yield child
466 466 elif isdir:
467 467 for f in child.walkfiles(pattern, errors):
468 468 yield f
469 469
470 470 def fnmatch(self, pattern):
471 471 """ Return True if self.name matches the given pattern.
472 472
473 473 pattern - A filename pattern with wildcards,
474 474 for example '*.py'.
475 475 """
476 476 return fnmatch.fnmatch(self.name, pattern)
477 477
478 478 def glob(self, pattern):
479 479 """ Return a list of path objects that match the pattern.
480 480
481 481 pattern - a path relative to this directory, with wildcards.
482 482
483 483 For example, path('/users').glob('*/bin/*') returns a list
484 484 of all the files users have in their bin directories.
485 485 """
486 486 cls = self.__class__
487 487 return [cls(s) for s in glob.glob(unicode(self / pattern))]
488 488
489 489
490 490 # --- Reading or writing an entire file at once.
491 491
492 492 def open(self, mode='r'):
493 493 """ Open this file. Return a file object. """
494 494 return open(self, mode)
495 495
496 496 def bytes(self):
497 497 """ Open this file, read all bytes, return them as a string. """
498 498 f = self.open('rb')
499 499 try:
500 500 return f.read()
501 501 finally:
502 502 f.close()
503 503
504 504 def write_bytes(self, bytes, append=False):
505 505 """ Open this file and write the given bytes to it.
506 506
507 507 Default behavior is to overwrite any existing file.
508 508 Call p.write_bytes(bytes, append=True) to append instead.
509 509 """
510 510 if append:
511 511 mode = 'ab'
512 512 else:
513 513 mode = 'wb'
514 514 f = self.open(mode)
515 515 try:
516 516 f.write(bytes)
517 517 finally:
518 518 f.close()
519 519
520 520 def text(self, encoding=None, errors='strict'):
521 521 r""" Open this file, read it in, return the content as a string.
522 522
523 523 This uses 'U' mode in Python 2.3 and later, so '\r\n' and '\r'
524 524 are automatically translated to '\n'.
525 525
526 526 Optional arguments:
527 527
528 528 encoding - The Unicode encoding (or character set) of
529 529 the file. If present, the content of the file is
530 530 decoded and returned as a unicode object; otherwise
531 531 it is returned as an 8-bit str.
532 532 errors - How to handle Unicode errors; see help(str.decode)
533 533 for the options. Default is 'strict'.
534 534 """
535 535 if encoding is None:
536 536 # 8-bit
537 537 f = self.open('U')
538 538 try:
539 539 return f.read()
540 540 finally:
541 541 f.close()
542 542 else:
543 543 # Unicode
544 544 f = codecs.open(self, 'r', encoding, errors)
545 545 # (Note - Can't use 'U' mode here, since codecs.open
546 546 # doesn't support 'U' mode, even in Python 2.3.)
547 547 try:
548 548 t = f.read()
549 549 finally:
550 550 f.close()
551 551 return (t.replace(u'\r\n', u'\n')
552 552 .replace(u'\r\x85', u'\n')
553 553 .replace(u'\r', u'\n')
554 554 .replace(u'\x85', u'\n')
555 555 .replace(u'\u2028', u'\n'))
556 556
557 557 def write_text(self, text, encoding=None, errors='strict', linesep=os.linesep, append=False):
558 558 r""" Write the given text to this file.
559 559
560 560 The default behavior is to overwrite any existing file;
561 561 to append instead, use the 'append=True' keyword argument.
562 562
563 563 There are two differences between path.write_text() and
564 564 path.write_bytes(): newline handling and Unicode handling.
565 565 See below.
566 566
567 567 Parameters:
568 568
569 569 - text - str/unicode - The text to be written.
570 570
571 571 - encoding - str - The Unicode encoding that will be used.
572 572 This is ignored if 'text' isn't a Unicode string.
573 573
574 574 - errors - str - How to handle Unicode encoding errors.
575 575 Default is 'strict'. See help(unicode.encode) for the
576 576 options. This is ignored if 'text' isn't a Unicode
577 577 string.
578 578
579 579 - linesep - keyword argument - str/unicode - The sequence of
580 580 characters to be used to mark end-of-line. The default is
581 581 os.linesep. You can also specify None; this means to
582 582 leave all newlines as they are in 'text'.
583 583
584 584 - append - keyword argument - bool - Specifies what to do if
585 585 the file already exists (True: append to the end of it;
586 586 False: overwrite it.) The default is False.
587 587
588 588
589 589 --- Newline handling.
590 590
591 591 write_text() converts all standard end-of-line sequences
592 592 ('\n', '\r', and '\r\n') to your platform's default end-of-line
593 593 sequence (see os.linesep; on Windows, for example, the
594 594 end-of-line marker is '\r\n').
595 595
596 596 If you don't like your platform's default, you can override it
597 597 using the 'linesep=' keyword argument. If you specifically want
598 598 write_text() to preserve the newlines as-is, use 'linesep=None'.
599 599
600 600 This applies to Unicode text the same as to 8-bit text, except
601 601 there are three additional standard Unicode end-of-line sequences:
602 602 u'\x85', u'\r\x85', and u'\u2028'.
603 603
604 604 (This is slightly different from when you open a file for
605 writing with fopen(filename, "w") in C or file(filename, 'w')
605 writing with fopen(filename, "w") in C or open(filename, 'w')
606 606 in Python.)
607 607
608 608
609 609 --- Unicode
610 610
611 611 If 'text' isn't Unicode, then apart from newline handling, the
612 612 bytes are written verbatim to the file. The 'encoding' and
613 613 'errors' arguments are not used and must be omitted.
614 614
615 615 If 'text' is Unicode, it is first converted to bytes using the
616 616 specified 'encoding' (or the default encoding if 'encoding'
617 617 isn't specified). The 'errors' argument applies only to this
618 618 conversion.
619 619
620 620 """
621 621 if isinstance(text, unicode):
622 622 if linesep is not None:
623 623 # Convert all standard end-of-line sequences to
624 624 # ordinary newline characters.
625 625 text = (text.replace(u'\r\n', u'\n')
626 626 .replace(u'\r\x85', u'\n')
627 627 .replace(u'\r', u'\n')
628 628 .replace(u'\x85', u'\n')
629 629 .replace(u'\u2028', u'\n'))
630 630 text = text.replace(u'\n', linesep)
631 631 if encoding is None:
632 632 encoding = sys.getdefaultencoding()
633 633 bytes = text.encode(encoding, errors)
634 634 else:
635 635 # It is an error to specify an encoding if 'text' is
636 636 # an 8-bit string.
637 637 assert encoding is None
638 638
639 639 if linesep is not None:
640 640 text = (text.replace('\r\n', '\n')
641 641 .replace('\r', '\n'))
642 642 bytes = text.replace('\n', linesep)
643 643
644 644 self.write_bytes(bytes, append)
645 645
646 646 def lines(self, encoding=None, errors='strict', retain=True):
647 647 r""" Open this file, read all lines, return them in a list.
648 648
649 649 Optional arguments:
650 650 encoding - The Unicode encoding (or character set) of
651 651 the file. The default is None, meaning the content
652 652 of the file is read as 8-bit characters and returned
653 653 as a list of (non-Unicode) str objects.
654 654 errors - How to handle Unicode errors; see help(str.decode)
655 655 for the options. Default is 'strict'
656 656 retain - If true, retain newline characters; but all newline
657 657 character combinations ('\r', '\n', '\r\n') are
658 658 translated to '\n'. If false, newline characters are
659 659 stripped off. Default is True.
660 660
661 661 This uses 'U' mode in Python 2.3 and later.
662 662 """
663 663 if encoding is None and retain:
664 664 f = self.open('U')
665 665 try:
666 666 return f.readlines()
667 667 finally:
668 668 f.close()
669 669 else:
670 670 return self.text(encoding, errors).splitlines(retain)
671 671
672 672 def write_lines(self, lines, encoding=None, errors='strict',
673 673 linesep=os.linesep, append=False):
674 674 r""" Write the given lines of text to this file.
675 675
676 676 By default this overwrites any existing file at this path.
677 677
678 678 This puts a platform-specific newline sequence on every line.
679 679 See 'linesep' below.
680 680
681 681 lines - A list of strings.
682 682
683 683 encoding - A Unicode encoding to use. This applies only if
684 684 'lines' contains any Unicode strings.
685 685
686 686 errors - How to handle errors in Unicode encoding. This
687 687 also applies only to Unicode strings.
688 688
689 689 linesep - The desired line-ending. This line-ending is
690 690 applied to every line. If a line already has any
691 691 standard line ending ('\r', '\n', '\r\n', u'\x85',
692 692 u'\r\x85', u'\u2028'), that will be stripped off and
693 693 this will be used instead. The default is os.linesep,
694 694 which is platform-dependent ('\r\n' on Windows, '\n' on
695 695 Unix, etc.) Specify None to write the lines as-is,
696 696 like file.writelines().
697 697
698 698 Use the keyword argument append=True to append lines to the
699 699 file. The default is to overwrite the file. Warning:
700 700 When you use this with Unicode data, if the encoding of the
701 701 existing data in the file is different from the encoding
702 702 you specify with the encoding= parameter, the result is
703 703 mixed-encoding data, which can really confuse someone trying
704 704 to read the file later.
705 705 """
706 706 if append:
707 707 mode = 'ab'
708 708 else:
709 709 mode = 'wb'
710 710 f = self.open(mode)
711 711 try:
712 712 for line in lines:
713 713 isUnicode = isinstance(line, unicode)
714 714 if linesep is not None:
715 715 # Strip off any existing line-end and add the
716 716 # specified linesep string.
717 717 if isUnicode:
718 718 if line[-2:] in (u'\r\n', u'\x0d\x85'):
719 719 line = line[:-2]
720 720 elif line[-1:] in (u'\r', u'\n',
721 721 u'\x85', u'\u2028'):
722 722 line = line[:-1]
723 723 else:
724 724 if line[-2:] == '\r\n':
725 725 line = line[:-2]
726 726 elif line[-1:] in ('\r', '\n'):
727 727 line = line[:-1]
728 728 line += linesep
729 729 if isUnicode:
730 730 if encoding is None:
731 731 encoding = sys.getdefaultencoding()
732 732 line = line.encode(encoding, errors)
733 733 f.write(line)
734 734 finally:
735 735 f.close()
736 736
737 737 def read_md5(self):
738 738 """ Calculate the md5 hash for this file.
739 739
740 740 This reads through the entire file.
741 741 """
742 742 f = self.open('rb')
743 743 try:
744 744 m = md5()
745 745 while True:
746 746 d = f.read(8192)
747 747 if not d:
748 748 break
749 749 m.update(d)
750 750 finally:
751 751 f.close()
752 752 return m.digest()
753 753
754 754 # --- Methods for querying the filesystem.
755 755 # N.B. We can't assign the functions directly, because they may on some
756 756 # platforms be implemented in C, and compiled functions don't get bound.
757 757 # See gh-737 for discussion of this.
758 758
759 759 def exists(s): return os.path.exists(s)
760 760 def isdir(s): return os.path.isdir(s)
761 761 def isfile(s): return os.path.isfile(s)
762 762 def islink(s): return os.path.islink(s)
763 763 def ismount(s): return os.path.ismount(s)
764 764
765 765 if hasattr(os.path, 'samefile'):
766 766 def samefile(s, o): return os.path.samefile(s, o)
767 767
768 768 def getatime(s): return os.path.getatime(s)
769 769 atime = property(
770 770 getatime, None, None,
771 771 """ Last access time of the file. """)
772 772
773 773 def getmtime(s): return os.path.getmtime(s)
774 774 mtime = property(
775 775 getmtime, None, None,
776 776 """ Last-modified time of the file. """)
777 777
778 778 if hasattr(os.path, 'getctime'):
779 779 def getctime(s): return os.path.getctime(s)
780 780 ctime = property(
781 781 getctime, None, None,
782 782 """ Creation time of the file. """)
783 783
784 784 def getsize(s): return os.path.getsize(s)
785 785 size = property(
786 786 getsize, None, None,
787 787 """ Size of the file, in bytes. """)
788 788
789 789 if hasattr(os, 'access'):
790 790 def access(self, mode):
791 791 """ Return true if current user has access to this path.
792 792
793 793 mode - One of the constants os.F_OK, os.R_OK, os.W_OK, os.X_OK
794 794 """
795 795 return os.access(self, mode)
796 796
797 797 def stat(self):
798 798 """ Perform a stat() system call on this path. """
799 799 return os.stat(self)
800 800
801 801 def lstat(self):
802 802 """ Like path.stat(), but do not follow symbolic links. """
803 803 return os.lstat(self)
804 804
805 805 def get_owner(self):
806 806 r""" Return the name of the owner of this file or directory.
807 807
808 808 This follows symbolic links.
809 809
810 810 On Windows, this returns a name of the form ur'DOMAIN\User Name'.
811 811 On Windows, a group can own a file or directory.
812 812 """
813 813 if os.name == 'nt':
814 814 if win32security is None:
815 815 raise Exception("path.owner requires win32all to be installed")
816 816 desc = win32security.GetFileSecurity(
817 817 self, win32security.OWNER_SECURITY_INFORMATION)
818 818 sid = desc.GetSecurityDescriptorOwner()
819 819 account, domain, typecode = win32security.LookupAccountSid(None, sid)
820 820 return domain + u'\\' + account
821 821 else:
822 822 if pwd is None:
823 823 raise NotImplementedError("path.owner is not implemented on this platform.")
824 824 st = self.stat()
825 825 return pwd.getpwuid(st.st_uid).pw_name
826 826
827 827 owner = property(
828 828 get_owner, None, None,
829 829 """ Name of the owner of this file or directory. """)
830 830
831 831 if hasattr(os, 'statvfs'):
832 832 def statvfs(self):
833 833 """ Perform a statvfs() system call on this path. """
834 834 return os.statvfs(self)
835 835
836 836 if hasattr(os, 'pathconf'):
837 837 def pathconf(self, name):
838 838 return os.pathconf(self, name)
839 839
840 840
841 841 # --- Modifying operations on files and directories
842 842
843 843 def utime(self, times):
844 844 """ Set the access and modified times of this file. """
845 845 os.utime(self, times)
846 846
847 847 def chmod(self, mode):
848 848 os.chmod(self, mode)
849 849
850 850 if hasattr(os, 'chown'):
851 851 def chown(self, uid, gid):
852 852 os.chown(self, uid, gid)
853 853
854 854 def rename(self, new):
855 855 os.rename(self, new)
856 856
857 857 def renames(self, new):
858 858 os.renames(self, new)
859 859
860 860
861 861 # --- Create/delete operations on directories
862 862
863 863 def mkdir(self, mode=0777):
864 864 os.mkdir(self, mode)
865 865
866 866 def makedirs(self, mode=0777):
867 867 os.makedirs(self, mode)
868 868
869 869 def rmdir(self):
870 870 os.rmdir(self)
871 871
872 872 def removedirs(self):
873 873 os.removedirs(self)
874 874
875 875
876 876 # --- Modifying operations on files
877 877
878 878 def touch(self):
879 879 """ Set the access/modified times of this file to the current time.
880 880 Create the file if it does not exist.
881 881 """
882 882 fd = os.open(self, os.O_WRONLY | os.O_CREAT, 0666)
883 883 os.close(fd)
884 884 os.utime(self, None)
885 885
886 886 def remove(self):
887 887 os.remove(self)
888 888
889 889 def unlink(self):
890 890 os.unlink(self)
891 891
892 892
893 893 # --- Links
894 894
895 895 if hasattr(os, 'link'):
896 896 def link(self, newpath):
897 897 """ Create a hard link at 'newpath', pointing to this file. """
898 898 os.link(self, newpath)
899 899
900 900 if hasattr(os, 'symlink'):
901 901 def symlink(self, newlink):
902 902 """ Create a symbolic link at 'newlink', pointing here. """
903 903 os.symlink(self, newlink)
904 904
905 905 if hasattr(os, 'readlink'):
906 906 def readlink(self):
907 907 """ Return the path to which this symbolic link points.
908 908
909 909 The result may be an absolute or a relative path.
910 910 """
911 911 return self.__class__(os.readlink(self))
912 912
913 913 def readlinkabs(self):
914 914 """ Return the path to which this symbolic link points.
915 915
916 916 The result is always an absolute path.
917 917 """
918 918 p = self.readlink()
919 919 if p.isabs():
920 920 return p
921 921 else:
922 922 return (self.parent / p).abspath()
923 923
924 924
925 925 # --- High-level functions from shutil
926 926
927 927 copyfile = shutil.copyfile
928 928 copymode = shutil.copymode
929 929 copystat = shutil.copystat
930 930 copy = shutil.copy
931 931 copy2 = shutil.copy2
932 932 copytree = shutil.copytree
933 933 if hasattr(shutil, 'move'):
934 934 move = shutil.move
935 935 rmtree = shutil.rmtree
936 936
937 937
938 938 # --- Special stuff from os
939 939
940 940 if hasattr(os, 'chroot'):
941 941 def chroot(self):
942 942 os.chroot(self)
943 943
944 944 if hasattr(os, 'startfile'):
945 945 def startfile(self):
946 946 os.startfile(self)
947 947
@@ -1,1900 +1,1900 b''
1 1 """Pexpect is a Python module for spawning child applications and controlling
2 2 them automatically. Pexpect can be used for automating interactive applications
3 3 such as ssh, ftp, passwd, telnet, etc. It can be used to a automate setup
4 4 scripts for duplicating software package installations on different servers. It
5 5 can be used for automated software testing. Pexpect is in the spirit of Don
6 6 Libes' Expect, but Pexpect is pure Python. Other Expect-like modules for Python
7 7 require TCL and Expect or require C extensions to be compiled. Pexpect does not
8 8 use C, Expect, or TCL extensions. It should work on any platform that supports
9 9 the standard Python pty module. The Pexpect interface focuses on ease of use so
10 10 that simple tasks are easy.
11 11
12 12 There are two main interfaces to the Pexpect system; these are the function,
13 13 run() and the class, spawn. The spawn class is more powerful. The run()
14 14 function is simpler than spawn, and is good for quickly calling program. When
15 15 you call the run() function it executes a given program and then returns the
16 16 output. This is a handy replacement for os.system().
17 17
18 18 For example::
19 19
20 20 pexpect.run('ls -la')
21 21
22 22 The spawn class is the more powerful interface to the Pexpect system. You can
23 23 use this to spawn a child program then interact with it by sending input and
24 24 expecting responses (waiting for patterns in the child's output).
25 25
26 26 For example::
27 27
28 28 child = pexpect.spawn('scp foo myname@host.example.com:.')
29 29 child.expect ('Password:')
30 30 child.sendline (mypassword)
31 31
32 32 This works even for commands that ask for passwords or other input outside of
33 33 the normal stdio streams. For example, ssh reads input directly from the TTY
34 34 device which bypasses stdin.
35 35
36 36 Credits: Noah Spurrier, Richard Holden, Marco Molteni, Kimberley Burchett,
37 37 Robert Stone, Hartmut Goebel, Chad Schroeder, Erick Tryzelaar, Dave Kirby, Ids
38 38 vander Molen, George Todd, Noel Taylor, Nicolas D. Cesar, Alexander Gattin,
39 39 Jacques-Etienne Baudoux, Geoffrey Marshall, Francisco Lourenco, Glen Mabey,
40 40 Karthik Gurusamy, Fernando Perez, Corey Minyard, Jon Cohen, Guillaume
41 41 Chazarain, Andrew Ryan, Nick Craig-Wood, Andrew Stone, Jorgen Grahn, John
42 42 Spiegel, Jan Grant, Shane Kerr and Thomas Kluyver. Let me know if I forgot anyone.
43 43
44 44 Pexpect is free, open source, and all that good stuff.
45 45
46 46 Permission is hereby granted, free of charge, to any person obtaining a copy of
47 47 this software and associated documentation files (the "Software"), to deal in
48 48 the Software without restriction, including without limitation the rights to
49 49 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
50 50 of the Software, and to permit persons to whom the Software is furnished to do
51 51 so, subject to the following conditions:
52 52
53 53 The above copyright notice and this permission notice shall be included in all
54 54 copies or substantial portions of the Software.
55 55
56 56 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
57 57 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
58 58 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
59 59 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
60 60 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
61 61 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
62 62 SOFTWARE.
63 63
64 64 Pexpect Copyright (c) 2008-2011 Noah Spurrier
65 65 http://pexpect.sourceforge.net/
66 66 """
67 67
68 68 try:
69 69 import os, sys, time
70 70 import select
71 71 import re
72 72 import struct
73 73 import resource
74 74 import types
75 75 import pty
76 76 import tty
77 77 import termios
78 78 import fcntl
79 79 import errno
80 80 import traceback
81 81 import signal
82 82 except ImportError, e:
83 83 raise ImportError (str(e) + """
84 84
85 85 A critical module was not found. Probably this operating system does not
86 86 support it. Pexpect is intended for UNIX-like operating systems.""")
87 87
88 88 __version__ = '2.6.dev'
89 89 version = __version__
90 90 version_info = (2,6,'dev')
91 91 __all__ = ['ExceptionPexpect', 'EOF', 'TIMEOUT', 'spawn', 'spawnb', 'run', 'which',
92 92 'split_command_line', '__version__']
93 93
94 94 # Exception classes used by this module.
95 95 class ExceptionPexpect(Exception):
96 96
97 97 """Base class for all exceptions raised by this module.
98 98 """
99 99
100 100 def __init__(self, value):
101 101
102 102 self.value = value
103 103
104 104 def __str__(self):
105 105
106 106 return str(self.value)
107 107
108 108 def get_trace(self):
109 109
110 110 """This returns an abbreviated stack trace with lines that only concern
111 111 the caller. In other words, the stack trace inside the Pexpect module
112 112 is not included. """
113 113
114 114 tblist = traceback.extract_tb(sys.exc_info()[2])
115 115 #tblist = filter(self.__filter_not_pexpect, tblist)
116 116 tblist = [item for item in tblist if self.__filter_not_pexpect(item)]
117 117 tblist = traceback.format_list(tblist)
118 118 return ''.join(tblist)
119 119
120 120 def __filter_not_pexpect(self, trace_list_item):
121 121
122 122 """This returns True if list item 0 the string 'pexpect.py' in it. """
123 123
124 124 if trace_list_item[0].find('pexpect.py') == -1:
125 125 return True
126 126 else:
127 127 return False
128 128
129 129 class EOF(ExceptionPexpect):
130 130
131 131 """Raised when EOF is read from a child. This usually means the child has exited."""
132 132
133 133 class TIMEOUT(ExceptionPexpect):
134 134
135 135 """Raised when a read time exceeds the timeout. """
136 136
137 137 ##class TIMEOUT_PATTERN(TIMEOUT):
138 138 ## """Raised when the pattern match time exceeds the timeout.
139 139 ## This is different than a read TIMEOUT because the child process may
140 140 ## give output, thus never give a TIMEOUT, but the output
141 141 ## may never match a pattern.
142 142 ## """
143 143 ##class MAXBUFFER(ExceptionPexpect):
144 144 ## """Raised when a scan buffer fills before matching an expected pattern."""
145 145
146 146 PY3 = (sys.version_info[0] >= 3)
147 147
148 148 def _cast_bytes(s, enc):
149 149 if isinstance(s, unicode):
150 150 return s.encode(enc)
151 151 return s
152 152
153 153 def _cast_unicode(s, enc):
154 154 if isinstance(s, bytes):
155 155 return s.decode(enc)
156 156 return s
157 157
158 158 re_type = type(re.compile(''))
159 159
160 160 def run (command, timeout=-1, withexitstatus=False, events=None, extra_args=None,
161 161 logfile=None, cwd=None, env=None, encoding='utf-8'):
162 162
163 163 """
164 164 This function runs the given command; waits for it to finish; then
165 165 returns all output as a string. STDERR is included in output. If the full
166 166 path to the command is not given then the path is searched.
167 167
168 168 Note that lines are terminated by CR/LF (\\r\\n) combination even on
169 169 UNIX-like systems because this is the standard for pseudo ttys. If you set
170 170 'withexitstatus' to true, then run will return a tuple of (command_output,
171 171 exitstatus). If 'withexitstatus' is false then this returns just
172 172 command_output.
173 173
174 174 The run() function can often be used instead of creating a spawn instance.
175 175 For example, the following code uses spawn::
176 176
177 177 from pexpect import *
178 178 child = spawn('scp foo myname@host.example.com:.')
179 179 child.expect ('(?i)password')
180 180 child.sendline (mypassword)
181 181
182 182 The previous code can be replace with the following::
183 183
184 184 from pexpect import *
185 185 run ('scp foo myname@host.example.com:.', events={'(?i)password': mypassword})
186 186
187 187 Examples
188 188 ========
189 189
190 190 Start the apache daemon on the local machine::
191 191
192 192 from pexpect import *
193 193 run ("/usr/local/apache/bin/apachectl start")
194 194
195 195 Check in a file using SVN::
196 196
197 197 from pexpect import *
198 198 run ("svn ci -m 'automatic commit' my_file.py")
199 199
200 200 Run a command and capture exit status::
201 201
202 202 from pexpect import *
203 203 (command_output, exitstatus) = run ('ls -l /bin', withexitstatus=1)
204 204
205 205 Tricky Examples
206 206 ===============
207 207
208 208 The following will run SSH and execute 'ls -l' on the remote machine. The
209 209 password 'secret' will be sent if the '(?i)password' pattern is ever seen::
210 210
211 211 run ("ssh username@machine.example.com 'ls -l'", events={'(?i)password':'secret\\n'})
212 212
213 213 This will start mencoder to rip a video from DVD. This will also display
214 214 progress ticks every 5 seconds as it runs. For example::
215 215
216 216 from pexpect import *
217 217 def print_ticks(d):
218 218 print d['event_count'],
219 219 run ("mencoder dvd://1 -o video.avi -oac copy -ovc copy", events={TIMEOUT:print_ticks}, timeout=5)
220 220
221 221 The 'events' argument should be a dictionary of patterns and responses.
222 222 Whenever one of the patterns is seen in the command out run() will send the
223 223 associated response string. Note that you should put newlines in your
224 224 string if Enter is necessary. The responses may also contain callback
225 225 functions. Any callback is function that takes a dictionary as an argument.
226 226 The dictionary contains all the locals from the run() function, so you can
227 227 access the child spawn object or any other variable defined in run()
228 228 (event_count, child, and extra_args are the most useful). A callback may
229 229 return True to stop the current run process otherwise run() continues until
230 230 the next event. A callback may also return a string which will be sent to
231 231 the child. 'extra_args' is not used by directly run(). It provides a way to
232 232 pass data to a callback function through run() through the locals
233 233 dictionary passed to a callback."""
234 234
235 235 if timeout == -1:
236 236 child = spawn(command, maxread=2000, logfile=logfile, cwd=cwd, env=env,
237 237 encoding=encoding)
238 238 else:
239 239 child = spawn(command, timeout=timeout, maxread=2000, logfile=logfile,
240 240 cwd=cwd, env=env, encoding=encoding)
241 241 if events is not None:
242 242 patterns = events.keys()
243 243 responses = events.values()
244 244 else:
245 245 patterns=None # We assume that EOF or TIMEOUT will save us.
246 246 responses=None
247 247 child_result_list = []
248 248 event_count = 0
249 249 while 1:
250 250 try:
251 251 index = child.expect (patterns)
252 252 if isinstance(child.after, basestring):
253 253 child_result_list.append(child.before + child.after)
254 254 else: # child.after may have been a TIMEOUT or EOF, so don't cat those.
255 255 child_result_list.append(child.before)
256 256 if isinstance(responses[index], basestring):
257 257 child.send(responses[index])
258 258 elif type(responses[index]) is types.FunctionType:
259 259 callback_result = responses[index](locals())
260 260 sys.stdout.flush()
261 261 if isinstance(callback_result, basestring):
262 262 child.send(callback_result)
263 263 elif callback_result:
264 264 break
265 265 else:
266 266 raise TypeError ('The callback must be a string or function type.')
267 267 event_count = event_count + 1
268 268 except TIMEOUT, e:
269 269 child_result_list.append(child.before)
270 270 break
271 271 except EOF, e:
272 272 child_result_list.append(child.before)
273 273 break
274 274 child_result = child._empty_buffer.join(child_result_list)
275 275 if withexitstatus:
276 276 child.close()
277 277 return (child_result, child.exitstatus)
278 278 else:
279 279 return child_result
280 280
281 281 class spawnb(object):
282 282 """Use this class to start and control child applications with a pure-bytes
283 283 interface."""
284 284
285 285 _buffer_type = bytes
286 286 def _cast_buffer_type(self, s):
287 287 return _cast_bytes(s, self.encoding)
288 288 _empty_buffer = b''
289 289 _pty_newline = b'\r\n'
290 290
291 291 # Some code needs this to exist, but it's mainly for the spawn subclass.
292 292 encoding = 'utf-8'
293 293
294 294 def __init__(self, command, args=[], timeout=30, maxread=2000, searchwindowsize=None,
295 295 logfile=None, cwd=None, env=None):
296 296
297 297 """This is the constructor. The command parameter may be a string that
298 298 includes a command and any arguments to the command. For example::
299 299
300 300 child = pexpect.spawn ('/usr/bin/ftp')
301 301 child = pexpect.spawn ('/usr/bin/ssh user@example.com')
302 302 child = pexpect.spawn ('ls -latr /tmp')
303 303
304 304 You may also construct it with a list of arguments like so::
305 305
306 306 child = pexpect.spawn ('/usr/bin/ftp', [])
307 307 child = pexpect.spawn ('/usr/bin/ssh', ['user@example.com'])
308 308 child = pexpect.spawn ('ls', ['-latr', '/tmp'])
309 309
310 310 After this the child application will be created and will be ready to
311 311 talk to. For normal use, see expect() and send() and sendline().
312 312
313 313 Remember that Pexpect does NOT interpret shell meta characters such as
314 314 redirect, pipe, or wild cards (>, |, or *). This is a common mistake.
315 315 If you want to run a command and pipe it through another command then
316 316 you must also start a shell. For example::
317 317
318 318 child = pexpect.spawn('/bin/bash -c "ls -l | grep LOG > log_list.txt"')
319 319 child.expect(pexpect.EOF)
320 320
321 321 The second form of spawn (where you pass a list of arguments) is useful
322 322 in situations where you wish to spawn a command and pass it its own
323 323 argument list. This can make syntax more clear. For example, the
324 324 following is equivalent to the previous example::
325 325
326 326 shell_cmd = 'ls -l | grep LOG > log_list.txt'
327 327 child = pexpect.spawn('/bin/bash', ['-c', shell_cmd])
328 328 child.expect(pexpect.EOF)
329 329
330 330 The maxread attribute sets the read buffer size. This is maximum number
331 331 of bytes that Pexpect will try to read from a TTY at one time. Setting
332 332 the maxread size to 1 will turn off buffering. Setting the maxread
333 333 value higher may help performance in cases where large amounts of
334 334 output are read back from the child. This feature is useful in
335 335 conjunction with searchwindowsize.
336 336
337 337 The searchwindowsize attribute sets the how far back in the incomming
338 338 seach buffer Pexpect will search for pattern matches. Every time
339 339 Pexpect reads some data from the child it will append the data to the
340 340 incomming buffer. The default is to search from the beginning of the
341 341 imcomming buffer each time new data is read from the child. But this is
342 342 very inefficient if you are running a command that generates a large
343 343 amount of data where you want to match The searchwindowsize does not
344 344 effect the size of the incomming data buffer. You will still have
345 345 access to the full buffer after expect() returns.
346 346
347 347 The logfile member turns on or off logging. All input and output will
348 348 be copied to the given file object. Set logfile to None to stop
349 349 logging. This is the default. Set logfile to sys.stdout to echo
350 350 everything to standard output. The logfile is flushed after each write.
351 351
352 352 Example log input and output to a file::
353 353
354 354 child = pexpect.spawn('some_command')
355 fout = file('mylog.txt','w')
355 fout = open('mylog.txt','w')
356 356 child.logfile = fout
357 357
358 358 Example log to stdout::
359 359
360 360 child = pexpect.spawn('some_command')
361 361 child.logfile = sys.stdout
362 362
363 363 The logfile_read and logfile_send members can be used to separately log
364 364 the input from the child and output sent to the child. Sometimes you
365 365 don't want to see everything you write to the child. You only want to
366 366 log what the child sends back. For example::
367 367
368 368 child = pexpect.spawn('some_command')
369 369 child.logfile_read = sys.stdout
370 370
371 371 To separately log output sent to the child use logfile_send::
372 372
373 373 self.logfile_send = fout
374 374
375 375 The delaybeforesend helps overcome a weird behavior that many users
376 376 were experiencing. The typical problem was that a user would expect() a
377 377 "Password:" prompt and then immediately call sendline() to send the
378 378 password. The user would then see that their password was echoed back
379 379 to them. Passwords don't normally echo. The problem is caused by the
380 380 fact that most applications print out the "Password" prompt and then
381 381 turn off stdin echo, but if you send your password before the
382 382 application turned off echo, then you get your password echoed.
383 383 Normally this wouldn't be a problem when interacting with a human at a
384 384 real keyboard. If you introduce a slight delay just before writing then
385 385 this seems to clear up the problem. This was such a common problem for
386 386 many users that I decided that the default pexpect behavior should be
387 387 to sleep just before writing to the child application. 1/20th of a
388 388 second (50 ms) seems to be enough to clear up the problem. You can set
389 389 delaybeforesend to 0 to return to the old behavior. Most Linux machines
390 390 don't like this to be below 0.03. I don't know why.
391 391
392 392 Note that spawn is clever about finding commands on your path.
393 393 It uses the same logic that "which" uses to find executables.
394 394
395 395 If you wish to get the exit status of the child you must call the
396 396 close() method. The exit or signal status of the child will be stored
397 397 in self.exitstatus or self.signalstatus. If the child exited normally
398 398 then exitstatus will store the exit return code and signalstatus will
399 399 be None. If the child was terminated abnormally with a signal then
400 400 signalstatus will store the signal value and exitstatus will be None.
401 401 If you need more detail you can also read the self.status member which
402 402 stores the status returned by os.waitpid. You can interpret this using
403 403 os.WIFEXITED/os.WEXITSTATUS or os.WIFSIGNALED/os.TERMSIG. """
404 404
405 405 self.STDIN_FILENO = pty.STDIN_FILENO
406 406 self.STDOUT_FILENO = pty.STDOUT_FILENO
407 407 self.STDERR_FILENO = pty.STDERR_FILENO
408 408 self.stdin = sys.stdin
409 409 self.stdout = sys.stdout
410 410 self.stderr = sys.stderr
411 411
412 412 self.searcher = None
413 413 self.ignorecase = False
414 414 self.before = None
415 415 self.after = None
416 416 self.match = None
417 417 self.match_index = None
418 418 self.terminated = True
419 419 self.exitstatus = None
420 420 self.signalstatus = None
421 421 self.status = None # status returned by os.waitpid
422 422 self.flag_eof = False
423 423 self.pid = None
424 424 self.child_fd = -1 # initially closed
425 425 self.timeout = timeout
426 426 self.delimiter = EOF
427 427 self.logfile = logfile
428 428 self.logfile_read = None # input from child (read_nonblocking)
429 429 self.logfile_send = None # output to send (send, sendline)
430 430 self.maxread = maxread # max bytes to read at one time into buffer
431 431 self.buffer = self._empty_buffer # This is the read buffer. See maxread.
432 432 self.searchwindowsize = searchwindowsize # Anything before searchwindowsize point is preserved, but not searched.
433 433 # Most Linux machines don't like delaybeforesend to be below 0.03 (30 ms).
434 434 self.delaybeforesend = 0.05 # Sets sleep time used just before sending data to child. Time in seconds.
435 435 self.delayafterclose = 0.1 # Sets delay in close() method to allow kernel time to update process status. Time in seconds.
436 436 self.delayafterterminate = 0.1 # Sets delay in terminate() method to allow kernel time to update process status. Time in seconds.
437 437 self.softspace = False # File-like object.
438 438 self.name = '<' + repr(self) + '>' # File-like object.
439 439 self.closed = True # File-like object.
440 440 self.cwd = cwd
441 441 self.env = env
442 442 self.__irix_hack = (sys.platform.lower().find('irix')>=0) # This flags if we are running on irix
443 443 # Solaris uses internal __fork_pty(). All others use pty.fork().
444 444 if 'solaris' in sys.platform.lower() or 'sunos5' in sys.platform.lower():
445 445 self.use_native_pty_fork = False
446 446 else:
447 447 self.use_native_pty_fork = True
448 448
449 449
450 450 # allow dummy instances for subclasses that may not use command or args.
451 451 if command is None:
452 452 self.command = None
453 453 self.args = None
454 454 self.name = '<pexpect factory incomplete>'
455 455 else:
456 456 self._spawn (command, args)
457 457
458 458 def __del__(self):
459 459
460 460 """This makes sure that no system resources are left open. Python only
461 461 garbage collects Python objects. OS file descriptors are not Python
462 462 objects, so they must be handled explicitly. If the child file
463 463 descriptor was opened outside of this class (passed to the constructor)
464 464 then this does not close it. """
465 465
466 466 if not self.closed:
467 467 # It is possible for __del__ methods to execute during the
468 468 # teardown of the Python VM itself. Thus self.close() may
469 469 # trigger an exception because os.close may be None.
470 470 # -- Fernando Perez
471 471 try:
472 472 self.close()
473 473 except:
474 474 pass
475 475
476 476 def __str__(self):
477 477
478 478 """This returns a human-readable string that represents the state of
479 479 the object. """
480 480
481 481 s = []
482 482 s.append(repr(self))
483 483 s.append('version: ' + __version__)
484 484 s.append('command: ' + str(self.command))
485 485 s.append('args: ' + str(self.args))
486 486 s.append('searcher: ' + str(self.searcher))
487 487 s.append('buffer (last 100 chars): ' + str(self.buffer)[-100:])
488 488 s.append('before (last 100 chars): ' + str(self.before)[-100:])
489 489 s.append('after: ' + str(self.after))
490 490 s.append('match: ' + str(self.match))
491 491 s.append('match_index: ' + str(self.match_index))
492 492 s.append('exitstatus: ' + str(self.exitstatus))
493 493 s.append('flag_eof: ' + str(self.flag_eof))
494 494 s.append('pid: ' + str(self.pid))
495 495 s.append('child_fd: ' + str(self.child_fd))
496 496 s.append('closed: ' + str(self.closed))
497 497 s.append('timeout: ' + str(self.timeout))
498 498 s.append('delimiter: ' + str(self.delimiter))
499 499 s.append('logfile: ' + str(self.logfile))
500 500 s.append('logfile_read: ' + str(self.logfile_read))
501 501 s.append('logfile_send: ' + str(self.logfile_send))
502 502 s.append('maxread: ' + str(self.maxread))
503 503 s.append('ignorecase: ' + str(self.ignorecase))
504 504 s.append('searchwindowsize: ' + str(self.searchwindowsize))
505 505 s.append('delaybeforesend: ' + str(self.delaybeforesend))
506 506 s.append('delayafterclose: ' + str(self.delayafterclose))
507 507 s.append('delayafterterminate: ' + str(self.delayafterterminate))
508 508 return '\n'.join(s)
509 509
510 510 def _spawn(self,command,args=[]):
511 511
512 512 """This starts the given command in a child process. This does all the
513 513 fork/exec type of stuff for a pty. This is called by __init__. If args
514 514 is empty then command will be parsed (split on spaces) and args will be
515 515 set to parsed arguments. """
516 516
517 517 # The pid and child_fd of this object get set by this method.
518 518 # Note that it is difficult for this method to fail.
519 519 # You cannot detect if the child process cannot start.
520 520 # So the only way you can tell if the child process started
521 521 # or not is to try to read from the file descriptor. If you get
522 522 # EOF immediately then it means that the child is already dead.
523 523 # That may not necessarily be bad because you may haved spawned a child
524 524 # that performs some task; creates no stdout output; and then dies.
525 525
526 526 # If command is an int type then it may represent a file descriptor.
527 527 if type(command) == type(0):
528 528 raise ExceptionPexpect ('Command is an int type. If this is a file descriptor then maybe you want to use fdpexpect.fdspawn which takes an existing file descriptor instead of a command string.')
529 529
530 530 if type (args) != type([]):
531 531 raise TypeError ('The argument, args, must be a list.')
532 532
533 533 if args == []:
534 534 self.args = split_command_line(command)
535 535 self.command = self.args[0]
536 536 else:
537 537 self.args = args[:] # work with a copy
538 538 self.args.insert (0, command)
539 539 self.command = command
540 540
541 541 command_with_path = which(self.command)
542 542 if command_with_path is None:
543 543 raise ExceptionPexpect ('The command was not found or was not executable: %s.' % self.command)
544 544 self.command = command_with_path
545 545 self.args[0] = self.command
546 546
547 547 self.name = '<' + ' '.join (self.args) + '>'
548 548
549 549 assert self.pid is None, 'The pid member should be None.'
550 550 assert self.command is not None, 'The command member should not be None.'
551 551
552 552 if self.use_native_pty_fork:
553 553 try:
554 554 self.pid, self.child_fd = pty.fork()
555 555 except OSError, e:
556 556 raise ExceptionPexpect('Error! pty.fork() failed: ' + str(e))
557 557 else: # Use internal __fork_pty
558 558 self.pid, self.child_fd = self.__fork_pty()
559 559
560 560 if self.pid == 0: # Child
561 561 try:
562 562 self.child_fd = sys.stdout.fileno() # used by setwinsize()
563 563 self.setwinsize(24, 80)
564 564 except:
565 565 # Some platforms do not like setwinsize (Cygwin).
566 566 # This will cause problem when running applications that
567 567 # are very picky about window size.
568 568 # This is a serious limitation, but not a show stopper.
569 569 pass
570 570 # Do not allow child to inherit open file descriptors from parent.
571 571 max_fd = resource.getrlimit(resource.RLIMIT_NOFILE)[0]
572 572 for i in range (3, max_fd):
573 573 try:
574 574 os.close (i)
575 575 except OSError:
576 576 pass
577 577
578 578 # I don't know why this works, but ignoring SIGHUP fixes a
579 579 # problem when trying to start a Java daemon with sudo
580 580 # (specifically, Tomcat).
581 581 signal.signal(signal.SIGHUP, signal.SIG_IGN)
582 582
583 583 if self.cwd is not None:
584 584 os.chdir(self.cwd)
585 585 if self.env is None:
586 586 os.execv(self.command, self.args)
587 587 else:
588 588 os.execvpe(self.command, self.args, self.env)
589 589
590 590 # Parent
591 591 self.terminated = False
592 592 self.closed = False
593 593
594 594 def __fork_pty(self):
595 595
596 596 """This implements a substitute for the forkpty system call. This
597 597 should be more portable than the pty.fork() function. Specifically,
598 598 this should work on Solaris.
599 599
600 600 Modified 10.06.05 by Geoff Marshall: Implemented __fork_pty() method to
601 601 resolve the issue with Python's pty.fork() not supporting Solaris,
602 602 particularly ssh. Based on patch to posixmodule.c authored by Noah
603 603 Spurrier::
604 604
605 605 http://mail.python.org/pipermail/python-dev/2003-May/035281.html
606 606
607 607 """
608 608
609 609 parent_fd, child_fd = os.openpty()
610 610 if parent_fd < 0 or child_fd < 0:
611 611 raise ExceptionPexpect, "Error! Could not open pty with os.openpty()."
612 612
613 613 pid = os.fork()
614 614 if pid < 0:
615 615 raise ExceptionPexpect, "Error! Failed os.fork()."
616 616 elif pid == 0:
617 617 # Child.
618 618 os.close(parent_fd)
619 619 self.__pty_make_controlling_tty(child_fd)
620 620
621 621 os.dup2(child_fd, 0)
622 622 os.dup2(child_fd, 1)
623 623 os.dup2(child_fd, 2)
624 624
625 625 if child_fd > 2:
626 626 os.close(child_fd)
627 627 else:
628 628 # Parent.
629 629 os.close(child_fd)
630 630
631 631 return pid, parent_fd
632 632
633 633 def __pty_make_controlling_tty(self, tty_fd):
634 634
635 635 """This makes the pseudo-terminal the controlling tty. This should be
636 636 more portable than the pty.fork() function. Specifically, this should
637 637 work on Solaris. """
638 638
639 639 child_name = os.ttyname(tty_fd)
640 640
641 641 # Disconnect from controlling tty. Harmless if not already connected.
642 642 try:
643 643 fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY);
644 644 if fd >= 0:
645 645 os.close(fd)
646 646 except:
647 647 # Already disconnected. This happens if running inside cron.
648 648 pass
649 649
650 650 os.setsid()
651 651
652 652 # Verify we are disconnected from controlling tty
653 653 # by attempting to open it again.
654 654 try:
655 655 fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY);
656 656 if fd >= 0:
657 657 os.close(fd)
658 658 raise ExceptionPexpect, "Error! Failed to disconnect from controlling tty. It is still possible to open /dev/tty."
659 659 except:
660 660 # Good! We are disconnected from a controlling tty.
661 661 pass
662 662
663 663 # Verify we can open child pty.
664 664 fd = os.open(child_name, os.O_RDWR);
665 665 if fd < 0:
666 666 raise ExceptionPexpect, "Error! Could not open child pty, " + child_name
667 667 else:
668 668 os.close(fd)
669 669
670 670 # Verify we now have a controlling tty.
671 671 fd = os.open("/dev/tty", os.O_WRONLY)
672 672 if fd < 0:
673 673 raise ExceptionPexpect, "Error! Could not open controlling tty, /dev/tty"
674 674 else:
675 675 os.close(fd)
676 676
677 677 def fileno (self): # File-like object.
678 678
679 679 """This returns the file descriptor of the pty for the child.
680 680 """
681 681
682 682 return self.child_fd
683 683
684 684 def close (self, force=True): # File-like object.
685 685
686 686 """This closes the connection with the child application. Note that
687 687 calling close() more than once is valid. This emulates standard Python
688 688 behavior with files. Set force to True if you want to make sure that
689 689 the child is terminated (SIGKILL is sent if the child ignores SIGHUP
690 690 and SIGINT). """
691 691
692 692 if not self.closed:
693 693 self.flush()
694 694 os.close (self.child_fd)
695 695 time.sleep(self.delayafterclose) # Give kernel time to update process status.
696 696 if self.isalive():
697 697 if not self.terminate(force):
698 698 raise ExceptionPexpect ('close() could not terminate the child using terminate()')
699 699 self.child_fd = -1
700 700 self.closed = True
701 701 #self.pid = None
702 702
703 703 def flush (self): # File-like object.
704 704
705 705 """This does nothing. It is here to support the interface for a
706 706 File-like object. """
707 707
708 708 pass
709 709
710 710 def isatty (self): # File-like object.
711 711
712 712 """This returns True if the file descriptor is open and connected to a
713 713 tty(-like) device, else False. """
714 714
715 715 return os.isatty(self.child_fd)
716 716
717 717 def waitnoecho (self, timeout=-1):
718 718
719 719 """This waits until the terminal ECHO flag is set False. This returns
720 720 True if the echo mode is off. This returns False if the ECHO flag was
721 721 not set False before the timeout. This can be used to detect when the
722 722 child is waiting for a password. Usually a child application will turn
723 723 off echo mode when it is waiting for the user to enter a password. For
724 724 example, instead of expecting the "password:" prompt you can wait for
725 725 the child to set ECHO off::
726 726
727 727 p = pexpect.spawn ('ssh user@example.com')
728 728 p.waitnoecho()
729 729 p.sendline(mypassword)
730 730
731 731 If timeout==-1 then this method will use the value in self.timeout.
732 732 If timeout==None then this method to block until ECHO flag is False.
733 733 """
734 734
735 735 if timeout == -1:
736 736 timeout = self.timeout
737 737 if timeout is not None:
738 738 end_time = time.time() + timeout
739 739 while True:
740 740 if not self.getecho():
741 741 return True
742 742 if timeout < 0 and timeout is not None:
743 743 return False
744 744 if timeout is not None:
745 745 timeout = end_time - time.time()
746 746 time.sleep(0.1)
747 747
748 748 def getecho (self):
749 749
750 750 """This returns the terminal echo mode. This returns True if echo is
751 751 on or False if echo is off. Child applications that are expecting you
752 752 to enter a password often set ECHO False. See waitnoecho(). """
753 753
754 754 attr = termios.tcgetattr(self.child_fd)
755 755 if attr[3] & termios.ECHO:
756 756 return True
757 757 return False
758 758
759 759 def setecho (self, state):
760 760
761 761 """This sets the terminal echo mode on or off. Note that anything the
762 762 child sent before the echo will be lost, so you should be sure that
763 763 your input buffer is empty before you call setecho(). For example, the
764 764 following will work as expected::
765 765
766 766 p = pexpect.spawn('cat')
767 767 p.sendline ('1234') # We will see this twice (once from tty echo and again from cat).
768 768 p.expect (['1234'])
769 769 p.expect (['1234'])
770 770 p.setecho(False) # Turn off tty echo
771 771 p.sendline ('abcd') # We will set this only once (echoed by cat).
772 772 p.sendline ('wxyz') # We will set this only once (echoed by cat)
773 773 p.expect (['abcd'])
774 774 p.expect (['wxyz'])
775 775
776 776 The following WILL NOT WORK because the lines sent before the setecho
777 777 will be lost::
778 778
779 779 p = pexpect.spawn('cat')
780 780 p.sendline ('1234') # We will see this twice (once from tty echo and again from cat).
781 781 p.setecho(False) # Turn off tty echo
782 782 p.sendline ('abcd') # We will set this only once (echoed by cat).
783 783 p.sendline ('wxyz') # We will set this only once (echoed by cat)
784 784 p.expect (['1234'])
785 785 p.expect (['1234'])
786 786 p.expect (['abcd'])
787 787 p.expect (['wxyz'])
788 788 """
789 789
790 790 self.child_fd
791 791 attr = termios.tcgetattr(self.child_fd)
792 792 if state:
793 793 attr[3] = attr[3] | termios.ECHO
794 794 else:
795 795 attr[3] = attr[3] & ~termios.ECHO
796 796 # I tried TCSADRAIN and TCSAFLUSH, but these were inconsistent
797 797 # and blocked on some platforms. TCSADRAIN is probably ideal if it worked.
798 798 termios.tcsetattr(self.child_fd, termios.TCSANOW, attr)
799 799
800 800 def read_nonblocking (self, size = 1, timeout = -1):
801 801
802 802 """This reads at most size bytes from the child application. It
803 803 includes a timeout. If the read does not complete within the timeout
804 804 period then a TIMEOUT exception is raised. If the end of file is read
805 805 then an EOF exception will be raised. If a log file was set using
806 806 setlog() then all data will also be written to the log file.
807 807
808 808 If timeout is None then the read may block indefinitely. If timeout is -1
809 809 then the self.timeout value is used. If timeout is 0 then the child is
810 810 polled and if there was no data immediately ready then this will raise
811 811 a TIMEOUT exception.
812 812
813 813 The timeout refers only to the amount of time to read at least one
814 814 character. This is not effected by the 'size' parameter, so if you call
815 815 read_nonblocking(size=100, timeout=30) and only one character is
816 816 available right away then one character will be returned immediately.
817 817 It will not wait for 30 seconds for another 99 characters to come in.
818 818
819 819 This is a wrapper around os.read(). It uses select.select() to
820 820 implement the timeout. """
821 821
822 822 if self.closed:
823 823 raise ValueError ('I/O operation on closed file in read_nonblocking().')
824 824
825 825 if timeout == -1:
826 826 timeout = self.timeout
827 827
828 828 # Note that some systems such as Solaris do not give an EOF when
829 829 # the child dies. In fact, you can still try to read
830 830 # from the child_fd -- it will block forever or until TIMEOUT.
831 831 # For this case, I test isalive() before doing any reading.
832 832 # If isalive() is false, then I pretend that this is the same as EOF.
833 833 if not self.isalive():
834 834 r,w,e = self.__select([self.child_fd], [], [], 0) # timeout of 0 means "poll"
835 835 if not r:
836 836 self.flag_eof = True
837 837 raise EOF ('End Of File (EOF) in read_nonblocking(). Braindead platform.')
838 838 elif self.__irix_hack:
839 839 # This is a hack for Irix. It seems that Irix requires a long delay before checking isalive.
840 840 # This adds a 2 second delay, but only when the child is terminated.
841 841 r, w, e = self.__select([self.child_fd], [], [], 2)
842 842 if not r and not self.isalive():
843 843 self.flag_eof = True
844 844 raise EOF ('End Of File (EOF) in read_nonblocking(). Pokey platform.')
845 845
846 846 r,w,e = self.__select([self.child_fd], [], [], timeout)
847 847
848 848 if not r:
849 849 if not self.isalive():
850 850 # Some platforms, such as Irix, will claim that their processes are alive;
851 851 # then timeout on the select; and then finally admit that they are not alive.
852 852 self.flag_eof = True
853 853 raise EOF ('End of File (EOF) in read_nonblocking(). Very pokey platform.')
854 854 else:
855 855 raise TIMEOUT ('Timeout exceeded in read_nonblocking().')
856 856
857 857 if self.child_fd in r:
858 858 try:
859 859 s = os.read(self.child_fd, size)
860 860 except OSError, e: # Linux does this
861 861 self.flag_eof = True
862 862 raise EOF ('End Of File (EOF) in read_nonblocking(). Exception style platform.')
863 863 if s == b'': # BSD style
864 864 self.flag_eof = True
865 865 raise EOF ('End Of File (EOF) in read_nonblocking(). Empty string style platform.')
866 866
867 867 s2 = self._cast_buffer_type(s)
868 868 if self.logfile is not None:
869 869 self.logfile.write(s2)
870 870 self.logfile.flush()
871 871 if self.logfile_read is not None:
872 872 self.logfile_read.write(s2)
873 873 self.logfile_read.flush()
874 874
875 875 return s
876 876
877 877 raise ExceptionPexpect ('Reached an unexpected state in read_nonblocking().')
878 878
879 879 def read (self, size = -1): # File-like object.
880 880 """This reads at most "size" bytes from the file (less if the read hits
881 881 EOF before obtaining size bytes). If the size argument is negative or
882 882 omitted, read all data until EOF is reached. The bytes are returned as
883 883 a string object. An empty string is returned when EOF is encountered
884 884 immediately. """
885 885
886 886 if size == 0:
887 887 return self._empty_buffer
888 888 if size < 0:
889 889 self.expect (self.delimiter) # delimiter default is EOF
890 890 return self.before
891 891
892 892 # I could have done this more directly by not using expect(), but
893 893 # I deliberately decided to couple read() to expect() so that
894 894 # I would catch any bugs early and ensure consistant behavior.
895 895 # It's a little less efficient, but there is less for me to
896 896 # worry about if I have to later modify read() or expect().
897 897 # Note, it's OK if size==-1 in the regex. That just means it
898 898 # will never match anything in which case we stop only on EOF.
899 899 if self._buffer_type is bytes:
900 900 pat = (u'.{%d}' % size).encode('ascii')
901 901 else:
902 902 pat = u'.{%d}' % size
903 903 cre = re.compile(pat, re.DOTALL)
904 904 index = self.expect ([cre, self.delimiter]) # delimiter default is EOF
905 905 if index == 0:
906 906 return self.after ### self.before should be ''. Should I assert this?
907 907 return self.before
908 908
909 909 def readline(self, size = -1):
910 910 """This reads and returns one entire line. A trailing newline is kept
911 911 in the string, but may be absent when a file ends with an incomplete
912 912 line. Note: This readline() looks for a \\r\\n pair even on UNIX
913 913 because this is what the pseudo tty device returns. So contrary to what
914 914 you may expect you will receive the newline as \\r\\n. An empty string
915 915 is returned when EOF is hit immediately. Currently, the size argument is
916 916 mostly ignored, so this behavior is not standard for a file-like
917 917 object. If size is 0 then an empty string is returned. """
918 918
919 919 if size == 0:
920 920 return self._empty_buffer
921 921 index = self.expect ([self._pty_newline, self.delimiter]) # delimiter default is EOF
922 922 if index == 0:
923 923 return self.before + self._pty_newline
924 924 return self.before
925 925
926 926 def __iter__ (self): # File-like object.
927 927
928 928 """This is to support iterators over a file-like object.
929 929 """
930 930
931 931 return self
932 932
933 933 def next (self): # File-like object.
934 934
935 935 """This is to support iterators over a file-like object.
936 936 """
937 937
938 938 result = self.readline()
939 939 if result == self._empty_buffer:
940 940 raise StopIteration
941 941 return result
942 942
943 943 def readlines (self, sizehint = -1): # File-like object.
944 944
945 945 """This reads until EOF using readline() and returns a list containing
946 946 the lines thus read. The optional "sizehint" argument is ignored. """
947 947
948 948 lines = []
949 949 while True:
950 950 line = self.readline()
951 951 if not line:
952 952 break
953 953 lines.append(line)
954 954 return lines
955 955
956 956 def write(self, s): # File-like object.
957 957
958 958 """This is similar to send() except that there is no return value.
959 959 """
960 960
961 961 self.send (s)
962 962
963 963 def writelines (self, sequence): # File-like object.
964 964
965 965 """This calls write() for each element in the sequence. The sequence
966 966 can be any iterable object producing strings, typically a list of
967 967 strings. This does not add line separators There is no return value.
968 968 """
969 969
970 970 for s in sequence:
971 971 self.write (s)
972 972
973 973 def send(self, s):
974 974
975 975 """This sends a string to the child process. This returns the number of
976 976 bytes written. If a log file was set then the data is also written to
977 977 the log. """
978 978
979 979 time.sleep(self.delaybeforesend)
980 980
981 981 s2 = self._cast_buffer_type(s)
982 982 if self.logfile is not None:
983 983 self.logfile.write(s2)
984 984 self.logfile.flush()
985 985 if self.logfile_send is not None:
986 986 self.logfile_send.write(s2)
987 987 self.logfile_send.flush()
988 988 c = os.write (self.child_fd, _cast_bytes(s, self.encoding))
989 989 return c
990 990
991 991 def sendline(self, s=''):
992 992
993 993 """This is like send(), but it adds a line feed (os.linesep). This
994 994 returns the number of bytes written. """
995 995
996 996 n = self.send (s)
997 997 n = n + self.send (os.linesep)
998 998 return n
999 999
1000 1000 def sendcontrol(self, char):
1001 1001
1002 1002 """This sends a control character to the child such as Ctrl-C or
1003 1003 Ctrl-D. For example, to send a Ctrl-G (ASCII 7)::
1004 1004
1005 1005 child.sendcontrol('g')
1006 1006
1007 1007 See also, sendintr() and sendeof().
1008 1008 """
1009 1009
1010 1010 char = char.lower()
1011 1011 a = ord(char)
1012 1012 if a>=97 and a<=122:
1013 1013 a = a - ord('a') + 1
1014 1014 return self.send (chr(a))
1015 1015 d = {'@':0, '`':0,
1016 1016 '[':27, '{':27,
1017 1017 '\\':28, '|':28,
1018 1018 ']':29, '}': 29,
1019 1019 '^':30, '~':30,
1020 1020 '_':31,
1021 1021 '?':127}
1022 1022 if char not in d:
1023 1023 return 0
1024 1024 return self.send (chr(d[char]))
1025 1025
1026 1026 def sendeof(self):
1027 1027
1028 1028 """This sends an EOF to the child. This sends a character which causes
1029 1029 the pending parent output buffer to be sent to the waiting child
1030 1030 program without waiting for end-of-line. If it is the first character
1031 1031 of the line, the read() in the user program returns 0, which signifies
1032 1032 end-of-file. This means to work as expected a sendeof() has to be
1033 1033 called at the beginning of a line. This method does not send a newline.
1034 1034 It is the responsibility of the caller to ensure the eof is sent at the
1035 1035 beginning of a line. """
1036 1036
1037 1037 ### Hmmm... how do I send an EOF?
1038 1038 ###C if ((m = write(pty, *buf, p - *buf)) < 0)
1039 1039 ###C return (errno == EWOULDBLOCK) ? n : -1;
1040 1040 #fd = sys.stdin.fileno()
1041 1041 #old = termios.tcgetattr(fd) # remember current state
1042 1042 #attr = termios.tcgetattr(fd)
1043 1043 #attr[3] = attr[3] | termios.ICANON # ICANON must be set to recognize EOF
1044 1044 #try: # use try/finally to ensure state gets restored
1045 1045 # termios.tcsetattr(fd, termios.TCSADRAIN, attr)
1046 1046 # if hasattr(termios, 'CEOF'):
1047 1047 # os.write (self.child_fd, '%c' % termios.CEOF)
1048 1048 # else:
1049 1049 # # Silly platform does not define CEOF so assume CTRL-D
1050 1050 # os.write (self.child_fd, '%c' % 4)
1051 1051 #finally: # restore state
1052 1052 # termios.tcsetattr(fd, termios.TCSADRAIN, old)
1053 1053 if hasattr(termios, 'VEOF'):
1054 1054 char = termios.tcgetattr(self.child_fd)[6][termios.VEOF]
1055 1055 else:
1056 1056 # platform does not define VEOF so assume CTRL-D
1057 1057 char = chr(4)
1058 1058 self.send(char)
1059 1059
1060 1060 def sendintr(self):
1061 1061
1062 1062 """This sends a SIGINT to the child. It does not require
1063 1063 the SIGINT to be the first character on a line. """
1064 1064
1065 1065 if hasattr(termios, 'VINTR'):
1066 1066 char = termios.tcgetattr(self.child_fd)[6][termios.VINTR]
1067 1067 else:
1068 1068 # platform does not define VINTR so assume CTRL-C
1069 1069 char = chr(3)
1070 1070 self.send (char)
1071 1071
1072 1072 def eof (self):
1073 1073
1074 1074 """This returns True if the EOF exception was ever raised.
1075 1075 """
1076 1076
1077 1077 return self.flag_eof
1078 1078
1079 1079 def terminate(self, force=False):
1080 1080
1081 1081 """This forces a child process to terminate. It starts nicely with
1082 1082 SIGHUP and SIGINT. If "force" is True then moves onto SIGKILL. This
1083 1083 returns True if the child was terminated. This returns False if the
1084 1084 child could not be terminated. """
1085 1085
1086 1086 if not self.isalive():
1087 1087 return True
1088 1088 try:
1089 1089 self.kill(signal.SIGHUP)
1090 1090 time.sleep(self.delayafterterminate)
1091 1091 if not self.isalive():
1092 1092 return True
1093 1093 self.kill(signal.SIGCONT)
1094 1094 time.sleep(self.delayafterterminate)
1095 1095 if not self.isalive():
1096 1096 return True
1097 1097 self.kill(signal.SIGINT)
1098 1098 time.sleep(self.delayafterterminate)
1099 1099 if not self.isalive():
1100 1100 return True
1101 1101 if force:
1102 1102 self.kill(signal.SIGKILL)
1103 1103 time.sleep(self.delayafterterminate)
1104 1104 if not self.isalive():
1105 1105 return True
1106 1106 else:
1107 1107 return False
1108 1108 return False
1109 1109 except OSError, e:
1110 1110 # I think there are kernel timing issues that sometimes cause
1111 1111 # this to happen. I think isalive() reports True, but the
1112 1112 # process is dead to the kernel.
1113 1113 # Make one last attempt to see if the kernel is up to date.
1114 1114 time.sleep(self.delayafterterminate)
1115 1115 if not self.isalive():
1116 1116 return True
1117 1117 else:
1118 1118 return False
1119 1119
1120 1120 def wait(self):
1121 1121
1122 1122 """This waits until the child exits. This is a blocking call. This will
1123 1123 not read any data from the child, so this will block forever if the
1124 1124 child has unread output and has terminated. In other words, the child
1125 1125 may have printed output then called exit(); but, technically, the child
1126 1126 is still alive until its output is read. """
1127 1127
1128 1128 if self.isalive():
1129 1129 pid, status = os.waitpid(self.pid, 0)
1130 1130 else:
1131 1131 raise ExceptionPexpect ('Cannot wait for dead child process.')
1132 1132 self.exitstatus = os.WEXITSTATUS(status)
1133 1133 if os.WIFEXITED (status):
1134 1134 self.status = status
1135 1135 self.exitstatus = os.WEXITSTATUS(status)
1136 1136 self.signalstatus = None
1137 1137 self.terminated = True
1138 1138 elif os.WIFSIGNALED (status):
1139 1139 self.status = status
1140 1140 self.exitstatus = None
1141 1141 self.signalstatus = os.WTERMSIG(status)
1142 1142 self.terminated = True
1143 1143 elif os.WIFSTOPPED (status):
1144 1144 raise ExceptionPexpect ('Wait was called for a child process that is stopped. This is not supported. Is some other process attempting job control with our child pid?')
1145 1145 return self.exitstatus
1146 1146
1147 1147 def isalive(self):
1148 1148
1149 1149 """This tests if the child process is running or not. This is
1150 1150 non-blocking. If the child was terminated then this will read the
1151 1151 exitstatus or signalstatus of the child. This returns True if the child
1152 1152 process appears to be running or False if not. It can take literally
1153 1153 SECONDS for Solaris to return the right status. """
1154 1154
1155 1155 if self.terminated:
1156 1156 return False
1157 1157
1158 1158 if self.flag_eof:
1159 1159 # This is for Linux, which requires the blocking form of waitpid to get
1160 1160 # status of a defunct process. This is super-lame. The flag_eof would have
1161 1161 # been set in read_nonblocking(), so this should be safe.
1162 1162 waitpid_options = 0
1163 1163 else:
1164 1164 waitpid_options = os.WNOHANG
1165 1165
1166 1166 try:
1167 1167 pid, status = os.waitpid(self.pid, waitpid_options)
1168 1168 except OSError as e: # No child processes
1169 1169 if e.errno == errno.ECHILD:
1170 1170 raise ExceptionPexpect ('isalive() encountered condition where "terminated" is 0, but there was no child process. Did someone else call waitpid() on our process?')
1171 1171 else:
1172 1172 raise e
1173 1173
1174 1174 # I have to do this twice for Solaris. I can't even believe that I figured this out...
1175 1175 # If waitpid() returns 0 it means that no child process wishes to
1176 1176 # report, and the value of status is undefined.
1177 1177 if pid == 0:
1178 1178 try:
1179 1179 pid, status = os.waitpid(self.pid, waitpid_options) ### os.WNOHANG) # Solaris!
1180 1180 except OSError, e: # This should never happen...
1181 1181 if e[0] == errno.ECHILD:
1182 1182 raise ExceptionPexpect ('isalive() encountered condition that should never happen. There was no child process. Did someone else call waitpid() on our process?')
1183 1183 else:
1184 1184 raise e
1185 1185
1186 1186 # If pid is still 0 after two calls to waitpid() then
1187 1187 # the process really is alive. This seems to work on all platforms, except
1188 1188 # for Irix which seems to require a blocking call on waitpid or select, so I let read_nonblocking
1189 1189 # take care of this situation (unfortunately, this requires waiting through the timeout).
1190 1190 if pid == 0:
1191 1191 return True
1192 1192
1193 1193 if pid == 0:
1194 1194 return True
1195 1195
1196 1196 if os.WIFEXITED (status):
1197 1197 self.status = status
1198 1198 self.exitstatus = os.WEXITSTATUS(status)
1199 1199 self.signalstatus = None
1200 1200 self.terminated = True
1201 1201 elif os.WIFSIGNALED (status):
1202 1202 self.status = status
1203 1203 self.exitstatus = None
1204 1204 self.signalstatus = os.WTERMSIG(status)
1205 1205 self.terminated = True
1206 1206 elif os.WIFSTOPPED (status):
1207 1207 raise ExceptionPexpect ('isalive() encountered condition where child process is stopped. This is not supported. Is some other process attempting job control with our child pid?')
1208 1208 return False
1209 1209
1210 1210 def kill(self, sig):
1211 1211
1212 1212 """This sends the given signal to the child application. In keeping
1213 1213 with UNIX tradition it has a misleading name. It does not necessarily
1214 1214 kill the child unless you send the right signal. """
1215 1215
1216 1216 # Same as os.kill, but the pid is given for you.
1217 1217 if self.isalive():
1218 1218 os.kill(self.pid, sig)
1219 1219
1220 1220 def compile_pattern_list(self, patterns):
1221 1221
1222 1222 """This compiles a pattern-string or a list of pattern-strings.
1223 1223 Patterns must be a StringType, EOF, TIMEOUT, SRE_Pattern, or a list of
1224 1224 those. Patterns may also be None which results in an empty list (you
1225 1225 might do this if waiting for an EOF or TIMEOUT condition without
1226 1226 expecting any pattern).
1227 1227
1228 1228 This is used by expect() when calling expect_list(). Thus expect() is
1229 1229 nothing more than::
1230 1230
1231 1231 cpl = self.compile_pattern_list(pl)
1232 1232 return self.expect_list(cpl, timeout)
1233 1233
1234 1234 If you are using expect() within a loop it may be more
1235 1235 efficient to compile the patterns first and then call expect_list().
1236 1236 This avoid calls in a loop to compile_pattern_list()::
1237 1237
1238 1238 cpl = self.compile_pattern_list(my_pattern)
1239 1239 while some_condition:
1240 1240 ...
1241 1241 i = self.expect_list(clp, timeout)
1242 1242 ...
1243 1243 """
1244 1244
1245 1245 if patterns is None:
1246 1246 return []
1247 1247 if not isinstance(patterns, list):
1248 1248 patterns = [patterns]
1249 1249
1250 1250 compile_flags = re.DOTALL # Allow dot to match \n
1251 1251 if self.ignorecase:
1252 1252 compile_flags = compile_flags | re.IGNORECASE
1253 1253 compiled_pattern_list = []
1254 1254 for p in patterns:
1255 1255 if isinstance(p, (bytes, unicode)):
1256 1256 p = self._cast_buffer_type(p)
1257 1257 compiled_pattern_list.append(re.compile(p, compile_flags))
1258 1258 elif p is EOF:
1259 1259 compiled_pattern_list.append(EOF)
1260 1260 elif p is TIMEOUT:
1261 1261 compiled_pattern_list.append(TIMEOUT)
1262 1262 elif type(p) is re_type:
1263 1263 p = self._prepare_regex_pattern(p)
1264 1264 compiled_pattern_list.append(p)
1265 1265 else:
1266 1266 raise TypeError ('Argument must be one of StringTypes, EOF, TIMEOUT, SRE_Pattern, or a list of those type. %s' % str(type(p)))
1267 1267
1268 1268 return compiled_pattern_list
1269 1269
1270 1270 def _prepare_regex_pattern(self, p):
1271 1271 "Recompile unicode regexes as bytes regexes. Overridden in subclass."
1272 1272 if isinstance(p.pattern, unicode):
1273 1273 p = re.compile(p.pattern.encode('utf-8'), p.flags &~ re.UNICODE)
1274 1274 return p
1275 1275
1276 1276 def expect(self, pattern, timeout = -1, searchwindowsize=-1):
1277 1277
1278 1278 """This seeks through the stream until a pattern is matched. The
1279 1279 pattern is overloaded and may take several types. The pattern can be a
1280 1280 StringType, EOF, a compiled re, or a list of any of those types.
1281 1281 Strings will be compiled to re types. This returns the index into the
1282 1282 pattern list. If the pattern was not a list this returns index 0 on a
1283 1283 successful match. This may raise exceptions for EOF or TIMEOUT. To
1284 1284 avoid the EOF or TIMEOUT exceptions add EOF or TIMEOUT to the pattern
1285 1285 list. That will cause expect to match an EOF or TIMEOUT condition
1286 1286 instead of raising an exception.
1287 1287
1288 1288 If you pass a list of patterns and more than one matches, the first match
1289 1289 in the stream is chosen. If more than one pattern matches at that point,
1290 1290 the leftmost in the pattern list is chosen. For example::
1291 1291
1292 1292 # the input is 'foobar'
1293 1293 index = p.expect (['bar', 'foo', 'foobar'])
1294 1294 # returns 1 ('foo') even though 'foobar' is a "better" match
1295 1295
1296 1296 Please note, however, that buffering can affect this behavior, since
1297 1297 input arrives in unpredictable chunks. For example::
1298 1298
1299 1299 # the input is 'foobar'
1300 1300 index = p.expect (['foobar', 'foo'])
1301 1301 # returns 0 ('foobar') if all input is available at once,
1302 1302 # but returs 1 ('foo') if parts of the final 'bar' arrive late
1303 1303
1304 1304 After a match is found the instance attributes 'before', 'after' and
1305 1305 'match' will be set. You can see all the data read before the match in
1306 1306 'before'. You can see the data that was matched in 'after'. The
1307 1307 re.MatchObject used in the re match will be in 'match'. If an error
1308 1308 occurred then 'before' will be set to all the data read so far and
1309 1309 'after' and 'match' will be None.
1310 1310
1311 1311 If timeout is -1 then timeout will be set to the self.timeout value.
1312 1312
1313 1313 A list entry may be EOF or TIMEOUT instead of a string. This will
1314 1314 catch these exceptions and return the index of the list entry instead
1315 1315 of raising the exception. The attribute 'after' will be set to the
1316 1316 exception type. The attribute 'match' will be None. This allows you to
1317 1317 write code like this::
1318 1318
1319 1319 index = p.expect (['good', 'bad', pexpect.EOF, pexpect.TIMEOUT])
1320 1320 if index == 0:
1321 1321 do_something()
1322 1322 elif index == 1:
1323 1323 do_something_else()
1324 1324 elif index == 2:
1325 1325 do_some_other_thing()
1326 1326 elif index == 3:
1327 1327 do_something_completely_different()
1328 1328
1329 1329 instead of code like this::
1330 1330
1331 1331 try:
1332 1332 index = p.expect (['good', 'bad'])
1333 1333 if index == 0:
1334 1334 do_something()
1335 1335 elif index == 1:
1336 1336 do_something_else()
1337 1337 except EOF:
1338 1338 do_some_other_thing()
1339 1339 except TIMEOUT:
1340 1340 do_something_completely_different()
1341 1341
1342 1342 These two forms are equivalent. It all depends on what you want. You
1343 1343 can also just expect the EOF if you are waiting for all output of a
1344 1344 child to finish. For example::
1345 1345
1346 1346 p = pexpect.spawn('/bin/ls')
1347 1347 p.expect (pexpect.EOF)
1348 1348 print p.before
1349 1349
1350 1350 If you are trying to optimize for speed then see expect_list().
1351 1351 """
1352 1352
1353 1353 compiled_pattern_list = self.compile_pattern_list(pattern)
1354 1354 return self.expect_list(compiled_pattern_list, timeout, searchwindowsize)
1355 1355
1356 1356 def expect_list(self, pattern_list, timeout = -1, searchwindowsize = -1):
1357 1357
1358 1358 """This takes a list of compiled regular expressions and returns the
1359 1359 index into the pattern_list that matched the child output. The list may
1360 1360 also contain EOF or TIMEOUT (which are not compiled regular
1361 1361 expressions). This method is similar to the expect() method except that
1362 1362 expect_list() does not recompile the pattern list on every call. This
1363 1363 may help if you are trying to optimize for speed, otherwise just use
1364 1364 the expect() method. This is called by expect(). If timeout==-1 then
1365 1365 the self.timeout value is used. If searchwindowsize==-1 then the
1366 1366 self.searchwindowsize value is used. """
1367 1367
1368 1368 return self.expect_loop(searcher_re(pattern_list), timeout, searchwindowsize)
1369 1369
1370 1370 def expect_exact(self, pattern_list, timeout = -1, searchwindowsize = -1):
1371 1371
1372 1372 """This is similar to expect(), but uses plain string matching instead
1373 1373 of compiled regular expressions in 'pattern_list'. The 'pattern_list'
1374 1374 may be a string; a list or other sequence of strings; or TIMEOUT and
1375 1375 EOF.
1376 1376
1377 1377 This call might be faster than expect() for two reasons: string
1378 1378 searching is faster than RE matching and it is possible to limit the
1379 1379 search to just the end of the input buffer.
1380 1380
1381 1381 This method is also useful when you don't want to have to worry about
1382 1382 escaping regular expression characters that you want to match."""
1383 1383
1384 1384 if isinstance(pattern_list, (bytes, unicode)) or pattern_list in (TIMEOUT, EOF):
1385 1385 pattern_list = [pattern_list]
1386 1386 return self.expect_loop(searcher_string(pattern_list), timeout, searchwindowsize)
1387 1387
1388 1388 def expect_loop(self, searcher, timeout = -1, searchwindowsize = -1):
1389 1389
1390 1390 """This is the common loop used inside expect. The 'searcher' should be
1391 1391 an instance of searcher_re or searcher_string, which describes how and what
1392 1392 to search for in the input.
1393 1393
1394 1394 See expect() for other arguments, return value and exceptions. """
1395 1395
1396 1396 self.searcher = searcher
1397 1397
1398 1398 if timeout == -1:
1399 1399 timeout = self.timeout
1400 1400 if timeout is not None:
1401 1401 end_time = time.time() + timeout
1402 1402 if searchwindowsize == -1:
1403 1403 searchwindowsize = self.searchwindowsize
1404 1404
1405 1405 try:
1406 1406 incoming = self.buffer
1407 1407 freshlen = len(incoming)
1408 1408 while True: # Keep reading until exception or return.
1409 1409 index = searcher.search(incoming, freshlen, searchwindowsize)
1410 1410 if index >= 0:
1411 1411 self.buffer = incoming[searcher.end : ]
1412 1412 self.before = incoming[ : searcher.start]
1413 1413 self.after = incoming[searcher.start : searcher.end]
1414 1414 self.match = searcher.match
1415 1415 self.match_index = index
1416 1416 return self.match_index
1417 1417 # No match at this point
1418 1418 if timeout is not None and timeout < 0:
1419 1419 raise TIMEOUT ('Timeout exceeded in expect_any().')
1420 1420 # Still have time left, so read more data
1421 1421 c = self.read_nonblocking (self.maxread, timeout)
1422 1422 freshlen = len(c)
1423 1423 time.sleep (0.0001)
1424 1424 incoming = incoming + c
1425 1425 if timeout is not None:
1426 1426 timeout = end_time - time.time()
1427 1427 except EOF, e:
1428 1428 self.buffer = self._empty_buffer
1429 1429 self.before = incoming
1430 1430 self.after = EOF
1431 1431 index = searcher.eof_index
1432 1432 if index >= 0:
1433 1433 self.match = EOF
1434 1434 self.match_index = index
1435 1435 return self.match_index
1436 1436 else:
1437 1437 self.match = None
1438 1438 self.match_index = None
1439 1439 raise EOF (str(e) + '\n' + str(self))
1440 1440 except TIMEOUT, e:
1441 1441 self.buffer = incoming
1442 1442 self.before = incoming
1443 1443 self.after = TIMEOUT
1444 1444 index = searcher.timeout_index
1445 1445 if index >= 0:
1446 1446 self.match = TIMEOUT
1447 1447 self.match_index = index
1448 1448 return self.match_index
1449 1449 else:
1450 1450 self.match = None
1451 1451 self.match_index = None
1452 1452 raise TIMEOUT (str(e) + '\n' + str(self))
1453 1453 except:
1454 1454 self.before = incoming
1455 1455 self.after = None
1456 1456 self.match = None
1457 1457 self.match_index = None
1458 1458 raise
1459 1459
1460 1460 def getwinsize(self):
1461 1461
1462 1462 """This returns the terminal window size of the child tty. The return
1463 1463 value is a tuple of (rows, cols). """
1464 1464
1465 1465 TIOCGWINSZ = getattr(termios, 'TIOCGWINSZ', 1074295912L)
1466 1466 s = struct.pack('HHHH', 0, 0, 0, 0)
1467 1467 x = fcntl.ioctl(self.fileno(), TIOCGWINSZ, s)
1468 1468 return struct.unpack('HHHH', x)[0:2]
1469 1469
1470 1470 def setwinsize(self, r, c):
1471 1471
1472 1472 """This sets the terminal window size of the child tty. This will cause
1473 1473 a SIGWINCH signal to be sent to the child. This does not change the
1474 1474 physical window size. It changes the size reported to TTY-aware
1475 1475 applications like vi or curses -- applications that respond to the
1476 1476 SIGWINCH signal. """
1477 1477
1478 1478 # Check for buggy platforms. Some Python versions on some platforms
1479 1479 # (notably OSF1 Alpha and RedHat 7.1) truncate the value for
1480 1480 # termios.TIOCSWINSZ. It is not clear why this happens.
1481 1481 # These platforms don't seem to handle the signed int very well;
1482 1482 # yet other platforms like OpenBSD have a large negative value for
1483 1483 # TIOCSWINSZ and they don't have a truncate problem.
1484 1484 # Newer versions of Linux have totally different values for TIOCSWINSZ.
1485 1485 # Note that this fix is a hack.
1486 1486 TIOCSWINSZ = getattr(termios, 'TIOCSWINSZ', -2146929561)
1487 1487 if TIOCSWINSZ == 2148037735L: # L is not required in Python >= 2.2.
1488 1488 TIOCSWINSZ = -2146929561 # Same bits, but with sign.
1489 1489 # Note, assume ws_xpixel and ws_ypixel are zero.
1490 1490 s = struct.pack('HHHH', r, c, 0, 0)
1491 1491 fcntl.ioctl(self.fileno(), TIOCSWINSZ, s)
1492 1492
1493 1493 def interact(self, escape_character = b'\x1d', input_filter = None, output_filter = None):
1494 1494
1495 1495 """This gives control of the child process to the interactive user (the
1496 1496 human at the keyboard). Keystrokes are sent to the child process, and
1497 1497 the stdout and stderr output of the child process is printed. This
1498 1498 simply echos the child stdout and child stderr to the real stdout and
1499 1499 it echos the real stdin to the child stdin. When the user types the
1500 1500 escape_character this method will stop. The default for
1501 1501 escape_character is ^]. This should not be confused with ASCII 27 --
1502 1502 the ESC character. ASCII 29 was chosen for historical merit because
1503 1503 this is the character used by 'telnet' as the escape character. The
1504 1504 escape_character will not be sent to the child process.
1505 1505
1506 1506 You may pass in optional input and output filter functions. These
1507 1507 functions should take a string and return a string. The output_filter
1508 1508 will be passed all the output from the child process. The input_filter
1509 1509 will be passed all the keyboard input from the user. The input_filter
1510 1510 is run BEFORE the check for the escape_character.
1511 1511
1512 1512 Note that if you change the window size of the parent the SIGWINCH
1513 1513 signal will not be passed through to the child. If you want the child
1514 1514 window size to change when the parent's window size changes then do
1515 1515 something like the following example::
1516 1516
1517 1517 import pexpect, struct, fcntl, termios, signal, sys
1518 1518 def sigwinch_passthrough (sig, data):
1519 1519 s = struct.pack("HHHH", 0, 0, 0, 0)
1520 1520 a = struct.unpack('hhhh', fcntl.ioctl(sys.stdout.fileno(), termios.TIOCGWINSZ , s))
1521 1521 global p
1522 1522 p.setwinsize(a[0],a[1])
1523 1523 p = pexpect.spawn('/bin/bash') # Note this is global and used in sigwinch_passthrough.
1524 1524 signal.signal(signal.SIGWINCH, sigwinch_passthrough)
1525 1525 p.interact()
1526 1526 """
1527 1527
1528 1528 # Flush the buffer.
1529 1529 if PY3: self.stdout.write(_cast_unicode(self.buffer, self.encoding))
1530 1530 else: self.stdout.write(self.buffer)
1531 1531 self.stdout.flush()
1532 1532 self.buffer = self._empty_buffer
1533 1533 mode = tty.tcgetattr(self.STDIN_FILENO)
1534 1534 tty.setraw(self.STDIN_FILENO)
1535 1535 try:
1536 1536 self.__interact_copy(escape_character, input_filter, output_filter)
1537 1537 finally:
1538 1538 tty.tcsetattr(self.STDIN_FILENO, tty.TCSAFLUSH, mode)
1539 1539
1540 1540 def __interact_writen(self, fd, data):
1541 1541
1542 1542 """This is used by the interact() method.
1543 1543 """
1544 1544
1545 1545 while data != b'' and self.isalive():
1546 1546 n = os.write(fd, data)
1547 1547 data = data[n:]
1548 1548
1549 1549 def __interact_read(self, fd):
1550 1550
1551 1551 """This is used by the interact() method.
1552 1552 """
1553 1553
1554 1554 return os.read(fd, 1000)
1555 1555
1556 1556 def __interact_copy(self, escape_character = None, input_filter = None, output_filter = None):
1557 1557
1558 1558 """This is used by the interact() method.
1559 1559 """
1560 1560
1561 1561 while self.isalive():
1562 1562 r,w,e = self.__select([self.child_fd, self.STDIN_FILENO], [], [])
1563 1563 if self.child_fd in r:
1564 1564 data = self.__interact_read(self.child_fd)
1565 1565 if output_filter: data = output_filter(data)
1566 1566 if self.logfile is not None:
1567 1567 self.logfile.write (data)
1568 1568 self.logfile.flush()
1569 1569 os.write(self.STDOUT_FILENO, data)
1570 1570 if self.STDIN_FILENO in r:
1571 1571 data = self.__interact_read(self.STDIN_FILENO)
1572 1572 if input_filter: data = input_filter(data)
1573 1573 i = data.rfind(escape_character)
1574 1574 if i != -1:
1575 1575 data = data[:i]
1576 1576 self.__interact_writen(self.child_fd, data)
1577 1577 break
1578 1578 self.__interact_writen(self.child_fd, data)
1579 1579
1580 1580 def __select (self, iwtd, owtd, ewtd, timeout=None):
1581 1581
1582 1582 """This is a wrapper around select.select() that ignores signals. If
1583 1583 select.select raises a select.error exception and errno is an EINTR
1584 1584 error then it is ignored. Mainly this is used to ignore sigwinch
1585 1585 (terminal resize). """
1586 1586
1587 1587 # if select() is interrupted by a signal (errno==EINTR) then
1588 1588 # we loop back and enter the select() again.
1589 1589 if timeout is not None:
1590 1590 end_time = time.time() + timeout
1591 1591 while True:
1592 1592 try:
1593 1593 return select.select (iwtd, owtd, ewtd, timeout)
1594 1594 except select.error as e:
1595 1595 if e.args[0] == errno.EINTR:
1596 1596 # if we loop back we have to subtract the amount of time we already waited.
1597 1597 if timeout is not None:
1598 1598 timeout = end_time - time.time()
1599 1599 if timeout < 0:
1600 1600 return ([],[],[])
1601 1601 else: # something else caused the select.error, so this really is an exception
1602 1602 raise
1603 1603
1604 1604 class spawn(spawnb):
1605 1605 """This is the main class interface for Pexpect. Use this class to start
1606 1606 and control child applications."""
1607 1607
1608 1608 _buffer_type = unicode
1609 1609 def _cast_buffer_type(self, s):
1610 1610 return _cast_unicode(s, self.encoding)
1611 1611 _empty_buffer = u''
1612 1612 _pty_newline = u'\r\n'
1613 1613
1614 1614 def __init__(self, command, args=[], timeout=30, maxread=2000, searchwindowsize=None,
1615 1615 logfile=None, cwd=None, env=None, encoding='utf-8'):
1616 1616 super(spawn, self).__init__(command, args, timeout=timeout, maxread=maxread,
1617 1617 searchwindowsize=searchwindowsize, logfile=logfile, cwd=cwd, env=env)
1618 1618 self.encoding = encoding
1619 1619
1620 1620 def _prepare_regex_pattern(self, p):
1621 1621 "Recompile bytes regexes as unicode regexes."
1622 1622 if isinstance(p.pattern, bytes):
1623 1623 p = re.compile(p.pattern.decode(self.encoding), p.flags)
1624 1624 return p
1625 1625
1626 1626 def read_nonblocking(self, size=1, timeout=-1):
1627 1627 return super(spawn, self).read_nonblocking(size=size, timeout=timeout)\
1628 1628 .decode(self.encoding)
1629 1629
1630 1630 read_nonblocking.__doc__ = spawnb.read_nonblocking.__doc__
1631 1631
1632 1632
1633 1633 ##############################################################################
1634 1634 # End of spawn class
1635 1635 ##############################################################################
1636 1636
1637 1637 class searcher_string (object):
1638 1638
1639 1639 """This is a plain string search helper for the spawn.expect_any() method.
1640 1640 This helper class is for speed. For more powerful regex patterns
1641 1641 see the helper class, searcher_re.
1642 1642
1643 1643 Attributes:
1644 1644
1645 1645 eof_index - index of EOF, or -1
1646 1646 timeout_index - index of TIMEOUT, or -1
1647 1647
1648 1648 After a successful match by the search() method the following attributes
1649 1649 are available:
1650 1650
1651 1651 start - index into the buffer, first byte of match
1652 1652 end - index into the buffer, first byte after match
1653 1653 match - the matching string itself
1654 1654
1655 1655 """
1656 1656
1657 1657 def __init__(self, strings):
1658 1658
1659 1659 """This creates an instance of searcher_string. This argument 'strings'
1660 1660 may be a list; a sequence of strings; or the EOF or TIMEOUT types. """
1661 1661
1662 1662 self.eof_index = -1
1663 1663 self.timeout_index = -1
1664 1664 self._strings = []
1665 1665 for n, s in enumerate(strings):
1666 1666 if s is EOF:
1667 1667 self.eof_index = n
1668 1668 continue
1669 1669 if s is TIMEOUT:
1670 1670 self.timeout_index = n
1671 1671 continue
1672 1672 self._strings.append((n, s))
1673 1673
1674 1674 def __str__(self):
1675 1675
1676 1676 """This returns a human-readable string that represents the state of
1677 1677 the object."""
1678 1678
1679 1679 ss = [ (ns[0],' %d: "%s"' % ns) for ns in self._strings ]
1680 1680 ss.append((-1,'searcher_string:'))
1681 1681 if self.eof_index >= 0:
1682 1682 ss.append ((self.eof_index,' %d: EOF' % self.eof_index))
1683 1683 if self.timeout_index >= 0:
1684 1684 ss.append ((self.timeout_index,' %d: TIMEOUT' % self.timeout_index))
1685 1685 ss.sort()
1686 1686 return '\n'.join(a[1] for a in ss)
1687 1687
1688 1688 def search(self, buffer, freshlen, searchwindowsize=None):
1689 1689
1690 1690 """This searches 'buffer' for the first occurence of one of the search
1691 1691 strings. 'freshlen' must indicate the number of bytes at the end of
1692 1692 'buffer' which have not been searched before. It helps to avoid
1693 1693 searching the same, possibly big, buffer over and over again.
1694 1694
1695 1695 See class spawn for the 'searchwindowsize' argument.
1696 1696
1697 1697 If there is a match this returns the index of that string, and sets
1698 1698 'start', 'end' and 'match'. Otherwise, this returns -1. """
1699 1699
1700 1700 absurd_match = len(buffer)
1701 1701 first_match = absurd_match
1702 1702
1703 1703 # 'freshlen' helps a lot here. Further optimizations could
1704 1704 # possibly include:
1705 1705 #
1706 1706 # using something like the Boyer-Moore Fast String Searching
1707 1707 # Algorithm; pre-compiling the search through a list of
1708 1708 # strings into something that can scan the input once to
1709 1709 # search for all N strings; realize that if we search for
1710 1710 # ['bar', 'baz'] and the input is '...foo' we need not bother
1711 1711 # rescanning until we've read three more bytes.
1712 1712 #
1713 1713 # Sadly, I don't know enough about this interesting topic. /grahn
1714 1714
1715 1715 for index, s in self._strings:
1716 1716 if searchwindowsize is None:
1717 1717 # the match, if any, can only be in the fresh data,
1718 1718 # or at the very end of the old data
1719 1719 offset = -(freshlen+len(s))
1720 1720 else:
1721 1721 # better obey searchwindowsize
1722 1722 offset = -searchwindowsize
1723 1723 n = buffer.find(s, offset)
1724 1724 if n >= 0 and n < first_match:
1725 1725 first_match = n
1726 1726 best_index, best_match = index, s
1727 1727 if first_match == absurd_match:
1728 1728 return -1
1729 1729 self.match = best_match
1730 1730 self.start = first_match
1731 1731 self.end = self.start + len(self.match)
1732 1732 return best_index
1733 1733
1734 1734 class searcher_re (object):
1735 1735
1736 1736 """This is regular expression string search helper for the
1737 1737 spawn.expect_any() method. This helper class is for powerful
1738 1738 pattern matching. For speed, see the helper class, searcher_string.
1739 1739
1740 1740 Attributes:
1741 1741
1742 1742 eof_index - index of EOF, or -1
1743 1743 timeout_index - index of TIMEOUT, or -1
1744 1744
1745 1745 After a successful match by the search() method the following attributes
1746 1746 are available:
1747 1747
1748 1748 start - index into the buffer, first byte of match
1749 1749 end - index into the buffer, first byte after match
1750 1750 match - the re.match object returned by a succesful re.search
1751 1751
1752 1752 """
1753 1753
1754 1754 def __init__(self, patterns):
1755 1755
1756 1756 """This creates an instance that searches for 'patterns' Where
1757 1757 'patterns' may be a list or other sequence of compiled regular
1758 1758 expressions, or the EOF or TIMEOUT types."""
1759 1759
1760 1760 self.eof_index = -1
1761 1761 self.timeout_index = -1
1762 1762 self._searches = []
1763 1763 for n, s in enumerate(patterns):
1764 1764 if s is EOF:
1765 1765 self.eof_index = n
1766 1766 continue
1767 1767 if s is TIMEOUT:
1768 1768 self.timeout_index = n
1769 1769 continue
1770 1770 self._searches.append((n, s))
1771 1771
1772 1772 def __str__(self):
1773 1773
1774 1774 """This returns a human-readable string that represents the state of
1775 1775 the object."""
1776 1776
1777 1777 ss = [ (n,' %d: re.compile("%s")' % (n,str(s.pattern))) for n,s in self._searches]
1778 1778 ss.append((-1,'searcher_re:'))
1779 1779 if self.eof_index >= 0:
1780 1780 ss.append ((self.eof_index,' %d: EOF' % self.eof_index))
1781 1781 if self.timeout_index >= 0:
1782 1782 ss.append ((self.timeout_index,' %d: TIMEOUT' % self.timeout_index))
1783 1783 ss.sort()
1784 1784 return '\n'.join(a[1] for a in ss)
1785 1785
1786 1786 def search(self, buffer, freshlen, searchwindowsize=None):
1787 1787
1788 1788 """This searches 'buffer' for the first occurence of one of the regular
1789 1789 expressions. 'freshlen' must indicate the number of bytes at the end of
1790 1790 'buffer' which have not been searched before.
1791 1791
1792 1792 See class spawn for the 'searchwindowsize' argument.
1793 1793
1794 1794 If there is a match this returns the index of that string, and sets
1795 1795 'start', 'end' and 'match'. Otherwise, returns -1."""
1796 1796
1797 1797 absurd_match = len(buffer)
1798 1798 first_match = absurd_match
1799 1799 # 'freshlen' doesn't help here -- we cannot predict the
1800 1800 # length of a match, and the re module provides no help.
1801 1801 if searchwindowsize is None:
1802 1802 searchstart = 0
1803 1803 else:
1804 1804 searchstart = max(0, len(buffer)-searchwindowsize)
1805 1805 for index, s in self._searches:
1806 1806 match = s.search(buffer, searchstart)
1807 1807 if match is None:
1808 1808 continue
1809 1809 n = match.start()
1810 1810 if n < first_match:
1811 1811 first_match = n
1812 1812 the_match = match
1813 1813 best_index = index
1814 1814 if first_match == absurd_match:
1815 1815 return -1
1816 1816 self.start = first_match
1817 1817 self.match = the_match
1818 1818 self.end = self.match.end()
1819 1819 return best_index
1820 1820
1821 1821 def which (filename):
1822 1822
1823 1823 """This takes a given filename; tries to find it in the environment path;
1824 1824 then checks if it is executable. This returns the full path to the filename
1825 1825 if found and executable. Otherwise this returns None."""
1826 1826
1827 1827 # Special case where filename already contains a path.
1828 1828 if os.path.dirname(filename) != '':
1829 1829 if os.access (filename, os.X_OK):
1830 1830 return filename
1831 1831
1832 1832 if not os.environ.has_key('PATH') or os.environ['PATH'] == '':
1833 1833 p = os.defpath
1834 1834 else:
1835 1835 p = os.environ['PATH']
1836 1836
1837 1837 pathlist = p.split(os.pathsep)
1838 1838
1839 1839 for path in pathlist:
1840 1840 f = os.path.join(path, filename)
1841 1841 if os.access(f, os.X_OK):
1842 1842 return f
1843 1843 return None
1844 1844
1845 1845 def split_command_line(command_line):
1846 1846
1847 1847 """This splits a command line into a list of arguments. It splits arguments
1848 1848 on spaces, but handles embedded quotes, doublequotes, and escaped
1849 1849 characters. It's impossible to do this with a regular expression, so I
1850 1850 wrote a little state machine to parse the command line. """
1851 1851
1852 1852 arg_list = []
1853 1853 arg = ''
1854 1854
1855 1855 # Constants to name the states we can be in.
1856 1856 state_basic = 0
1857 1857 state_esc = 1
1858 1858 state_singlequote = 2
1859 1859 state_doublequote = 3
1860 1860 state_whitespace = 4 # The state of consuming whitespace between commands.
1861 1861 state = state_basic
1862 1862
1863 1863 for c in command_line:
1864 1864 if state == state_basic or state == state_whitespace:
1865 1865 if c == '\\': # Escape the next character
1866 1866 state = state_esc
1867 1867 elif c == r"'": # Handle single quote
1868 1868 state = state_singlequote
1869 1869 elif c == r'"': # Handle double quote
1870 1870 state = state_doublequote
1871 1871 elif c.isspace():
1872 1872 # Add arg to arg_list if we aren't in the middle of whitespace.
1873 1873 if state == state_whitespace:
1874 1874 None # Do nothing.
1875 1875 else:
1876 1876 arg_list.append(arg)
1877 1877 arg = ''
1878 1878 state = state_whitespace
1879 1879 else:
1880 1880 arg = arg + c
1881 1881 state = state_basic
1882 1882 elif state == state_esc:
1883 1883 arg = arg + c
1884 1884 state = state_basic
1885 1885 elif state == state_singlequote:
1886 1886 if c == r"'":
1887 1887 state = state_basic
1888 1888 else:
1889 1889 arg = arg + c
1890 1890 elif state == state_doublequote:
1891 1891 if c == r'"':
1892 1892 state = state_basic
1893 1893 else:
1894 1894 arg = arg + c
1895 1895
1896 1896 if arg != '':
1897 1897 arg_list.append(arg)
1898 1898 return arg_list
1899 1899
1900 1900 # vi:set sr et ts=4 sw=4 ft=python :
@@ -1,668 +1,668 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Subclass of InteractiveShell for terminal based frontends."""
3 3
4 4 #-----------------------------------------------------------------------------
5 5 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
6 6 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
7 7 # Copyright (C) 2008-2011 The IPython Development Team
8 8 #
9 9 # Distributed under the terms of the BSD License. The full license is in
10 10 # the file COPYING, distributed as part of this software.
11 11 #-----------------------------------------------------------------------------
12 12
13 13 #-----------------------------------------------------------------------------
14 14 # Imports
15 15 #-----------------------------------------------------------------------------
16 16
17 17 import __builtin__
18 18 import bdb
19 19 import os
20 20 import re
21 21 import sys
22 22 import textwrap
23 23
24 24 try:
25 25 from contextlib import nested
26 26 except:
27 27 from IPython.utils.nested_context import nested
28 28
29 29 from IPython.core.error import TryNext, UsageError
30 30 from IPython.core.usage import interactive_usage, default_banner
31 31 from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
32 32 from IPython.core.pylabtools import pylab_activate
33 33 from IPython.testing.skipdoctest import skip_doctest
34 34 from IPython.utils import py3compat
35 35 from IPython.utils.terminal import toggle_set_term_title, set_term_title
36 36 from IPython.utils.process import abbrev_cwd
37 37 from IPython.utils.warn import warn, error
38 38 from IPython.utils.text import num_ini_spaces, SList
39 39 from IPython.utils.traitlets import Integer, CBool, Unicode
40 40
41 41 #-----------------------------------------------------------------------------
42 42 # Utilities
43 43 #-----------------------------------------------------------------------------
44 44
45 45 def get_default_editor():
46 46 try:
47 47 ed = os.environ['EDITOR']
48 48 except KeyError:
49 49 if os.name == 'posix':
50 50 ed = 'vi' # the only one guaranteed to be there!
51 51 else:
52 52 ed = 'notepad' # same in Windows!
53 53 return ed
54 54
55 55
56 56 def get_pasted_lines(sentinel, l_input=py3compat.input):
57 57 """ Yield pasted lines until the user enters the given sentinel value.
58 58 """
59 59 print "Pasting code; enter '%s' alone on the line to stop or use Ctrl-D." \
60 60 % sentinel
61 61 while True:
62 62 try:
63 63 l = l_input(':')
64 64 if l == sentinel:
65 65 return
66 66 else:
67 67 yield l
68 68 except EOFError:
69 69 print '<EOF>'
70 70 return
71 71
72 72
73 73 def strip_email_quotes(raw_lines):
74 74 """ Strip email quotation marks at the beginning of each line.
75 75
76 76 We don't do any more input transofrmations here because the main shell's
77 77 prefiltering handles other cases.
78 78 """
79 79 lines = [re.sub(r'^\s*(\s?>)+', '', l) for l in raw_lines]
80 80 return '\n'.join(lines) + '\n'
81 81
82 82
83 83 # These two functions are needed by the %paste/%cpaste magics. In practice
84 84 # they are basically methods (they take the shell as their first argument), but
85 85 # we leave them as standalone functions because eventually the magics
86 86 # themselves will become separate objects altogether. At that point, the
87 87 # magics will have access to the shell object, and these functions can be made
88 88 # methods of the magic object, but not of the shell.
89 89
90 90 def store_or_execute(shell, block, name):
91 91 """ Execute a block, or store it in a variable, per the user's request.
92 92 """
93 93 # Dedent and prefilter so what we store matches what is executed by
94 94 # run_cell.
95 95 b = shell.prefilter(textwrap.dedent(block))
96 96
97 97 if name:
98 98 # If storing it for further editing, run the prefilter on it
99 99 shell.user_ns[name] = SList(b.splitlines())
100 100 print "Block assigned to '%s'" % name
101 101 else:
102 102 shell.user_ns['pasted_block'] = b
103 103 shell.run_cell(b)
104 104
105 105
106 106 def rerun_pasted(shell, name='pasted_block'):
107 107 """ Rerun a previously pasted command.
108 108 """
109 109 b = shell.user_ns.get(name)
110 110
111 111 # Sanity checks
112 112 if b is None:
113 113 raise UsageError('No previous pasted block available')
114 114 if not isinstance(b, basestring):
115 115 raise UsageError(
116 116 "Variable 'pasted_block' is not a string, can't execute")
117 117
118 118 print "Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b))
119 119 shell.run_cell(b)
120 120
121 121
122 122 #-----------------------------------------------------------------------------
123 123 # Main class
124 124 #-----------------------------------------------------------------------------
125 125
126 126 class TerminalInteractiveShell(InteractiveShell):
127 127
128 128 autoedit_syntax = CBool(False, config=True,
129 129 help="auto editing of files with syntax errors.")
130 130 banner = Unicode('')
131 131 banner1 = Unicode(default_banner, config=True,
132 132 help="""The part of the banner to be printed before the profile"""
133 133 )
134 134 banner2 = Unicode('', config=True,
135 135 help="""The part of the banner to be printed after the profile"""
136 136 )
137 137 confirm_exit = CBool(True, config=True,
138 138 help="""
139 139 Set to confirm when you try to exit IPython with an EOF (Control-D
140 140 in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
141 141 you can force a direct exit without any confirmation.""",
142 142 )
143 143 # This display_banner only controls whether or not self.show_banner()
144 144 # is called when mainloop/interact are called. The default is False
145 145 # because for the terminal based application, the banner behavior
146 146 # is controlled by Global.display_banner, which IPythonApp looks at
147 147 # to determine if *it* should call show_banner() by hand or not.
148 148 display_banner = CBool(False) # This isn't configurable!
149 149 embedded = CBool(False)
150 150 embedded_active = CBool(False)
151 151 editor = Unicode(get_default_editor(), config=True,
152 152 help="Set the editor used by IPython (default to $EDITOR/vi/notepad)."
153 153 )
154 154 pager = Unicode('less', config=True,
155 155 help="The shell program to be used for paging.")
156 156
157 157 screen_length = Integer(0, config=True,
158 158 help=
159 159 """Number of lines of your screen, used to control printing of very
160 160 long strings. Strings longer than this number of lines will be sent
161 161 through a pager instead of directly printed. The default value for
162 162 this is 0, which means IPython will auto-detect your screen size every
163 163 time it needs to print certain potentially long strings (this doesn't
164 164 change the behavior of the 'print' keyword, it's only triggered
165 165 internally). If for some reason this isn't working well (it needs
166 166 curses support), specify it yourself. Otherwise don't change the
167 167 default.""",
168 168 )
169 169 term_title = CBool(False, config=True,
170 170 help="Enable auto setting the terminal title."
171 171 )
172 172
173 173 # In the terminal, GUI control is done via PyOS_InputHook
174 174 from IPython.lib.inputhook import enable_gui
175 175 enable_gui = staticmethod(enable_gui)
176 176
177 177 def __init__(self, config=None, ipython_dir=None, profile_dir=None,
178 178 user_ns=None, user_module=None, custom_exceptions=((),None),
179 179 usage=None, banner1=None, banner2=None, display_banner=None):
180 180
181 181 super(TerminalInteractiveShell, self).__init__(
182 182 config=config, profile_dir=profile_dir, user_ns=user_ns,
183 183 user_module=user_module, custom_exceptions=custom_exceptions
184 184 )
185 185 # use os.system instead of utils.process.system by default,
186 186 # because piped system doesn't make sense in the Terminal:
187 187 self.system = self.system_raw
188 188
189 189 self.init_term_title()
190 190 self.init_usage(usage)
191 191 self.init_banner(banner1, banner2, display_banner)
192 192
193 193 #-------------------------------------------------------------------------
194 194 # Things related to the terminal
195 195 #-------------------------------------------------------------------------
196 196
197 197 @property
198 198 def usable_screen_length(self):
199 199 if self.screen_length == 0:
200 200 return 0
201 201 else:
202 202 num_lines_bot = self.separate_in.count('\n')+1
203 203 return self.screen_length - num_lines_bot
204 204
205 205 def init_term_title(self):
206 206 # Enable or disable the terminal title.
207 207 if self.term_title:
208 208 toggle_set_term_title(True)
209 209 set_term_title('IPython: ' + abbrev_cwd())
210 210 else:
211 211 toggle_set_term_title(False)
212 212
213 213 #-------------------------------------------------------------------------
214 214 # Things related to aliases
215 215 #-------------------------------------------------------------------------
216 216
217 217 def init_alias(self):
218 218 # The parent class defines aliases that can be safely used with any
219 219 # frontend.
220 220 super(TerminalInteractiveShell, self).init_alias()
221 221
222 222 # Now define aliases that only make sense on the terminal, because they
223 223 # need direct access to the console in a way that we can't emulate in
224 224 # GUI or web frontend
225 225 if os.name == 'posix':
226 226 aliases = [('clear', 'clear'), ('more', 'more'), ('less', 'less'),
227 227 ('man', 'man')]
228 228 elif os.name == 'nt':
229 229 aliases = [('cls', 'cls')]
230 230
231 231
232 232 for name, cmd in aliases:
233 233 self.alias_manager.define_alias(name, cmd)
234 234
235 235 #-------------------------------------------------------------------------
236 236 # Things related to the banner and usage
237 237 #-------------------------------------------------------------------------
238 238
239 239 def _banner1_changed(self):
240 240 self.compute_banner()
241 241
242 242 def _banner2_changed(self):
243 243 self.compute_banner()
244 244
245 245 def _term_title_changed(self, name, new_value):
246 246 self.init_term_title()
247 247
248 248 def init_banner(self, banner1, banner2, display_banner):
249 249 if banner1 is not None:
250 250 self.banner1 = banner1
251 251 if banner2 is not None:
252 252 self.banner2 = banner2
253 253 if display_banner is not None:
254 254 self.display_banner = display_banner
255 255 self.compute_banner()
256 256
257 257 def show_banner(self, banner=None):
258 258 if banner is None:
259 259 banner = self.banner
260 260 self.write(banner)
261 261
262 262 def compute_banner(self):
263 263 self.banner = self.banner1
264 264 if self.profile and self.profile != 'default':
265 265 self.banner += '\nIPython profile: %s\n' % self.profile
266 266 if self.banner2:
267 267 self.banner += '\n' + self.banner2
268 268
269 269 def init_usage(self, usage=None):
270 270 if usage is None:
271 271 self.usage = interactive_usage
272 272 else:
273 273 self.usage = usage
274 274
275 275 #-------------------------------------------------------------------------
276 276 # Mainloop and code execution logic
277 277 #-------------------------------------------------------------------------
278 278
279 279 def mainloop(self, display_banner=None):
280 280 """Start the mainloop.
281 281
282 282 If an optional banner argument is given, it will override the
283 283 internally created default banner.
284 284 """
285 285
286 286 with nested(self.builtin_trap, self.display_trap):
287 287
288 288 while 1:
289 289 try:
290 290 self.interact(display_banner=display_banner)
291 291 #self.interact_with_readline()
292 292 # XXX for testing of a readline-decoupled repl loop, call
293 293 # interact_with_readline above
294 294 break
295 295 except KeyboardInterrupt:
296 296 # this should not be necessary, but KeyboardInterrupt
297 297 # handling seems rather unpredictable...
298 298 self.write("\nKeyboardInterrupt in interact()\n")
299 299
300 300 def _replace_rlhist_multiline(self, source_raw, hlen_before_cell):
301 301 """Store multiple lines as a single entry in history"""
302 302
303 303 # do nothing without readline or disabled multiline
304 304 if not self.has_readline or not self.multiline_history:
305 305 return hlen_before_cell
306 306
307 307 # windows rl has no remove_history_item
308 308 if not hasattr(self.readline, "remove_history_item"):
309 309 return hlen_before_cell
310 310
311 311 # skip empty cells
312 312 if not source_raw.rstrip():
313 313 return hlen_before_cell
314 314
315 315 # nothing changed do nothing, e.g. when rl removes consecutive dups
316 316 hlen = self.readline.get_current_history_length()
317 317 if hlen == hlen_before_cell:
318 318 return hlen_before_cell
319 319
320 320 for i in range(hlen - hlen_before_cell):
321 321 self.readline.remove_history_item(hlen - i - 1)
322 322 stdin_encoding = sys.stdin.encoding or "utf-8"
323 323 self.readline.add_history(py3compat.unicode_to_str(source_raw.rstrip(),
324 324 stdin_encoding))
325 325 return self.readline.get_current_history_length()
326 326
327 327 def interact(self, display_banner=None):
328 328 """Closely emulate the interactive Python console."""
329 329
330 330 # batch run -> do not interact
331 331 if self.exit_now:
332 332 return
333 333
334 334 if display_banner is None:
335 335 display_banner = self.display_banner
336 336
337 337 if isinstance(display_banner, basestring):
338 338 self.show_banner(display_banner)
339 339 elif display_banner:
340 340 self.show_banner()
341 341
342 342 more = False
343 343
344 344 if self.has_readline:
345 345 self.readline_startup_hook(self.pre_readline)
346 346 hlen_b4_cell = self.readline.get_current_history_length()
347 347 else:
348 348 hlen_b4_cell = 0
349 349 # exit_now is set by a call to %Exit or %Quit, through the
350 350 # ask_exit callback.
351 351
352 352 while not self.exit_now:
353 353 self.hooks.pre_prompt_hook()
354 354 if more:
355 355 try:
356 356 prompt = self.prompt_manager.render('in2')
357 357 except:
358 358 self.showtraceback()
359 359 if self.autoindent:
360 360 self.rl_do_indent = True
361 361
362 362 else:
363 363 try:
364 364 prompt = self.separate_in + self.prompt_manager.render('in')
365 365 except:
366 366 self.showtraceback()
367 367 try:
368 368 line = self.raw_input(prompt)
369 369 if self.exit_now:
370 370 # quick exit on sys.std[in|out] close
371 371 break
372 372 if self.autoindent:
373 373 self.rl_do_indent = False
374 374
375 375 except KeyboardInterrupt:
376 376 #double-guard against keyboardinterrupts during kbdint handling
377 377 try:
378 378 self.write('\nKeyboardInterrupt\n')
379 379 source_raw = self.input_splitter.source_raw_reset()[1]
380 380 hlen_b4_cell = \
381 381 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
382 382 more = False
383 383 except KeyboardInterrupt:
384 384 pass
385 385 except EOFError:
386 386 if self.autoindent:
387 387 self.rl_do_indent = False
388 388 if self.has_readline:
389 389 self.readline_startup_hook(None)
390 390 self.write('\n')
391 391 self.exit()
392 392 except bdb.BdbQuit:
393 393 warn('The Python debugger has exited with a BdbQuit exception.\n'
394 394 'Because of how pdb handles the stack, it is impossible\n'
395 395 'for IPython to properly format this particular exception.\n'
396 396 'IPython will resume normal operation.')
397 397 except:
398 398 # exceptions here are VERY RARE, but they can be triggered
399 399 # asynchronously by signal handlers, for example.
400 400 self.showtraceback()
401 401 else:
402 402 self.input_splitter.push(line)
403 403 more = self.input_splitter.push_accepts_more()
404 404 if (self.SyntaxTB.last_syntax_error and
405 405 self.autoedit_syntax):
406 406 self.edit_syntax_error()
407 407 if not more:
408 408 source_raw = self.input_splitter.source_raw_reset()[1]
409 409 self.run_cell(source_raw, store_history=True)
410 410 hlen_b4_cell = \
411 411 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
412 412
413 413 # Turn off the exit flag, so the mainloop can be restarted if desired
414 414 self.exit_now = False
415 415
416 416 def raw_input(self, prompt=''):
417 417 """Write a prompt and read a line.
418 418
419 419 The returned line does not include the trailing newline.
420 420 When the user enters the EOF key sequence, EOFError is raised.
421 421
422 422 Optional inputs:
423 423
424 424 - prompt(''): a string to be printed to prompt the user.
425 425
426 426 - continue_prompt(False): whether this line is the first one or a
427 427 continuation in a sequence of inputs.
428 428 """
429 429 # Code run by the user may have modified the readline completer state.
430 430 # We must ensure that our completer is back in place.
431 431
432 432 if self.has_readline:
433 433 self.set_readline_completer()
434 434
435 435 try:
436 436 line = py3compat.str_to_unicode(self.raw_input_original(prompt))
437 437 except ValueError:
438 438 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
439 439 " or sys.stdout.close()!\nExiting IPython!")
440 440 self.ask_exit()
441 441 return ""
442 442
443 443 # Try to be reasonably smart about not re-indenting pasted input more
444 444 # than necessary. We do this by trimming out the auto-indent initial
445 445 # spaces, if the user's actual input started itself with whitespace.
446 446 if self.autoindent:
447 447 if num_ini_spaces(line) > self.indent_current_nsp:
448 448 line = line[self.indent_current_nsp:]
449 449 self.indent_current_nsp = 0
450 450
451 451 return line
452 452
453 453 #-------------------------------------------------------------------------
454 454 # Methods to support auto-editing of SyntaxErrors.
455 455 #-------------------------------------------------------------------------
456 456
457 457 def edit_syntax_error(self):
458 458 """The bottom half of the syntax error handler called in the main loop.
459 459
460 460 Loop until syntax error is fixed or user cancels.
461 461 """
462 462
463 463 while self.SyntaxTB.last_syntax_error:
464 464 # copy and clear last_syntax_error
465 465 err = self.SyntaxTB.clear_err_state()
466 466 if not self._should_recompile(err):
467 467 return
468 468 try:
469 469 # may set last_syntax_error again if a SyntaxError is raised
470 470 self.safe_execfile(err.filename,self.user_ns)
471 471 except:
472 472 self.showtraceback()
473 473 else:
474 474 try:
475 f = file(err.filename)
475 f = open(err.filename)
476 476 try:
477 477 # This should be inside a display_trap block and I
478 478 # think it is.
479 479 sys.displayhook(f.read())
480 480 finally:
481 481 f.close()
482 482 except:
483 483 self.showtraceback()
484 484
485 485 def _should_recompile(self,e):
486 486 """Utility routine for edit_syntax_error"""
487 487
488 488 if e.filename in ('<ipython console>','<input>','<string>',
489 489 '<console>','<BackgroundJob compilation>',
490 490 None):
491 491
492 492 return False
493 493 try:
494 494 if (self.autoedit_syntax and
495 495 not self.ask_yes_no('Return to editor to correct syntax error? '
496 496 '[Y/n] ','y')):
497 497 return False
498 498 except EOFError:
499 499 return False
500 500
501 501 def int0(x):
502 502 try:
503 503 return int(x)
504 504 except TypeError:
505 505 return 0
506 506 # always pass integer line and offset values to editor hook
507 507 try:
508 508 self.hooks.fix_error_editor(e.filename,
509 509 int0(e.lineno),int0(e.offset),e.msg)
510 510 except TryNext:
511 511 warn('Could not open editor')
512 512 return False
513 513 return True
514 514
515 515 #-------------------------------------------------------------------------
516 516 # Things related to exiting
517 517 #-------------------------------------------------------------------------
518 518
519 519 def ask_exit(self):
520 520 """ Ask the shell to exit. Can be overiden and used as a callback. """
521 521 self.exit_now = True
522 522
523 523 def exit(self):
524 524 """Handle interactive exit.
525 525
526 526 This method calls the ask_exit callback."""
527 527 if self.confirm_exit:
528 528 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
529 529 self.ask_exit()
530 530 else:
531 531 self.ask_exit()
532 532
533 533 #------------------------------------------------------------------------
534 534 # Magic overrides
535 535 #------------------------------------------------------------------------
536 536 # Once the base class stops inheriting from magic, this code needs to be
537 537 # moved into a separate machinery as well. For now, at least isolate here
538 538 # the magics which this class needs to implement differently from the base
539 539 # class, or that are unique to it.
540 540
541 541 def magic_autoindent(self, parameter_s = ''):
542 542 """Toggle autoindent on/off (if available)."""
543 543
544 544 self.shell.set_autoindent()
545 545 print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
546 546
547 547 @skip_doctest
548 548 def magic_cpaste(self, parameter_s=''):
549 549 """Paste & execute a pre-formatted code block from clipboard.
550 550
551 551 You must terminate the block with '--' (two minus-signs) or Ctrl-D
552 552 alone on the line. You can also provide your own sentinel with '%paste
553 553 -s %%' ('%%' is the new sentinel for this operation)
554 554
555 555 The block is dedented prior to execution to enable execution of method
556 556 definitions. '>' and '+' characters at the beginning of a line are
557 557 ignored, to allow pasting directly from e-mails, diff files and
558 558 doctests (the '...' continuation prompt is also stripped). The
559 559 executed block is also assigned to variable named 'pasted_block' for
560 560 later editing with '%edit pasted_block'.
561 561
562 562 You can also pass a variable name as an argument, e.g. '%cpaste foo'.
563 563 This assigns the pasted block to variable 'foo' as string, without
564 564 dedenting or executing it (preceding >>> and + is still stripped)
565 565
566 566 '%cpaste -r' re-executes the block previously entered by cpaste.
567 567
568 568 Do not be alarmed by garbled output on Windows (it's a readline bug).
569 569 Just press enter and type -- (and press enter again) and the block
570 570 will be what was just pasted.
571 571
572 572 IPython statements (magics, shell escapes) are not supported (yet).
573 573
574 574 See also
575 575 --------
576 576 paste: automatically pull code from clipboard.
577 577
578 578 Examples
579 579 --------
580 580 ::
581 581
582 582 In [8]: %cpaste
583 583 Pasting code; enter '--' alone on the line to stop.
584 584 :>>> a = ["world!", "Hello"]
585 585 :>>> print " ".join(sorted(a))
586 586 :--
587 587 Hello world!
588 588 """
589 589
590 590 opts, name = self.parse_options(parameter_s, 'rs:', mode='string')
591 591 if 'r' in opts:
592 592 rerun_pasted(self.shell)
593 593 return
594 594
595 595 sentinel = opts.get('s', '--')
596 596 block = strip_email_quotes(get_pasted_lines(sentinel))
597 597 store_or_execute(self.shell, block, name)
598 598
599 599 def magic_paste(self, parameter_s=''):
600 600 """Paste & execute a pre-formatted code block from clipboard.
601 601
602 602 The text is pulled directly from the clipboard without user
603 603 intervention and printed back on the screen before execution (unless
604 604 the -q flag is given to force quiet mode).
605 605
606 606 The block is dedented prior to execution to enable execution of method
607 607 definitions. '>' and '+' characters at the beginning of a line are
608 608 ignored, to allow pasting directly from e-mails, diff files and
609 609 doctests (the '...' continuation prompt is also stripped). The
610 610 executed block is also assigned to variable named 'pasted_block' for
611 611 later editing with '%edit pasted_block'.
612 612
613 613 You can also pass a variable name as an argument, e.g. '%paste foo'.
614 614 This assigns the pasted block to variable 'foo' as string, without
615 615 dedenting or executing it (preceding >>> and + is still stripped)
616 616
617 617 Options
618 618 -------
619 619
620 620 -r: re-executes the block previously entered by cpaste.
621 621
622 622 -q: quiet mode: do not echo the pasted text back to the terminal.
623 623
624 624 IPython statements (magics, shell escapes) are not supported (yet).
625 625
626 626 See also
627 627 --------
628 628 cpaste: manually paste code into terminal until you mark its end.
629 629 """
630 630 opts, name = self.parse_options(parameter_s, 'rq', mode='string')
631 631 if 'r' in opts:
632 632 rerun_pasted(self.shell)
633 633 return
634 634 try:
635 635 text = self.shell.hooks.clipboard_get()
636 636 block = strip_email_quotes(text.splitlines())
637 637 except TryNext as clipboard_exc:
638 638 message = getattr(clipboard_exc, 'args')
639 639 if message:
640 640 error(message[0])
641 641 else:
642 642 error('Could not get text from the clipboard.')
643 643 return
644 644
645 645 # By default, echo back to terminal unless quiet mode is requested
646 646 if 'q' not in opts:
647 647 write = self.shell.write
648 648 write(self.shell.pycolorize(block))
649 649 if not block.endswith('\n'):
650 650 write('\n')
651 651 write("## -- End pasted text --\n")
652 652
653 653 store_or_execute(self.shell, block, name)
654 654
655 655 # Class-level: add a '%cls' magic only on Windows
656 656 if sys.platform == 'win32':
657 657 def magic_cls(self, s):
658 658 """Clear screen.
659 659 """
660 660 os.system("cls")
661 661
662 662 def showindentationerror(self):
663 663 super(TerminalInteractiveShell, self).showindentationerror()
664 664 print("If you want to paste code into IPython, try the "
665 665 "%paste and %cpaste magic functions.")
666 666
667 667
668 668 InteractiveShellABC.register(TerminalInteractiveShell)
@@ -1,306 +1,306 b''
1 1 # -*- coding: utf-8 -*-
2 2 """
3 3 Class and program to colorize python source code for ANSI terminals.
4 4
5 5 Based on an HTML code highlighter by Jurgen Hermann found at:
6 6 http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52298
7 7
8 8 Modifications by Fernando Perez (fperez@colorado.edu).
9 9
10 10 Information on the original HTML highlighter follows:
11 11
12 12 MoinMoin - Python Source Parser
13 13
14 14 Title: Colorize Python source using the built-in tokenizer
15 15
16 16 Submitter: Jurgen Hermann
17 17 Last Updated:2001/04/06
18 18
19 19 Version no:1.2
20 20
21 21 Description:
22 22
23 23 This code is part of MoinMoin (http://moin.sourceforge.net/) and converts
24 24 Python source code to HTML markup, rendering comments, keywords,
25 25 operators, numeric and string literals in different colors.
26 26
27 27 It shows how to use the built-in keyword, token and tokenize modules to
28 28 scan Python source code and re-emit it with no changes to its original
29 29 formatting (which is the hard part).
30 30 """
31 31
32 32 __all__ = ['ANSICodeColors','Parser']
33 33
34 34 _scheme_default = 'Linux'
35 35
36 36 # Imports
37 37 import StringIO
38 38 import keyword
39 39 import os
40 40 import optparse
41 41 import sys
42 42 import token
43 43 import tokenize
44 44
45 45 try:
46 46 generate_tokens = tokenize.generate_tokens
47 47 except AttributeError:
48 48 # Python 3. Note that we use the undocumented _tokenize because it expects
49 49 # strings, not bytes. See also Python issue #9969.
50 50 generate_tokens = tokenize._tokenize
51 51
52 52 from IPython.utils.coloransi import *
53 53
54 54 #############################################################################
55 55 ### Python Source Parser (does Hilighting)
56 56 #############################################################################
57 57
58 58 _KEYWORD = token.NT_OFFSET + 1
59 59 _TEXT = token.NT_OFFSET + 2
60 60
61 61 #****************************************************************************
62 62 # Builtin color schemes
63 63
64 64 Colors = TermColors # just a shorthand
65 65
66 66 # Build a few color schemes
67 67 NoColor = ColorScheme(
68 68 'NoColor',{
69 69 token.NUMBER : Colors.NoColor,
70 70 token.OP : Colors.NoColor,
71 71 token.STRING : Colors.NoColor,
72 72 tokenize.COMMENT : Colors.NoColor,
73 73 token.NAME : Colors.NoColor,
74 74 token.ERRORTOKEN : Colors.NoColor,
75 75
76 76 _KEYWORD : Colors.NoColor,
77 77 _TEXT : Colors.NoColor,
78 78
79 79 'normal' : Colors.NoColor # color off (usu. Colors.Normal)
80 80 } )
81 81
82 82 LinuxColors = ColorScheme(
83 83 'Linux',{
84 84 token.NUMBER : Colors.LightCyan,
85 85 token.OP : Colors.Yellow,
86 86 token.STRING : Colors.LightBlue,
87 87 tokenize.COMMENT : Colors.LightRed,
88 88 token.NAME : Colors.Normal,
89 89 token.ERRORTOKEN : Colors.Red,
90 90
91 91 _KEYWORD : Colors.LightGreen,
92 92 _TEXT : Colors.Yellow,
93 93
94 94 'normal' : Colors.Normal # color off (usu. Colors.Normal)
95 95 } )
96 96
97 97 LightBGColors = ColorScheme(
98 98 'LightBG',{
99 99 token.NUMBER : Colors.Cyan,
100 100 token.OP : Colors.Blue,
101 101 token.STRING : Colors.Blue,
102 102 tokenize.COMMENT : Colors.Red,
103 103 token.NAME : Colors.Normal,
104 104 token.ERRORTOKEN : Colors.Red,
105 105
106 106 _KEYWORD : Colors.Green,
107 107 _TEXT : Colors.Blue,
108 108
109 109 'normal' : Colors.Normal # color off (usu. Colors.Normal)
110 110 } )
111 111
112 112 # Build table of color schemes (needed by the parser)
113 113 ANSICodeColors = ColorSchemeTable([NoColor,LinuxColors,LightBGColors],
114 114 _scheme_default)
115 115
116 116 class Parser:
117 117 """ Format colored Python source.
118 118 """
119 119
120 120 def __init__(self, color_table=None,out = sys.stdout):
121 121 """ Create a parser with a specified color table and output channel.
122 122
123 123 Call format() to process code.
124 124 """
125 125 self.color_table = color_table and color_table or ANSICodeColors
126 126 self.out = out
127 127
128 128 def format(self, raw, out = None, scheme = ''):
129 129 return self.format2(raw, out, scheme)[0]
130 130
131 131 def format2(self, raw, out = None, scheme = ''):
132 132 """ Parse and send the colored source.
133 133
134 134 If out and scheme are not specified, the defaults (given to
135 135 constructor) are used.
136 136
137 137 out should be a file-type object. Optionally, out can be given as the
138 138 string 'str' and the parser will automatically return the output in a
139 139 string."""
140 140
141 141 string_output = 0
142 142 if out == 'str' or self.out == 'str' or \
143 143 isinstance(self.out,StringIO.StringIO):
144 144 # XXX - I don't really like this state handling logic, but at this
145 145 # point I don't want to make major changes, so adding the
146 146 # isinstance() check is the simplest I can do to ensure correct
147 147 # behavior.
148 148 out_old = self.out
149 149 self.out = StringIO.StringIO()
150 150 string_output = 1
151 151 elif out is not None:
152 152 self.out = out
153 153
154 154 # Fast return of the unmodified input for NoColor scheme
155 155 if scheme == 'NoColor':
156 156 error = False
157 157 self.out.write(raw)
158 158 if string_output:
159 159 return raw,error
160 160 else:
161 161 return None,error
162 162
163 163 # local shorthands
164 164 colors = self.color_table[scheme].colors
165 165 self.colors = colors # put in object so __call__ sees it
166 166
167 167 # Remove trailing whitespace and normalize tabs
168 168 self.raw = raw.expandtabs().rstrip()
169 169
170 170 # store line offsets in self.lines
171 171 self.lines = [0, 0]
172 172 pos = 0
173 173 raw_find = self.raw.find
174 174 lines_append = self.lines.append
175 175 while 1:
176 176 pos = raw_find('\n', pos) + 1
177 177 if not pos: break
178 178 lines_append(pos)
179 179 lines_append(len(self.raw))
180 180
181 181 # parse the source and write it
182 182 self.pos = 0
183 183 text = StringIO.StringIO(self.raw)
184 184
185 185 error = False
186 186 try:
187 187 for atoken in generate_tokens(text.readline):
188 188 self(*atoken)
189 189 except tokenize.TokenError as ex:
190 190 msg = ex.args[0]
191 191 line = ex.args[1][0]
192 192 self.out.write("%s\n\n*** ERROR: %s%s%s\n" %
193 193 (colors[token.ERRORTOKEN],
194 194 msg, self.raw[self.lines[line]:],
195 195 colors.normal)
196 196 )
197 197 error = True
198 198 self.out.write(colors.normal+'\n')
199 199 if string_output:
200 200 output = self.out.getvalue()
201 201 self.out = out_old
202 202 return (output, error)
203 203 return (None, error)
204 204
205 205 def __call__(self, toktype, toktext, (srow,scol), (erow,ecol), line):
206 206 """ Token handler, with syntax highlighting."""
207 207
208 208 # local shorthands
209 209 colors = self.colors
210 210 owrite = self.out.write
211 211
212 212 # line separator, so this works across platforms
213 213 linesep = os.linesep
214 214
215 215 # calculate new positions
216 216 oldpos = self.pos
217 217 newpos = self.lines[srow] + scol
218 218 self.pos = newpos + len(toktext)
219 219
220 220 # send the original whitespace, if needed
221 221 if newpos > oldpos:
222 222 owrite(self.raw[oldpos:newpos])
223 223
224 224 # skip indenting tokens
225 225 if toktype in [token.INDENT, token.DEDENT]:
226 226 self.pos = newpos
227 227 return
228 228
229 229 # map token type to a color group
230 230 if token.LPAR <= toktype and toktype <= token.OP:
231 231 toktype = token.OP
232 232 elif toktype == token.NAME and keyword.iskeyword(toktext):
233 233 toktype = _KEYWORD
234 234 color = colors.get(toktype, colors[_TEXT])
235 235
236 236 #print '<%s>' % toktext, # dbg
237 237
238 238 # Triple quoted strings must be handled carefully so that backtracking
239 239 # in pagers works correctly. We need color terminators on _each_ line.
240 240 if linesep in toktext:
241 241 toktext = toktext.replace(linesep, '%s%s%s' %
242 242 (colors.normal,linesep,color))
243 243
244 244 # send text
245 245 owrite('%s%s%s' % (color,toktext,colors.normal))
246 246
247 247 def main(argv=None):
248 248 """Run as a command-line script: colorize a python file or stdin using ANSI
249 249 color escapes and print to stdout.
250 250
251 251 Inputs:
252 252
253 253 - argv(None): a list of strings like sys.argv[1:] giving the command-line
254 254 arguments. If None, use sys.argv[1:].
255 255 """
256 256
257 257 usage_msg = """%prog [options] [filename]
258 258
259 259 Colorize a python file or stdin using ANSI color escapes and print to stdout.
260 260 If no filename is given, or if filename is -, read standard input."""
261 261
262 262 parser = optparse.OptionParser(usage=usage_msg)
263 263 newopt = parser.add_option
264 264 newopt('-s','--scheme',metavar='NAME',dest='scheme_name',action='store',
265 265 choices=['Linux','LightBG','NoColor'],default=_scheme_default,
266 266 help="give the color scheme to use. Currently only 'Linux'\
267 267 (default) and 'LightBG' and 'NoColor' are implemented (give without\
268 268 quotes)")
269 269
270 270 opts,args = parser.parse_args(argv)
271 271
272 272 if len(args) > 1:
273 273 parser.error("you must give at most one filename.")
274 274
275 275 if len(args) == 0:
276 276 fname = '-' # no filename given; setup to read from stdin
277 277 else:
278 278 fname = args[0]
279 279
280 280 if fname == '-':
281 281 stream = sys.stdin
282 282 else:
283 283 try:
284 stream = file(fname)
284 stream = open(fname)
285 285 except IOError,msg:
286 286 print >> sys.stderr, msg
287 287 sys.exit(1)
288 288
289 289 parser = Parser()
290 290
291 291 # we need nested try blocks because pre-2.5 python doesn't support unified
292 292 # try-except-finally
293 293 try:
294 294 try:
295 295 # write colorized version to stdout
296 296 parser.format(stream.read(),scheme=opts.scheme_name)
297 297 except IOError,msg:
298 298 # if user reads through a pager and quits, don't print traceback
299 299 if msg.args != (32,'Broken pipe'):
300 300 raise
301 301 finally:
302 302 if stream is not sys.stdin:
303 303 stream.close() # in case a non-handled exception happened above
304 304
305 305 if __name__ == "__main__":
306 306 main()
@@ -1,306 +1,306 b''
1 1 """An Application for launching a kernel
2 2
3 3 Authors
4 4 -------
5 5 * MinRK
6 6 """
7 7 #-----------------------------------------------------------------------------
8 8 # Copyright (C) 2011 The IPython Development Team
9 9 #
10 10 # Distributed under the terms of the BSD License. The full license is in
11 11 # the file COPYING.txt, distributed as part of this software.
12 12 #-----------------------------------------------------------------------------
13 13
14 14 #-----------------------------------------------------------------------------
15 15 # Imports
16 16 #-----------------------------------------------------------------------------
17 17
18 18 # Standard library imports.
19 19 import json
20 20 import os
21 21 import sys
22 22
23 23 # System library imports.
24 24 import zmq
25 25
26 26 # IPython imports.
27 27 from IPython.core.ultratb import FormattedTB
28 28 from IPython.core.application import (
29 29 BaseIPythonApplication, base_flags, base_aliases, catch_config_error
30 30 )
31 31 from IPython.utils import io
32 32 from IPython.utils.localinterfaces import LOCALHOST
33 33 from IPython.utils.path import filefind
34 34 from IPython.utils.py3compat import str_to_bytes
35 35 from IPython.utils.traitlets import (Any, Instance, Dict, Unicode, Integer, Bool,
36 36 DottedObjectName)
37 37 from IPython.utils.importstring import import_item
38 38 # local imports
39 39 from IPython.zmq.entry_point import write_connection_file
40 40 from IPython.zmq.heartbeat import Heartbeat
41 41 from IPython.zmq.parentpoller import ParentPollerUnix, ParentPollerWindows
42 42 from IPython.zmq.session import (
43 43 Session, session_flags, session_aliases, default_secure,
44 44 )
45 45
46 46
47 47 #-----------------------------------------------------------------------------
48 48 # Flags and Aliases
49 49 #-----------------------------------------------------------------------------
50 50
51 51 kernel_aliases = dict(base_aliases)
52 52 kernel_aliases.update({
53 53 'ip' : 'KernelApp.ip',
54 54 'hb' : 'KernelApp.hb_port',
55 55 'shell' : 'KernelApp.shell_port',
56 56 'iopub' : 'KernelApp.iopub_port',
57 57 'stdin' : 'KernelApp.stdin_port',
58 58 'f' : 'KernelApp.connection_file',
59 59 'parent': 'KernelApp.parent',
60 60 })
61 61 if sys.platform.startswith('win'):
62 62 kernel_aliases['interrupt'] = 'KernelApp.interrupt'
63 63
64 64 kernel_flags = dict(base_flags)
65 65 kernel_flags.update({
66 66 'no-stdout' : (
67 67 {'KernelApp' : {'no_stdout' : True}},
68 68 "redirect stdout to the null device"),
69 69 'no-stderr' : (
70 70 {'KernelApp' : {'no_stderr' : True}},
71 71 "redirect stderr to the null device"),
72 72 })
73 73
74 74 # inherit flags&aliases for Sessions
75 75 kernel_aliases.update(session_aliases)
76 76 kernel_flags.update(session_flags)
77 77
78 78
79 79
80 80 #-----------------------------------------------------------------------------
81 81 # Application class for starting a Kernel
82 82 #-----------------------------------------------------------------------------
83 83
84 84 class KernelApp(BaseIPythonApplication):
85 85 name='pykernel'
86 86 aliases = Dict(kernel_aliases)
87 87 flags = Dict(kernel_flags)
88 88 classes = [Session]
89 89 # the kernel class, as an importstring
90 90 kernel_class = DottedObjectName('IPython.zmq.pykernel.Kernel')
91 91 kernel = Any()
92 92 poller = Any() # don't restrict this even though current pollers are all Threads
93 93 heartbeat = Instance(Heartbeat)
94 94 session = Instance('IPython.zmq.session.Session')
95 95 ports = Dict()
96 96
97 97 # inherit config file name from parent:
98 98 parent_appname = Unicode(config=True)
99 99 def _parent_appname_changed(self, name, old, new):
100 100 if self.config_file_specified:
101 101 # it was manually specified, ignore
102 102 return
103 103 self.config_file_name = new.replace('-','_') + u'_config.py'
104 104 # don't let this count as specifying the config file
105 105 self.config_file_specified = False
106 106
107 107 # connection info:
108 108 ip = Unicode(LOCALHOST, config=True,
109 109 help="Set the IP or interface on which the kernel will listen.")
110 110 hb_port = Integer(0, config=True, help="set the heartbeat port [default: random]")
111 111 shell_port = Integer(0, config=True, help="set the shell (XREP) port [default: random]")
112 112 iopub_port = Integer(0, config=True, help="set the iopub (PUB) port [default: random]")
113 113 stdin_port = Integer(0, config=True, help="set the stdin (XREQ) port [default: random]")
114 114 connection_file = Unicode('', config=True,
115 115 help="""JSON file in which to store connection info [default: kernel-<pid>.json]
116 116
117 117 This file will contain the IP, ports, and authentication key needed to connect
118 118 clients to this kernel. By default, this file will be created in the security-dir
119 119 of the current profile, but can be specified by absolute path.
120 120 """)
121 121
122 122 # streams, etc.
123 123 no_stdout = Bool(False, config=True, help="redirect stdout to the null device")
124 124 no_stderr = Bool(False, config=True, help="redirect stderr to the null device")
125 125 outstream_class = DottedObjectName('IPython.zmq.iostream.OutStream',
126 126 config=True, help="The importstring for the OutStream factory")
127 127 displayhook_class = DottedObjectName('IPython.zmq.displayhook.ZMQDisplayHook',
128 128 config=True, help="The importstring for the DisplayHook factory")
129 129
130 130 # polling
131 131 parent = Integer(0, config=True,
132 132 help="""kill this process if its parent dies. On Windows, the argument
133 133 specifies the HANDLE of the parent process, otherwise it is simply boolean.
134 134 """)
135 135 interrupt = Integer(0, config=True,
136 136 help="""ONLY USED ON WINDOWS
137 137 Interrupt this process when the parent is signalled.
138 138 """)
139 139
140 140 def init_crash_handler(self):
141 141 # Install minimal exception handling
142 142 sys.excepthook = FormattedTB(mode='Verbose', color_scheme='NoColor',
143 143 ostream=sys.__stdout__)
144 144
145 145 def init_poller(self):
146 146 if sys.platform == 'win32':
147 147 if self.interrupt or self.parent:
148 148 self.poller = ParentPollerWindows(self.interrupt, self.parent)
149 149 elif self.parent:
150 150 self.poller = ParentPollerUnix()
151 151
152 152 def _bind_socket(self, s, port):
153 153 iface = 'tcp://%s' % self.ip
154 154 if port <= 0:
155 155 port = s.bind_to_random_port(iface)
156 156 else:
157 157 s.bind(iface + ':%i'%port)
158 158 return port
159 159
160 160 def load_connection_file(self):
161 161 """load ip/port/hmac config from JSON connection file"""
162 162 try:
163 163 fname = filefind(self.connection_file, ['.', self.profile_dir.security_dir])
164 164 except IOError:
165 165 self.log.debug("Connection file not found: %s", self.connection_file)
166 166 return
167 167 self.log.debug(u"Loading connection file %s", fname)
168 168 with open(fname) as f:
169 169 s = f.read()
170 170 cfg = json.loads(s)
171 171 if self.ip == LOCALHOST and 'ip' in cfg:
172 172 # not overridden by config or cl_args
173 173 self.ip = cfg['ip']
174 174 for channel in ('hb', 'shell', 'iopub', 'stdin'):
175 175 name = channel + '_port'
176 176 if getattr(self, name) == 0 and name in cfg:
177 177 # not overridden by config or cl_args
178 178 setattr(self, name, cfg[name])
179 179 if 'key' in cfg:
180 180 self.config.Session.key = str_to_bytes(cfg['key'])
181 181
182 182 def write_connection_file(self):
183 183 """write connection info to JSON file"""
184 184 if os.path.basename(self.connection_file) == self.connection_file:
185 185 cf = os.path.join(self.profile_dir.security_dir, self.connection_file)
186 186 else:
187 187 cf = self.connection_file
188 188 write_connection_file(cf, ip=self.ip, key=self.session.key,
189 189 shell_port=self.shell_port, stdin_port=self.stdin_port, hb_port=self.hb_port,
190 190 iopub_port=self.iopub_port)
191 191
192 192 def init_connection_file(self):
193 193 if not self.connection_file:
194 194 self.connection_file = "kernel-%s.json"%os.getpid()
195 195 try:
196 196 self.load_connection_file()
197 197 except Exception:
198 198 self.log.error("Failed to load connection file: %r", self.connection_file, exc_info=True)
199 199 self.exit(1)
200 200
201 201 def init_sockets(self):
202 202 # Create a context, a session, and the kernel sockets.
203 203 self.log.info("Starting the kernel at pid: %i", os.getpid())
204 204 context = zmq.Context.instance()
205 205 # Uncomment this to try closing the context.
206 206 # atexit.register(context.term)
207 207
208 208 self.shell_socket = context.socket(zmq.ROUTER)
209 209 self.shell_port = self._bind_socket(self.shell_socket, self.shell_port)
210 210 self.log.debug("shell ROUTER Channel on port: %i"%self.shell_port)
211 211
212 212 self.iopub_socket = context.socket(zmq.PUB)
213 213 self.iopub_port = self._bind_socket(self.iopub_socket, self.iopub_port)
214 214 self.log.debug("iopub PUB Channel on port: %i"%self.iopub_port)
215 215
216 216 self.stdin_socket = context.socket(zmq.ROUTER)
217 217 self.stdin_port = self._bind_socket(self.stdin_socket, self.stdin_port)
218 218 self.log.debug("stdin ROUTER Channel on port: %i"%self.stdin_port)
219 219
220 220 # heartbeat doesn't share context, because it mustn't be blocked
221 221 # by the GIL, which is accessed by libzmq when freeing zero-copy messages
222 222 hb_ctx = zmq.Context()
223 223 self.heartbeat = Heartbeat(hb_ctx, (self.ip, self.hb_port))
224 224 self.hb_port = self.heartbeat.port
225 225 self.log.debug("Heartbeat REP Channel on port: %i"%self.hb_port)
226 226
227 227 # Helper to make it easier to connect to an existing kernel.
228 228 # set log-level to critical, to make sure it is output
229 229 self.log.critical("To connect another client to this kernel, use:")
230 230
231 231 basename = os.path.basename(self.connection_file)
232 232 if basename == self.connection_file or \
233 233 os.path.dirname(self.connection_file) == self.profile_dir.security_dir:
234 234 # use shortname
235 235 tail = basename
236 236 if self.profile != 'default':
237 237 tail += " --profile %s" % self.profile
238 238 else:
239 239 tail = self.connection_file
240 240 self.log.critical("--existing %s", tail)
241 241
242 242
243 243 self.ports = dict(shell=self.shell_port, iopub=self.iopub_port,
244 244 stdin=self.stdin_port, hb=self.hb_port)
245 245
246 246 def init_session(self):
247 247 """create our session object"""
248 248 default_secure(self.config)
249 249 self.session = Session(config=self.config, username=u'kernel')
250 250
251 251 def init_blackhole(self):
252 252 """redirects stdout/stderr to devnull if necessary"""
253 253 if self.no_stdout or self.no_stderr:
254 blackhole = file(os.devnull, 'w')
254 blackhole = open(os.devnull, 'w')
255 255 if self.no_stdout:
256 256 sys.stdout = sys.__stdout__ = blackhole
257 257 if self.no_stderr:
258 258 sys.stderr = sys.__stderr__ = blackhole
259 259
260 260 def init_io(self):
261 261 """Redirect input streams and set a display hook."""
262 262 if self.outstream_class:
263 263 outstream_factory = import_item(str(self.outstream_class))
264 264 sys.stdout = outstream_factory(self.session, self.iopub_socket, u'stdout')
265 265 sys.stderr = outstream_factory(self.session, self.iopub_socket, u'stderr')
266 266 if self.displayhook_class:
267 267 displayhook_factory = import_item(str(self.displayhook_class))
268 268 sys.displayhook = displayhook_factory(self.session, self.iopub_socket)
269 269
270 270 def init_kernel(self):
271 271 """Create the Kernel object itself"""
272 272 kernel_factory = import_item(str(self.kernel_class))
273 273 self.kernel = kernel_factory(config=self.config, session=self.session,
274 274 shell_socket=self.shell_socket,
275 275 iopub_socket=self.iopub_socket,
276 276 stdin_socket=self.stdin_socket,
277 277 log=self.log
278 278 )
279 279 self.kernel.record_ports(self.ports)
280 280
281 281 @catch_config_error
282 282 def initialize(self, argv=None):
283 283 super(KernelApp, self).initialize(argv)
284 284 self.init_blackhole()
285 285 self.init_connection_file()
286 286 self.init_session()
287 287 self.init_poller()
288 288 self.init_sockets()
289 289 # writing connection file must be *after* init_sockets
290 290 self.write_connection_file()
291 291 self.init_io()
292 292 self.init_kernel()
293 293 # flush stdout/stderr, so that anything written to these streams during
294 294 # initialization do not get associated with the first execution request
295 295 sys.stdout.flush()
296 296 sys.stderr.flush()
297 297
298 298 def start(self):
299 299 self.heartbeat.start()
300 300 if self.poller is not None:
301 301 self.poller.start()
302 302 try:
303 303 self.kernel.start()
304 304 except KeyboardInterrupt:
305 305 pass
306 306
General Comments 0
You need to be logged in to leave comments. Login now