Vega strike Python Modules doc: pydoc Namespace Reference

def pydoc.classname	(	object,
		modname
	)

Get a class name and qualify it with a module name if necessary.

Definition at line 78 of file pydoc.py.

 
 def classname(object, modname):
     """Get a class name and qualify it with a module name if necessary."""
     name = object.__name__
     if object.__module__ != modname:
         name = object.__module__ + '.' + name
     return name

def pydoc.cli ( )

Command-line interface (looks at sys.argv to decide what to do).

Definition at line 2030 of file pydoc.py.

References apropos(), doc(), getopt.getopt(), gui(), importfile(), ispath(), serve(), writedoc(), and writedocs().

 
 def cli():
     """Command-line interface (looks at sys.argv to decide what to do)."""
     import getopt
     class BadUsage: pass
 
     # Scripts don't get the current directory in their path by default.
     scriptdir = os.path.dirname(sys.argv[0])
     if scriptdir in sys.path:
         sys.path.remove(scriptdir)
     sys.path.insert(0, '.')
 
     try:
         opts, args = getopt.getopt(sys.argv[1:], 'gk:p:w')
         writing = 0
 
         for opt, val in opts:
             if opt == '-g':
                 gui()
                 return
             if opt == '-k':
                 apropos(val)
                 return
             if opt == '-p':
                 try:
                     port = int(val)
                 except ValueError:
                     raise BadUsage
                 def ready(server):
                     print 'pydoc server ready at %s' % server.url
                 def stopped():
                     print 'pydoc server stopped'
                 serve(port, ready, stopped)
                 return
             if opt == '-w':
                 writing = 1
 
         if not args: raise BadUsage
         for arg in args:
             try:
                 if ispath(arg) and os.path.isfile(arg):
                     arg = importfile(arg)
                 if writing:
                     if ispath(arg) and os.path.isdir(arg):
                         writedocs(arg)
                     else:
                         writedoc(arg)
                 else:
                     doc(arg)
             except ErrorDuringImport, value:
                 print value
 
     except (getopt.error, BadUsage):
         cmd = sys.argv[0]
         print """pydoc - the Python documentation tool
 
 %s <name> ...
     Show text documentation on something.  <name> may be the name of a
     function, module, or package, or a dotted reference to a class or
     function within a module or module in a package.  If <name> contains
     a '%s', it is used as the path to a Python source file to document.
 
 %s -k <keyword>
     Search for a keyword in the synopsis lines of all available modules.
 
 %s -p <port>
     Start an HTTP server on the given port on the local machine.
 
 %s -g
     Pop up a graphical interface for finding and serving documentation.
 
 %s -w <name> ...
     Write out the HTML documentation for a module to a file in the current
     directory.  If <name> contains a '%s', it is treated as a filename; if
     it names a directory, documentation is written for all the contents.
 """ % (cmd, os.sep, cmd, cmd, cmd, cmd, os.sep)

def pydoc.cram	(	text,
		maxlen
	)

Omit part of a string if needed to make it fit in a maximum length.

Definition at line 98 of file pydoc.py.

References sre_parse.max.

 
 def cram(text, maxlen):
     """Omit part of a string if needed to make it fit in a maximum length."""
     if len(text) > maxlen:
         pre = max(0, (maxlen-3)/2)
         post = max(0, maxlen-3-pre)
         return text[:pre] + '...' + text[len(text)-post:]
     return text

def pydoc.describe ( thing)

Produce a short description of the given thing.

Definition at line 1275 of file pydoc.py.

References inspect.isbuiltin(), inspect.isclass(), inspect.isfunction(), inspect.ismethod(), and inspect.ismodule().

 
 def describe(thing):
     """Produce a short description of the given thing."""
     if inspect.ismodule(thing):
         if thing.__name__ in sys.builtin_module_names:
             return 'built-in module ' + thing.__name__
         if hasattr(thing, '__path__'):
             return 'package ' + thing.__name__
         else:
             return 'module ' + thing.__name__
     if inspect.isbuiltin(thing):
         return 'built-in function ' + thing.__name__
     if inspect.isclass(thing):
         return 'class ' + thing.__name__
     if inspect.isfunction(thing):
         return 'function ' + thing.__name__
     if inspect.ismethod(thing):
         return 'method ' + thing.__name__
     if type(thing) is types.InstanceType:
         return 'instance of ' + thing.__class__.__name__
     return type(thing).__name__

def pydoc.doc	(	thing,
		title = `'Python Library Documentation: %s'`,
		forceload = `0`
	)

Display text documentation, given an object or a path to an object.

Definition at line 1320 of file pydoc.py.

References describe(), inspect.getmodule(), dospath.join(), locate(), pager(), and dospath.split().

 
 def doc(thing, title='Python Library Documentation: %s', forceload=0):
     """Display text documentation, given an object or a path to an object."""
     suffix, name = '', None
     if type(thing) is type(''):
         try:
             object = locate(thing, forceload)
         except ErrorDuringImport, value:
             print value
             return
         if not object:
             print 'no Python documentation found for %s' % repr(thing)
             return
         parts = split(thing, '.')
         if len(parts) > 1: suffix = ' in ' + join(parts[:-1], '.')
         name = parts[-1]
         thing = object
 
     desc = describe(thing)
     module = inspect.getmodule(thing)
     if not suffix and module and module is not thing:
         suffix = ' in module ' + module.__name__
     pager(title % (desc + suffix) + '\n\n' + text.document(thing, name))

def pydoc.getdoc ( object)

Get the doc string or comments for an object.

Definition at line 64 of file pydoc.py.

References inspect.getcomments(), inspect.getdoc(), and string.rstrip().

 
 def getdoc(object):
     """Get the doc string or comments for an object."""
     result = inspect.getdoc(object) or inspect.getcomments(object)
     return result and re.sub('^ *\n', '', rstrip(result)) or ''

def pydoc.getpager ( )

Decide what method to use for paging through text.

Definition at line 1177 of file pydoc.py.

References aifc.close(), tempfile.mktemp(), aifc.open(), pipepager(), plain(), and tempfilepager().

 
 def getpager():
     """Decide what method to use for paging through text."""
     if type(sys.stdout) is not types.FileType:
         return plainpager
     if not sys.stdin.isatty() or not sys.stdout.isatty():
         return plainpager
     if os.environ.get('TERM') in ['dumb', 'emacs']:
         return plainpager
     if os.environ.has_key('PAGER'):
         if sys.platform == 'win32': # pipes completely broken in Windows
             return lambda text: tempfilepager(plain(text), os.environ['PAGER'])
         elif os.environ.get('TERM') in ['dumb', 'emacs']:
             return lambda text: pipepager(plain(text), os.environ['PAGER'])
         else:
             return lambda text: pipepager(text, os.environ['PAGER'])
     if sys.platform == 'win32':
         return lambda text: tempfilepager(plain(text), 'more <')
     if hasattr(os, 'system') and os.system('less 2>/dev/null') == 0:
         return lambda text: pipepager(text, 'less')
 
     import tempfile
     filename = tempfile.mktemp()
     open(filename, 'w').close()
     try:
         if hasattr(os, 'system') and os.system('more %s' % filename) == 0:
             return lambda text: pipepager(text, 'more')
         else:
             return ttypager
     finally:
         os.unlink(filename)

def pydoc.gui ( )

Graphical interface (starts web server and pops up a control window).

Definition at line 1849 of file pydoc.py.

References audiodev.__init__().

 
 def gui():
     """Graphical interface (starts web server and pops up a control window)."""
     class GUI:
         def __init__(self, window, port=7464):
             self.window = window
             self.server = None
             self.scanner = None
 
             import Tkinter
             self.server_frm = Tkinter.Frame(window)
             self.title_lbl = Tkinter.Label(self.server_frm,
                 text='Starting server...\n ')
             self.open_btn = Tkinter.Button(self.server_frm,
                 text='open browser', command=self.open, state='disabled')
             self.quit_btn = Tkinter.Button(self.server_frm,
                 text='quit serving', command=self.quit, state='disabled')
 
             self.search_frm = Tkinter.Frame(window)
             self.search_lbl = Tkinter.Label(self.search_frm, text='Search for')
             self.search_ent = Tkinter.Entry(self.search_frm)
             self.search_ent.bind('<Return>', self.search)
             self.stop_btn = Tkinter.Button(self.search_frm,
                 text='stop', pady=0, command=self.stop, state='disabled')
             if sys.platform == 'win32':
                 # Trying to hide and show this button crashes under Windows.
                 self.stop_btn.pack(side='right')
 
             self.window.title('pydoc')
             self.window.protocol('WM_DELETE_WINDOW', self.quit)
             self.title_lbl.pack(side='top', fill='x')
             self.open_btn.pack(side='left', fill='x', expand=1)
             self.quit_btn.pack(side='right', fill='x', expand=1)
             self.server_frm.pack(side='top', fill='x')
 
             self.search_lbl.pack(side='left')
             self.search_ent.pack(side='right', fill='x', expand=1)
             self.search_frm.pack(side='top', fill='x')
             self.search_ent.focus_set()
 
             font = ('helvetica', sys.platform == 'win32' and 8 or 10)
             self.result_lst = Tkinter.Listbox(window, font=font, height=6)
             self.result_lst.bind('<Button-1>', self.select)
             self.result_lst.bind('<Double-Button-1>', self.goto)
             self.result_scr = Tkinter.Scrollbar(window,
                 orient='vertical', command=self.result_lst.yview)
             self.result_lst.config(yscrollcommand=self.result_scr.set)
 
             self.result_frm = Tkinter.Frame(window)
             self.goto_btn = Tkinter.Button(self.result_frm,
                 text='go to selected', command=self.goto)
             self.hide_btn = Tkinter.Button(self.result_frm,
                 text='hide results', command=self.hide)
             self.goto_btn.pack(side='left', fill='x', expand=1)
             self.hide_btn.pack(side='right', fill='x', expand=1)
 
             self.window.update()
             self.minwidth = self.window.winfo_width()
             self.minheight = self.window.winfo_height()
             self.bigminheight = (self.server_frm.winfo_reqheight() +
                                  self.search_frm.winfo_reqheight() +
                                  self.result_lst.winfo_reqheight() +
                                  self.result_frm.winfo_reqheight())
             self.bigwidth, self.bigheight = self.minwidth, self.bigminheight
             self.expanded = 0
             self.window.wm_geometry('%dx%d' % (self.minwidth, self.minheight))
             self.window.wm_minsize(self.minwidth, self.minheight)
 
             import threading
             threading.Thread(
                 target=serve, args=(port, self.ready, self.quit)).start()
 
         def ready(self, server):
             self.server = server
             self.title_lbl.config(
                 text='Python documentation server at\n' + server.url)
             self.open_btn.config(state='normal')
             self.quit_btn.config(state='normal')
 
         def open(self, event=None, url=None):
             url = url or self.server.url
             try:
                 import webbrowser
                 webbrowser.open(url)
             except ImportError: # pre-webbrowser.py compatibility
                 if sys.platform == 'win32':
                     os.system('start "%s"' % url)
                 elif sys.platform == 'mac':
                     try: import ic
                     except ImportError: pass
                     else: ic.launchurl(url)
                 else:
                     rc = os.system('netscape -remote "openURL(%s)" &' % url)
                     if rc: os.system('netscape "%s" &' % url)
 
         def quit(self, event=None):
             if self.server:
                 self.server.quit = 1
             self.window.quit()
 
         def search(self, event=None):
             key = self.search_ent.get()
             self.stop_btn.pack(side='right')
             self.stop_btn.config(state='normal')
             self.search_lbl.config(text='Searching for "%s"...' % key)
             self.search_ent.forget()
             self.search_lbl.pack(side='left')
             self.result_lst.delete(0, 'end')
             self.goto_btn.config(state='disabled')
             self.expand()
 
             import threading
             if self.scanner:
                 self.scanner.quit = 1
             self.scanner = ModuleScanner()
             threading.Thread(target=self.scanner.run,
                              args=(self.update, key, self.done)).start()
 
         def update(self, path, modname, desc):
             if modname[-9:] == '.__init__':
                 modname = modname[:-9] + ' (package)'
             self.result_lst.insert('end',
                 modname + ' - ' + (desc or '(no description)'))
 
         def stop(self, event=None):
             if self.scanner:
                 self.scanner.quit = 1
                 self.scanner = None
 
         def done(self):
             self.scanner = None
             self.search_lbl.config(text='Search for')
             self.search_lbl.pack(side='left')
             self.search_ent.pack(side='right', fill='x', expand=1)
             if sys.platform != 'win32': self.stop_btn.forget()
             self.stop_btn.config(state='disabled')
 
         def select(self, event=None):
             self.goto_btn.config(state='normal')
 
         def goto(self, event=None):
             selection = self.result_lst.curselection()
             if selection:
                 modname = split(self.result_lst.get(selection[0]))[0]
                 self.open(url=self.server.url + modname + '.html')
 
         def collapse(self):
             if not self.expanded: return
             self.result_frm.forget()
             self.result_scr.forget()
             self.result_lst.forget()
             self.bigwidth = self.window.winfo_width()
             self.bigheight = self.window.winfo_height()
             self.window.wm_geometry('%dx%d' % (self.minwidth, self.minheight))
             self.window.wm_minsize(self.minwidth, self.minheight)
             self.expanded = 0
 
         def expand(self):
             if self.expanded: return
             self.result_frm.pack(side='bottom', fill='x')
             self.result_scr.pack(side='right', fill='y')
             self.result_lst.pack(side='top', fill='both', expand=1)
             self.window.wm_geometry('%dx%d' % (self.bigwidth, self.bigheight))
             self.window.wm_minsize(self.minwidth, self.bigminheight)
             self.expanded = 1
 
         def hide(self, event=None):
             self.stop()
             self.collapse()
 
     import Tkinter
     try:
         gui = GUI(Tkinter.Tk())
         Tkinter.mainloop()
     except KeyboardInterrupt:
         pass
 
 # -------------------------------------------------- command-line interface

def pydoc.importfile ( path)

Import a Python source file or compiled file given its path.

Definition at line 198 of file pydoc.py.

References aifc.open().

 
 def importfile(path):
     """Import a Python source file or compiled file given its path."""
     magic = imp.get_magic()
     file = open(path, 'r')
     if file.read(len(magic)) == magic:
         kind = imp.PY_COMPILED
     else:
         kind = imp.PY_SOURCE
     file.close()
     filename = os.path.basename(path)
     name, ext = os.path.splitext(filename)
     file = open(path, 'r')
     try:
         module = imp.load_module(name, file, path, (ext, 'r', kind))
     except:
         raise ErrorDuringImport(path, sys.exc_info())
     file.close()
     return module

def pydoc.isdata ( object)

Check if an object is of a type that probably means it's data.

Definition at line 85 of file pydoc.py.

References inspect.isclass(), inspect.iscode(), inspect.isframe(), inspect.ismodule(), inspect.isroutine(), and inspect.istraceback().

 
 def isdata(object):
     """Check if an object is of a type that probably means it's data."""
     return not (inspect.ismodule(object) or inspect.isclass(object) or
                 inspect.isroutine(object) or inspect.isframe(object) or
                 inspect.istraceback(object) or inspect.iscode(object))

def pydoc.ispackage ( path)

Guess whether a path refers to a package directory.

Definition at line 146 of file pydoc.py.

 
 def ispackage(path):
     """Guess whether a path refers to a package directory."""
     if os.path.isdir(path):
         for ext in ['.py', '.pyc', '.pyo']:
             if os.path.isfile(os.path.join(path, '__init__' + ext)):
                 return 1

def pydoc.ispath ( x)

Definition at line 2027 of file pydoc.py.

References gettext.find().

 
 def ispath(x):
     return type(x) is types.StringType and find(x, os.sep) >= 0

def pydoc.locate	(	path,
		forceload = `0`
	)

Locate an object by name or dotted path, importing as necessary.

Definition at line 1296 of file pydoc.py.

References dospath.join(), safeimport(), and dospath.split().

 
 def locate(path, forceload=0):
     """Locate an object by name or dotted path, importing as necessary."""
     parts = split(path, '.')
     module, n = None, 0
     while n < len(parts):
         nextmodule = safeimport(join(parts[:n+1], '.'), forceload)
         if nextmodule: module, n = nextmodule, n + 1
         else: break
     if module:
         object = module
         for part in parts[n:]:
             try: object = getattr(object, part)
             except AttributeError: return None
         return object
     else:
         import __builtin__
         if hasattr(__builtin__, path):
             return getattr(__builtin__, path)
 
 # --------------------------------------- interactive interpreter interface

def pydoc.pager ( text)

The first time this is called, determine what kind of pager to use.

Definition at line 1171 of file pydoc.py.

References getpager().

 
 def pager(text):
     """The first time this is called, determine what kind of pager to use."""
     global pager
     pager = getpager()
     pager(text)

def pydoc.pathdirs ( )

Convert sys.path into a list of absolute, existing, unique paths.

Definition at line 52 of file pydoc.py.

 
 def pathdirs():
     """Convert sys.path into a list of absolute, existing, unique paths."""
     dirs = []
     normdirs = []
     for dir in sys.path:
         dir = os.path.abspath(dir or '.')
         normdir = os.path.normcase(dir)
         if normdir not in normdirs and os.path.isdir(dir):
             dirs.append(dir)
             normdirs.append(normdir)
     return dirs

def pydoc.pipepager	(	text,
		cmd
	)

Page through text by feeding it to another program.

Definition at line 1212 of file pydoc.py.

 
 def pipepager(text, cmd):
     """Page through text by feeding it to another program."""
     pipe = os.popen(cmd, 'w')
     try:
         pipe.write(text)
         pipe.close()
     except IOError:
         pass # Ignore broken pipes caused by quitting the pager program.

def pydoc.plain ( text)

Remove boldface formatting from text.

Definition at line 1208 of file pydoc.py.

 
 def plain(text):
     """Remove boldface formatting from text."""
     return re.sub('.\b', '', text)

def pydoc.plainpager ( text)

Simply print unformatted text.  This is the ultimate fallback.

Definition at line 1271 of file pydoc.py.

References plain().

 
 def plainpager(text):
     """Simply print unformatted text.  This is the ultimate fallback."""
     sys.stdout.write(plain(text))

def pydoc.replace	(	text,
		pairs
	)

Do a series of global replacements on a string.

Definition at line 91 of file pydoc.py.

References dospath.join(), and dospath.split().

 
 def replace(text, *pairs):
     """Do a series of global replacements on a string."""
     while pairs:
         text = join(split(text, pairs[0]), pairs[1])
         pairs = pairs[2:]
     return text

def pydoc.safeimport	(	path,
		forceload = `0`,
		cache = `{}`
	)

Import a module; handle errors; return None if the module isn't found.

If the module *is* found but an exception occurs, it's wrapped in an
ErrorDuringImport exception and reraised.  Unlike __import__, if a
package path is specified, the module at the end of the path is returned,
not the package at the beginning.  If the optional 'forceload' argument
is 1, we reload the module from disk (unless it's a dynamic extension).

Definition at line 217 of file pydoc.py.

References inspect.getmoduleinfo(), string.lower(), dospath.split(), and locale.str().

 
 def safeimport(path, forceload=0, cache={}):
     """Import a module; handle errors; return None if the module isn't found.
 
     If the module *is* found but an exception occurs, it's wrapped in an
     ErrorDuringImport exception and reraised.  Unlike __import__, if a
     package path is specified, the module at the end of the path is returned,
     not the package at the beginning.  If the optional 'forceload' argument
     is 1, we reload the module from disk (unless it's a dynamic extension)."""
     if forceload and sys.modules.has_key(path):
         # This is the only way to be sure.  Checking the mtime of the file
         # isn't good enough (e.g. what if the module contains a class that
         # inherits from another module that has changed?).
         if path not in sys.builtin_module_names:
             # Python never loads a dynamic extension a second time from the
             # same path, even if the file is changed or missing.  Deleting
             # the entry in sys.modules doesn't help for dynamic extensions,
             # so we're not even going to try to keep them up to date.
             info = inspect.getmoduleinfo(sys.modules[path].__file__)
             if info[3] != imp.C_EXTENSION:
                 cache[path] = sys.modules[path] # prevent module from clearing
                 del sys.modules[path]
     try:
         module = __import__(path)
     except:
         # Did the error occur before or after the module was found?
         (exc, value, tb) = info = sys.exc_info()
         if sys.modules.has_key(path):
             # An error occured while executing the imported module.
             raise ErrorDuringImport(sys.modules[path].__file__, info)
         elif exc is SyntaxError:
             # A SyntaxError occurred before we could execute the module.
             raise ErrorDuringImport(value.filename, info)
         elif exc is ImportError and \
              split(lower(str(value)))[:2] == ['no', 'module']:
             # The module was not found.
             return None
         else:
             # Some other error occurred during the importing process.
             raise ErrorDuringImport(path, sys.exc_info())
     for part in split(path, '.')[1:]:
         try: module = getattr(module, part)
         except AttributeError: return None
     return module
 
 # ---------------------------------------------------- formatter base class

def pydoc.serve	(	port,
		callback = `None`,
		completer = `None`
	)

Definition at line 1758 of file pydoc.py.

References audiodev.__init__().

 
 def serve(port, callback=None, completer=None):
     import BaseHTTPServer, mimetools, select
 
     # Patch up mimetools.Message so it doesn't break if rfc822 is reloaded.
     class Message(mimetools.Message):
         def __init__(self, fp, seekable=1):
             Message = self.__class__
             Message.__bases__[0].__bases__[0].__init__(self, fp, seekable)
             self.encodingheader = self.getheader('content-transfer-encoding')
             self.typeheader = self.getheader('content-type')
             self.parsetype()
             self.parseplist()
 
     class DocHandler(BaseHTTPServer.BaseHTTPRequestHandler):
         def send_document(self, title, contents):
             try:
                 self.send_response(200)
                 self.send_header('Content-Type', 'text/html')
                 self.end_headers()
                 self.wfile.write(html.page(title, contents))
             except IOError: pass
 
         def do_GET(self):
             path = self.path
             if path[-5:] == '.html': path = path[:-5]
             if path[:1] == '/': path = path[1:]
             if path and path != '.':
                 try:
                     obj = locate(path, forceload=1)
                 except ErrorDuringImport, value:
                     self.send_document(path, html.escape(str(value)))
                     return
                 if obj:
                     self.send_document(describe(obj), html.document(obj, path))
                 else:
                     self.send_document(path,
 'no Python documentation found for %s' % repr(path))
             else:
                 heading = html.heading(
 '<big><big><strong>Python: Index of Modules</strong></big></big>',
 '#ffffff', '#7799ee')
                 def bltinlink(name):
                     return '<a href="%s.html">%s</a>' % (name, name)
                 names = filter(lambda x: x != '__main__',
                                sys.builtin_module_names)
                 contents = html.multicolumn(names, bltinlink)
                 indices = ['<p>' + html.bigsection(
                     'Built-in Modules', '#ffffff', '#ee77aa', contents)]
 
                 seen = {}
                 for dir in pathdirs():
                     indices.append(html.index(dir, seen))
                 contents = heading + join(indices) + '''<p align=right>
 <font color="#909090" face="helvetica, arial"><strong>
 pydoc</strong> by Ka-Ping Yee &lt;ping@lfw.org&gt;</font>'''
                 self.send_document('Index of Modules', contents)
 
         def log_message(self, *args): pass
 
     class DocServer(BaseHTTPServer.HTTPServer):
         def __init__(self, port, callback):
             host = (sys.platform == 'mac') and '127.0.0.1' or 'localhost'
             self.address = ('', port)
             self.url = 'http://%s:%d/' % (host, port)
             self.callback = callback
             self.base.__init__(self, self.address, self.handler)
 
         def serve_until_quit(self):
             import select
             self.quit = 0
             while not self.quit:
                 rd, wr, ex = select.select([self.socket.fileno()], [], [], 1)
                 if rd: self.handle_request()
 
         def server_activate(self):
             self.base.server_activate(self)
             if self.callback: self.callback(self)
 
     DocServer.base = BaseHTTPServer.HTTPServer
     DocServer.handler = DocHandler
     DocHandler.MessageClass = Message
     try:
         try:
             DocServer(port, callback).serve_until_quit()
         except (KeyboardInterrupt, select.error):
             pass
     finally:
         if completer: completer()
 
 # ----------------------------------------------------- graphical interface

def pydoc.splitdoc ( doc)

Split a doc string into a synopsis line (if any) and the rest.

Definition at line 69 of file pydoc.py.

References dospath.join(), string.rstrip(), dospath.split(), and string.strip().

 
 def splitdoc(doc):
     """Split a doc string into a synopsis line (if any) and the rest."""
     lines = split(strip(doc), '\n')
     if len(lines) == 1:
         return lines[0], ''
     elif len(lines) >= 2 and not rstrip(lines[1]):
         return lines[0], join(lines[2:], '\n')
     return '', join(lines, '\n')

def pydoc.stripid ( text)

Remove the hexadecimal id from a Python object representation.

Definition at line 106 of file pydoc.py.

References inspect.ismethod(), and inspect.ismethoddescriptor().

 
 def stripid(text):
     """Remove the hexadecimal id from a Python object representation."""
     # The behaviour of %p is implementation-dependent; we check two cases.
     for pattern in [' at 0x[0-9a-f]{6,}>$', ' at [0-9A-F]{8,}>$']:
         if re.search(pattern, repr(Exception)):
             return re.sub(pattern, '>', text)
     return text

def pydoc.synopsis	(	filename,
		cache = `{}`
	)

Get the one-line summary out of a module file.

Definition at line 153 of file pydoc.py.

References inspect.getmoduleinfo(), aifc.open(), dospath.split(), and string.strip().

 
 def synopsis(filename, cache={}):
     """Get the one-line summary out of a module file."""
     mtime = os.stat(filename)[stat.ST_MTIME]
     lastupdate, result = cache.get(filename, (0, None))
     if lastupdate < mtime:
         info = inspect.getmoduleinfo(filename)
         file = open(filename)
         if info and 'b' in info[2]: # binary modules have to be imported
             try: module = imp.load_module('__temp__', file, filename, info[1:])
             except: return None
             result = split(module.__doc__ or '', '\n')[0]
             del sys.modules['__temp__']
         else: # text modules can be directly examined
             line = file.readline()
             while line[:1] == '#' or not strip(line):
                 line = file.readline()
                 if not line: break
             line = strip(line)
             if line[:4] == 'r"""': line = line[1:]
             if line[:3] == '"""':
                 line = line[3:]
                 if line[-1:] == '\\': line = line[:-1]
                 while not strip(line):
                     line = file.readline()
                     if not line: break
                 result = strip(split(line, '"""')[0])
             else: result = None
         file.close()
         cache[filename] = (mtime, result)
     return result

def pydoc.tempfilepager	(	text,
		cmd
	)

Page through text by invoking a program on a temporary file.

Definition at line 1221 of file pydoc.py.

References tempfile.mktemp(), and aifc.open().

 
 def tempfilepager(text, cmd):
     """Page through text by invoking a program on a temporary file."""
     import tempfile
     filename = tempfile.mktemp()
     file = open(filename, 'w')
     file.write(text)
     file.close()
     try:
         os.system(cmd + ' ' + filename)
     finally:
         os.unlink(filename)

def pydoc.ttypager ( text)

Page through text on a text terminal.

Definition at line 1233 of file pydoc.py.

References dospath.join(), plain(), tty.setcbreak(), and dospath.split().

 
 def ttypager(text):
     """Page through text on a text terminal."""
     lines = split(plain(text), '\n')
     try:
         import tty
         fd = sys.stdin.fileno()
         old = tty.tcgetattr(fd)
         tty.setcbreak(fd)
         getchar = lambda: sys.stdin.read(1)
     except (ImportError, AttributeError):
         tty = None
         getchar = lambda: sys.stdin.readline()[:-1][:1]
 
     try:
         r = inc = os.environ.get('LINES', 25) - 1
         sys.stdout.write(join(lines[:inc], '\n') + '\n')
         while lines[r:]:
             sys.stdout.write('-- more --')
             sys.stdout.flush()
             c = getchar()
 
             if c in ['q', 'Q']:
                 sys.stdout.write('\r          \r')
                 break
             elif c in ['\r', '\n']:
                 sys.stdout.write('\r          \r' + lines[r] + '\n')
                 r = r + 1
                 continue
             if c in ['b', 'B', '\x1b']:
                 r = r - inc - inc
                 if r < 0: r = 0
             sys.stdout.write('\n' + join(lines[r:r+inc], '\n') + '\n')
             r = r + inc
 
     finally:
         if tty:
             tty.tcsetattr(fd, tty.TCSAFLUSH, old)

def pydoc.writedoc	(	key,
		forceload = `0`
	)

Write HTML documentation to a file in the current directory.

Definition at line 1343 of file pydoc.py.

References describe(), locate(), and aifc.open().

 
 def writedoc(key, forceload=0):
     """Write HTML documentation to a file in the current directory."""
     try:
         object = locate(key, forceload)
     except ErrorDuringImport, value:
         print value
     else:
         if object:
             page = html.page(describe(object),
                              html.document(object, object.__name__))
             file = open(key + '.html', 'w')
             file.write(page)
             file.close()
             print 'wrote', key + '.html'
         else:
             print 'no Python documentation found for %s' % repr(key)

def pydoc.writedocs	(	dir,
		pkgpath = `''`,
		done = `None`
	)

Write out HTML documentation for all modules in a directory tree.

Definition at line 1360 of file pydoc.py.

References inspect.getmodulename(), ispackage(), and writedoc().

 
 def writedocs(dir, pkgpath='', done=None):
     """Write out HTML documentation for all modules in a directory tree."""
     if done is None: done = {}
     for file in os.listdir(dir):
         path = os.path.join(dir, file)
         if ispackage(path):
             writedocs(path, pkgpath + file + '.', done)
         elif os.path.isfile(path):
             modname = inspect.getmodulename(path)
             if modname:
                 modname = pkgpath + modname
                 if not done.has_key(modname):
                     done[modname] = 1
                     writedoc(modname)

string __author__ = "Ka-Ping Yee <ping@lfw.org>"

Definition at line 28 of file pydoc.py.

string __credits__

Initial value:

 = """Guido van Rossum, for an excellent programming language.
 Tommy Burnette, the original creator of manpy.
 Paul Prescod, for all his work on onlinehelp.
 Richard Chamberlain, for the first implementation of textdoc.
 
 Mynd you, m��se bites Kan be pretty nasti..."""

Definition at line 31 of file pydoc.py.

string __date__ = "26 February 2001"

Definition at line 29 of file pydoc.py.

string __version__ = "$Revision: 5816 $"

Definition at line 30 of file pydoc.py.

address

Definition at line 1820 of file pydoc.py.

bigheight

Definition at line 1911 of file pydoc.py.

bigminheight

Definition at line 1907 of file pydoc.py.

bigwidth

Definition at line 1999 of file pydoc.py.

callback

Definition at line 1822 of file pydoc.py.

encodingheader

Definition at line 1766 of file pydoc.py.

expanded

Definition at line 1912 of file pydoc.py.

goto_btn

Definition at line 1897 of file pydoc.py.

tuple help = Helper(sys.stdin, sys.stdout)

Definition at line 1664 of file pydoc.py.

hide_btn

Definition at line 1899 of file pydoc.py.

tuple html = HTMLDoc()

Definition at line 1318 of file pydoc.py.

minheight

Definition at line 1906 of file pydoc.py.

minwidth

Definition at line 1905 of file pydoc.py.

open_btn

Definition at line 1861 of file pydoc.py.

quit

Definition at line 1827 of file pydoc.py.

quit_btn

Definition at line 1863 of file pydoc.py.

result_frm

Definition at line 1896 of file pydoc.py.

result_lst

Definition at line 1889 of file pydoc.py.

result_scr

Definition at line 1892 of file pydoc.py.

scanner

Definition at line 1855 of file pydoc.py.

search_ent

Definition at line 1868 of file pydoc.py.

search_frm

Definition at line 1866 of file pydoc.py.

search_lbl

Definition at line 1867 of file pydoc.py.

server

Definition at line 1854 of file pydoc.py.

server_frm

Definition at line 1858 of file pydoc.py.

stop_btn

Definition at line 1870 of file pydoc.py.

tuple text = TextDoc()

Definition at line 1317 of file pydoc.py.

title_lbl

Definition at line 1859 of file pydoc.py.

typeheader

Definition at line 1767 of file pydoc.py.

url

Definition at line 1821 of file pydoc.py.

window

Definition at line 1853 of file pydoc.py.

Data Structures

Functions

Variables

Function Documentation

Variable Documentation

Data Structures
class	ErrorDuringImport

class	Doc

class	HTMLRepr

class	HTMLDoc

class	TextRepr

class	TextDoc

class	Helper

class	Scanner

class	ModuleScanner

Functions
def	pathdirs

def	getdoc

def	splitdoc

def	classname

def	isdata

def	replace

def	cram

def	stripid

def	allmethods

def	ispackage

def	synopsis

def	importfile

def	safeimport

def	pager

def	getpager

def	plain

def	pipepager

def	tempfilepager

def	ttypager

def	plainpager

def	describe

def	locate

def	doc

def	writedoc

def	writedocs

def	apropos

def	serve

def	gui

def	ispath

def	cli

Variables
string	__author__ = "Ka-Ping Yee <ping@lfw.org>"

string	__date__ = "26 February 2001"

string	__version__ = "$Revision: 5816 $"

string	__credits__

tuple	text = TextDoc()

tuple	html = HTMLDoc()

tuple	help = Helper(sys.stdin, sys.stdout)

	encodingheader

	typeheader

	address

	url

	callback

	quit

	window

	server

	scanner

	server_frm

	title_lbl

	open_btn

	quit_btn

	search_frm

	search_lbl

	search_ent

	stop_btn

	result_lst

	result_scr

	result_frm

	goto_btn

	hide_btn

	minwidth

	minheight

	bigminheight

	bigheight

	expanded

	bigwidth