Vega strike Python Modules doc  0.5.1
Documentation of the " Modules " folder of Vega strike
 All Data Structures Namespaces Files Functions Variables
Public Member Functions | Data Fields | Static Public Attributes
HTMLDoc Class Reference
Inheritance diagram for HTMLDoc:
Doc

Public Member Functions

def page
 
def heading
 
def section
 
def bigsection
 
def preformat
 
def multicolumn
 
def grey
 
def namelink
 
def classlink
 
def modulelink
 
def modpkglink
 
def markup
 
def formattree
 
def docmodule
 
def docclass
 
def formatvalue
 
def docroutine
 
def docother
 
def index
 
- Public Member Functions inherited from Doc
def document
 
def fail
 

Data Fields

 needone
 

Static Public Attributes

 repr = _repr_instance.repr
 
 escape = _repr_instance.escape
 
- Static Public Attributes inherited from Doc
 docmodule = fail
 

Detailed Description

Formatter class for HTML documentation.

Definition at line 324 of file pydoc.py.

Member Function Documentation

def bigsection (   self,
  title,
  args 
) 
Format a section with a big heading.

Definition at line 377 of file pydoc.py.

References NoSectionError.section, DuplicateSectionError.section, NoOptionError.section, InterpolationError.section, InterpolationDepthError.section, and HTMLDoc.section().

377 
378  def bigsection(self, title, *args):
379  """Format a section with a big heading."""
380  title = '<big><strong>%s</strong></big>' % title
381  return apply(self.section, (title,) + args)
def classlink (   self,
  object,
  modname 
) 
Make a link for a class.

Definition at line 409 of file pydoc.py.

References pydoc.classname().

409 
410  def classlink(self, object, modname):
411  """Make a link for a class."""
412  name, module = object.__name__, sys.modules.get(object.__module__)
413  if hasattr(module, name) and getattr(module, name) is object:
414  return '<a href="%s.html#%s">%s</a>' % (
415  module.__name__, name, classname(object, modname))
416  return classname(object, modname)
def docclass (   self,
  object,
  name = None,
  mod = None,
  funcs = {},
  classes = {},
  ignored 
) 
Produce HTML documentation for a class object.

Definition at line 608 of file pydoc.py.

References audiodev.__init__().

608 
609  *ignored):
610  """Produce HTML documentation for a class object."""
611  realname = object.__name__
612  name = name or realname
613  bases = object.__bases__
614 
615  contents = []
616  push = contents.append
617 
618  # Cute little class to pump out a horizontal rule between sections.
619  class HorizontalRule:
620  def __init__(self):
621  self.needone = 0
622  def maybe(self):
623  if self.needone:
624  push('<hr>\n')
625  self.needone = 1
626  hr = HorizontalRule()
627 
628  # List the mro, if non-trivial.
629  mro = list(inspect.getmro(object))
630  if len(mro) > 2:
631  hr.maybe()
632  push('<dl><dt>Method resolution order:</dt>\n')
633  for base in mro:
634  push('<dd>%s</dd>\n' % self.classlink(base,
635  object.__module__))
636  push('</dl>\n')
637 
638  def spill(msg, attrs, predicate):
639  ok, attrs = _split_list(attrs, predicate)
640  if ok:
641  hr.maybe()
642  push(msg)
643  for name, kind, homecls, value in ok:
644  push(self.document(getattr(object, name), name, mod,
645  funcs, classes, mdict, object))
646  push('\n')
647  return attrs
648 
649  def spillproperties(msg, attrs, predicate):
650  ok, attrs = _split_list(attrs, predicate)
651  if ok:
652  hr.maybe()
653  push(msg)
654  for name, kind, homecls, value in ok:
655  push('<dl><dt><strong>%s</strong></dt>\n' % name)
656  if value.__doc__ is not None:
657  doc = self.markup(value.__doc__, self.preformat,
658  funcs, classes, mdict)
659  push('<dd><tt>%s</tt></dd>\n' % doc)
660  for attr, tag in [("fget", " getter"),
661  ("fset", " setter"),
662  ("fdel", " deleter")]:
663  func = getattr(value, attr)
664  if func is not None:
665  base = self.document(func, name + tag, mod,
666  funcs, classes, mdict, object)
667  push('<dd>%s</dd>\n' % base)
668  push('</dl>\n')
669  return attrs
670 
671  def spilldata(msg, attrs, predicate):
672  ok, attrs = _split_list(attrs, predicate)
673  if ok:
674  hr.maybe()
675  push(msg)
676  for name, kind, homecls, value in ok:
677  base = self.docother(getattr(object, name), name, mod)
678  doc = getattr(value, "__doc__", None)
679  if doc is None:
680  push('<dl><dt>%s</dl>\n' % base)
681  else:
682  doc = self.markup(getdoc(value), self.preformat,
683  funcs, classes, mdict)
684  doc = '<dd><tt>%s</tt>' % doc
685  push('<dl><dt>%s%s</dl>\n' % (base, doc))
686  push('\n')
687  return attrs
688 
689  attrs = inspect.classify_class_attrs(object)
690  mdict = {}
691  for key, kind, homecls, value in attrs:
692  mdict[key] = anchor = '#' + name + '-' + key
693  value = getattr(object, key)
694  try:
695  # The value may not be hashable (e.g., a data attr with
696  # a dict or list value).
697  mdict[value] = anchor
698  except TypeError:
699  pass
700 
701  while attrs:
702  if mro:
703  thisclass = mro.pop(0)
704  else:
705  thisclass = attrs[0][2]
706  attrs, inherited = _split_list(attrs, lambda t: t[2] is thisclass)
707 
708  if thisclass is object:
709  tag = "defined here"
710  else:
711  tag = "inherited from %s" % self.classlink(thisclass,
712  object.__module__)
713  tag += ':<br>\n'
714 
715  # Sort attrs by name.
716  attrs.sort(lambda t1, t2: cmp(t1[0], t2[0]))
717 
718  # Pump out the attrs, segregated by kind.
719  attrs = spill("Methods %s" % tag, attrs,
720  lambda t: t[1] == 'method')
721  attrs = spill("Class methods %s" % tag, attrs,
722  lambda t: t[1] == 'class method')
723  attrs = spill("Static methods %s" % tag, attrs,
724  lambda t: t[1] == 'static method')
725  attrs = spillproperties("Properties %s" % tag, attrs,
726  lambda t: t[1] == 'property')
727  attrs = spilldata("Data and non-method functions %s" % tag, attrs,
728  lambda t: t[1] == 'data')
729  assert attrs == []
730  attrs = inherited
731 
732  contents = ''.join(contents)
733 
734  if name == realname:
735  title = '<a name="%s">class <strong>%s</strong></a>' % (
736  name, realname)
737  else:
738  title = '<strong>%s</strong> = <a name="%s">class %s</a>' % (
739  name, name, realname)
740  if bases:
741  parents = []
742  for base in bases:
743  parents.append(self.classlink(base, object.__module__))
744  title = title + '(%s)' % join(parents, ', ')
745  doc = self.markup(getdoc(object), self.preformat, funcs, classes, mdict)
746  doc = doc and '<tt>%s<br>&nbsp;</tt>' % doc or '&nbsp;'
747 
748  return self.section(title, '#000000', '#ffc8d8', contents, 5, doc)
def docmodule (   self,
  object,
  name = None,
  mod = None,
  ignored 
) 
Produce HTML documentation for a module object.

Definition at line 492 of file pydoc.py.

References HTMLDoc.bigsection(), HTMLDoc.docclass(), Doc.document(), HTMLDoc.escape, HTMLDoc.formattree(), inspect.getabsfile(), inspect.getclasstree(), pydoc.getdoc(), inspect.getmembers(), inspect.getmodule(), inspect.getmodulename(), HTMLDoc.heading(), inspect.isbuiltin(), inspect.isfunction(), pydoc.ispackage(), dospath.join(), HTMLDoc.markup(), HTMLDoc.modpkglink(), HTMLDoc.multicolumn(), nturl2path.pathname2url(), HTMLDoc.preformat(), dospath.split(), locale.str(), and string.strip().

492 
493  def docmodule(self, object, name=None, mod=None, *ignored):
494  """Produce HTML documentation for a module object."""
495  name = object.__name__ # ignore the passed-in name
496  parts = split(name, '.')
497  links = []
498  for i in range(len(parts)-1):
499  links.append(
500  '<a href="%s.html"><font color="#ffffff">%s</font></a>' %
501  (join(parts[:i+1], '.'), parts[i]))
502  linkedname = join(links + parts[-1:], '.')
503  head = '<big><big><strong>%s</strong></big></big>' % linkedname
504  try:
505  path = inspect.getabsfile(object)
506  url = path
507  if sys.platform == 'win32':
508  import nturl2path
509  url = nturl2path.pathname2url(path)
510  filelink = '<a href="file:%s">%s</a>' % (url, path)
511  except TypeError:
512  filelink = '(built-in)'
513  info = []
514  if hasattr(object, '__version__'):
515  version = str(object.__version__)
516  if version[:11] == '$' + 'Revision: ' and version[-1:] == '$':
517  version = strip(version[11:-1])
518  info.append('version %s' % self.escape(version))
519  if hasattr(object, '__date__'):
520  info.append(self.escape(str(object.__date__)))
521  if info:
522  head = head + ' (%s)' % join(info, ', ')
523  result = self.heading(
524  head, '#ffffff', '#7799ee', '<a href=".">index</a><br>' + filelink)
525 
526  modules = inspect.getmembers(object, inspect.ismodule)
527 
528  classes, cdict = [], {}
529  for key, value in inspect.getmembers(object, inspect.isclass):
530  if (inspect.getmodule(value) or object) is object:
531  classes.append((key, value))
532  cdict[key] = cdict[value] = '#' + key
533  for key, value in classes:
534  for base in value.__bases__:
535  key, modname = base.__name__, base.__module__
536  module = sys.modules.get(modname)
537  if modname != name and module and hasattr(module, key):
538  if getattr(module, key) is base:
539  if not cdict.has_key(key):
540  cdict[key] = cdict[base] = modname + '.html#' + key
541  funcs, fdict = [], {}
542  for key, value in inspect.getmembers(object, inspect.isroutine):
543  if inspect.isbuiltin(value) or inspect.getmodule(value) is object:
544  funcs.append((key, value))
545  fdict[key] = '#-' + key
546  if inspect.isfunction(value): fdict[value] = fdict[key]
547  data = []
548  for key, value in inspect.getmembers(object, isdata):
549  if key not in ['__builtins__', '__doc__']:
550  data.append((key, value))
551 
552  doc = self.markup(getdoc(object), self.preformat, fdict, cdict)
553  doc = doc and '<tt>%s</tt>' % doc
554  result = result + '<p>%s</p>\n' % doc
555 
556  if hasattr(object, '__path__'):
557  modpkgs = []
558  modnames = []
559  for file in os.listdir(object.__path__[0]):
560  path = os.path.join(object.__path__[0], file)
561  modname = inspect.getmodulename(file)
562  if modname and modname not in modnames:
563  modpkgs.append((modname, name, 0, 0))
564  modnames.append(modname)
565  elif ispackage(path):
566  modpkgs.append((file, name, 1, 0))
567  modpkgs.sort()
568  contents = self.multicolumn(modpkgs, self.modpkglink)
569  result = result + self.bigsection(
570  'Package Contents', '#ffffff', '#aa55cc', contents)
571  elif modules:
572  contents = self.multicolumn(
573  modules, lambda (key, value), s=self: s.modulelink(value))
574  result = result + self.bigsection(
575  'Modules', '#fffff', '#aa55cc', contents)
576 
577  if classes:
578  classlist = map(lambda (key, value): value, classes)
579  contents = [
580  self.formattree(inspect.getclasstree(classlist, 1), name)]
581  for key, value in classes:
582  contents.append(self.document(value, key, name, fdict, cdict))
583  result = result + self.bigsection(
584  'Classes', '#ffffff', '#ee77aa', join(contents))
585  if funcs:
586  contents = []
587  for key, value in funcs:
588  contents.append(self.document(value, key, name, fdict, cdict))
589  result = result + self.bigsection(
590  'Functions', '#ffffff', '#eeaa77', join(contents))
591  if data:
592  contents = []
593  for key, value in data:
594  contents.append(self.document(value, key))
595  result = result + self.bigsection(
596  'Data', '#ffffff', '#55aa55', join(contents, '<br>\n'))
597  if hasattr(object, '__author__'):
598  contents = self.markup(str(object.__author__), self.preformat)
599  result = result + self.bigsection(
600  'Author', '#ffffff', '#7799ee', contents)
601  if hasattr(object, '__credits__'):
602  contents = self.markup(str(object.__credits__), self.preformat)
603  result = result + self.bigsection(
604  'Credits', '#ffffff', '#7799ee', contents)
605 
606  return result
def docother (   self,
  object,
  name = None,
  mod = None,
  ignored 
) 
Produce HTML documentation for a data object.

Definition at line 807 of file pydoc.py.

References HTMLDoc.repr.

807 
808  def docother(self, object, name=None, mod=None, *ignored):
809  """Produce HTML documentation for a data object."""
810  lhs = name and '<strong>%s</strong> = ' % name or ''
811  return lhs + self.repr(object)
def docroutine (   self,
  object,
  name = None,
  mod = None,
  funcs = {},
  classes = {},
  methods = {},
  cl = None 
) 
Produce HTML documentation for a function or method object.

Definition at line 754 of file pydoc.py.

References HTMLDoc.classlink(), inspect.formatargspec(), HTMLDoc.formatvalue(), inspect.getargspec(), pydoc.getdoc(), HTMLDoc.grey(), inspect.isfunction(), inspect.ismethod(), HTMLDoc.markup(), and HTMLDoc.preformat().

754 
755  funcs={}, classes={}, methods={}, cl=None):
756  """Produce HTML documentation for a function or method object."""
757  realname = object.__name__
758  name = name or realname
759  anchor = (cl and cl.__name__ or '') + '-' + name
760  note = ''
761  skipdocs = 0
762  if inspect.ismethod(object):
763  imclass = object.im_class
764  if cl:
765  if imclass is not cl:
766  note = ' from ' + self.classlink(imclass, mod)
767  else:
768  if object.im_self:
769  note = ' method of %s instance' % self.classlink(
770  object.im_self.__class__, mod)
771  else:
772  note = ' unbound %s method' % self.classlink(imclass,mod)
773  object = object.im_func
774 
775  if name == realname:
776  title = '<a name="%s"><strong>%s</strong></a>' % (anchor, realname)
777  else:
778  if (cl and cl.__dict__.has_key(realname) and
779  cl.__dict__[realname] is object):
780  reallink = '<a href="#%s">%s</a>' % (
781  cl.__name__ + '-' + realname, realname)
782  skipdocs = 1
783  else:
784  reallink = realname
785  title = '<a name="%s"><strong>%s</strong></a> = %s' % (
786  anchor, name, reallink)
787  if inspect.isfunction(object):
788  args, varargs, varkw, defaults = inspect.getargspec(object)
789  argspec = inspect.formatargspec(
790  args, varargs, varkw, defaults, formatvalue=self.formatvalue)
791  if realname == '<lambda>':
792  title = '<strong>%s</strong> <em>lambda</em> ' % name
793  argspec = argspec[1:-1] # remove parentheses
794  else:
795  argspec = '(...)'
796 
797  decl = title + argspec + (note and self.grey(
798  '<font face="helvetica, arial">%s</font>' % note))
799 
800  if skipdocs:
801  return '<dl><dt>%s</dt></dl>\n' % decl
802  else:
803  doc = self.markup(
804  getdoc(object), self.preformat, funcs, classes, methods)
805  doc = doc and '<dd><tt>%s</tt></dd>' % doc
806  return '<dl><dt>%s</dt>%s</dl>\n' % (decl, doc)
def formattree (   self,
  tree,
  modname,
  parent = None 
) 
Produce HTML for a class tree as given by inspect.getclasstree().

Definition at line 473 of file pydoc.py.

References HTMLDoc.classlink(), HTMLDoc.formattree(), and dospath.join().

473 
474  def formattree(self, tree, modname, parent=None):
475  """Produce HTML for a class tree as given by inspect.getclasstree()."""
476  result = ''
477  for entry in tree:
478  if type(entry) is type(()):
479  c, bases = entry
480  result = result + '<dt><font face="helvetica, arial">'
481  result = result + self.classlink(c, modname)
482  if bases and bases != (parent,):
483  parents = []
484  for base in bases:
485  parents.append(self.classlink(base, modname))
486  result = result + '(' + join(parents, ', ') + ')'
487  result = result + '\n</font></dt>'
488  elif type(entry) is type([]):
489  result = result + '<dd>\n%s</dd>\n' % self.formattree(
490  entry, modname, c)
491  return '<dl>\n%s</dl>\n' % result
def formatvalue (   self,
  object 
) 
Format an argument default value as text.

Definition at line 749 of file pydoc.py.

References HTMLDoc.docroutine(), HTMLDoc.grey(), and HTMLDoc.repr.

749 
750  def formatvalue(self, object):
751  """Format an argument default value as text."""
752  return self.grey('=' + self.repr(object))
def grey (   self,
  text 
)

Definition at line 400 of file pydoc.py.

400 
401  def grey(self, text): return '<font color="#909090">%s</font>' % text
def heading (   self,
  title,
  fgcol,
  bgcol,
  extras = '' 
) 
Format a page heading.

Definition at line 344 of file pydoc.py.

References HTMLDoc.section().

344 
345  def heading(self, title, fgcol, bgcol, extras=''):
346  """Format a page heading."""
347  return '''
348 <table width="100%%" cellspacing=0 cellpadding=2 border=0 summary="heading">
349 <tr bgcolor="%s">
350 <td valign=bottom>&nbsp;<br>
351 <font color="%s" face="helvetica, arial">&nbsp;<br>%s</font></td
352 ><td align=right valign=bottom
353 ><font color="%s" face="helvetica, arial">%s</font></td></tr></table>
354  ''' % (bgcol, fgcol, title, fgcol, extras or '&nbsp;')
def index (   self,
  dir,
  shadowed = None 
) 
Generate an HTML index for a directory of modules.

Definition at line 812 of file pydoc.py.

References HTMLDoc.bigsection(), inspect.getmodulename(), pydoc.ispackage(), HTMLDoc.modpkglink(), and HTMLDoc.multicolumn().

812 
813  def index(self, dir, shadowed=None):
814  """Generate an HTML index for a directory of modules."""
815  modpkgs = []
816  if shadowed is None: shadowed = {}
817  seen = {}
818  files = os.listdir(dir)
819 
820  def found(name, ispackage,
821  modpkgs=modpkgs, shadowed=shadowed, seen=seen):
822  if not seen.has_key(name):
823  modpkgs.append((name, '', ispackage, shadowed.has_key(name)))
824  seen[name] = 1
825  shadowed[name] = 1
826 
827  # Package spam/__init__.py takes precedence over module spam.py.
828  for file in files:
829  path = os.path.join(dir, file)
830  if ispackage(path): found(file, 1)
831  for file in files:
832  path = os.path.join(dir, file)
833  if os.path.isfile(path):
834  modname = inspect.getmodulename(file)
835  if modname: found(modname, 0)
836 
837  modpkgs.sort()
838  contents = self.multicolumn(modpkgs, self.modpkglink)
839  return self.bigsection(dir, '#ffffff', '#ee77aa', contents)
840 
841 # -------------------------------------------- text documentation generator
def markup (   self,
  text,
  escape = None,
  funcs = {},
  classes = {},
  methods = {} 
) 
Mark up some plain text, given a context of symbols to look for.
Each context dictionary maps object names to anchor names.

Definition at line 435 of file pydoc.py.

References HTMLDoc.escape, dospath.join(), HTMLDoc.namelink(), and pydoc.replace().

435 
436  def markup(self, text, escape=None, funcs={}, classes={}, methods={}):
437  """Mark up some plain text, given a context of symbols to look for.
438  Each context dictionary maps object names to anchor names."""
439  escape = escape or self.escape
440  results = []
441  here = 0
442  pattern = re.compile(r'\b((http|ftp)://\S+[\w/]|'
443  r'RFC[- ]?(\d+)|'
444  r'PEP[- ]?(\d+)|'
445  r'(self\.)?(\w+))')
446  while 1:
447  match = pattern.search(text, here)
448  if not match: break
449  start, end = match.span()
450  results.append(escape(text[here:start]))
451 
452  all, scheme, rfc, pep, selfdot, name = match.groups()
453  if scheme:
454  url = escape(all).replace('"', '&quot;')
455  results.append('<a href="%s">%s</a>' % (url, url))
456  elif rfc:
457  url = 'http://www.rfc-editor.org/rfc/rfc%d.txt' % int(rfc)
458  results.append('<a href="%s">%s</a>' % (url, escape(all)))
459  elif pep:
460  url = 'http://www.python.org/peps/pep-%04d.html' % int(pep)
461  results.append('<a href="%s">%s</a>' % (url, escape(all)))
462  elif text[end:end+1] == '(':
463  results.append(self.namelink(name, methods, funcs, classes))
464  elif selfdot:
465  results.append('self.<strong>%s</strong>' % name)
466  else:
467  results.append(self.namelink(name, classes))
468  here = end
469  results.append(escape(text[here:]))
470  return join(results, '')
def modpkglink (   self,
  name,
  path,
  ispackage,
  shadowed 
) 
Make a link for a module or package to display in an index.

Definition at line 421 of file pydoc.py.

References HTMLDoc.grey().

421 
422  def modpkglink(self, (name, path, ispackage, shadowed)):
423  """Make a link for a module or package to display in an index."""
424  if shadowed:
425  return self.grey(name)
426  if path:
427  url = '%s.%s.html' % (path, name)
428  else:
429  url = '%s.html' % name
430  if ispackage:
431  text = '<strong>%s</strong>&nbsp;(package)' % name
432  else:
433  text = name
434  return '<a href="%s">%s</a>' % (url, text)
def modulelink (   self,
  object 
) 
Make a link for a module.

Definition at line 417 of file pydoc.py.

417 
418  def modulelink(self, object):
419  """Make a link for a module."""
420  return '<a href="%s.html">%s</a>' % (object.__name__, object.__name__)
def multicolumn (   self,
  list,
  format,
  cols = 4 
) 
Format a list of items into a multi-column list.

Definition at line 388 of file pydoc.py.

References locale.format().

388 
389  def multicolumn(self, list, format, cols=4):
390  """Format a list of items into a multi-column list."""
391  result = ''
392  rows = (len(list)+cols-1)/cols
393  for col in range(cols):
394  result = result + '<td width="%d%%" valign=top>' % (100/cols)
395  for i in range(rows*col, rows*col+rows):
396  if i < len(list):
397  result = result + format(list[i]) + '<br>\n'
398  result = result + '</td>'
399  return '<table width="100%%" summary="list"><tr>%s</tr></table>' % result
def namelink (   self,
  name,
  dicts 
) 
Make a link for an identifier, given name-to-URL mappings.

Definition at line 402 of file pydoc.py.

402 
403  def namelink(self, name, *dicts):
404  """Make a link for an identifier, given name-to-URL mappings."""
405  for dict in dicts:
406  if dict.has_key(name):
407  return '<a href="%s">%s</a>' % (dict[name], name)
408  return name
def page (   self,
  title,
  contents 
) 
Format an HTML page.

Definition at line 333 of file pydoc.py.

333 
334  def page(self, title, contents):
335  """Format an HTML page."""
336  return '''
337 <!doctype html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
338 <html><head><title>Python: %s</title>
339 <style type="text/css"><!--
340 TT { font-family: lucidatypewriter, lucida console, courier }
341 --></style></head><body bgcolor="#f0f0f8">
342 %s
343 </body></html>''' % (title, contents)
def preformat (   self,
  text 
) 
Format literal preformatted text.

Definition at line 382 of file pydoc.py.

References HTMLDoc.escape, string.expandtabs(), and pydoc.replace().

382 
383  def preformat(self, text):
384  """Format literal preformatted text."""
385  text = self.escape(expandtabs(text))
386  return replace(text, '\n\n', '\n \n', '\n\n', '\n \n',
387  ' ', '&nbsp;', '\n', '<br>\n')
def section (   self,
  title,
  fgcol,
  bgcol,
  contents,
  width = 10,
  prelude = '',
  marginalia = None,
  gap = '&nbsp;&nbsp;' 
) 
Format a section with a heading.

Definition at line 356 of file pydoc.py.

356 
357  prelude='', marginalia=None, gap='&nbsp;&nbsp;'):
358  """Format a section with a heading."""
359  if marginalia is None:
360  marginalia = '<tt>' + '&nbsp;' * width + '</tt>'
361  result = '''
362 <table width="100%%" cellspacing=0 cellpadding=2 border=0 summary="section">
363 <tr bgcolor="%s">
364 <td colspan=3 valign=bottom>&nbsp;<br>
365 <font color="%s" face="helvetica, arial">%s</font></td></tr>
366  ''' % (bgcol, fgcol, title)
367  if prelude:
368  result = result + '''
369 <tr bgcolor="%s"><td rowspan=2>%s</td>
370 <td colspan=2>%s</td></tr>
371 <tr><td>%s</td>''' % (bgcol, marginalia, prelude, gap)
372  else:
373  result = result + '''
374 <tr><td bgcolor="%s">%s</td><td>%s</td>''' % (bgcol, marginalia, gap)
375 
376  return result + '\n<td width="100%%">%s</td></tr></table>' % contents

Field Documentation

escape = _repr_instance.escape
static

Definition at line 331 of file pydoc.py.

needone

Definition at line 620 of file pydoc.py.

repr = _repr_instance.repr
static

Definition at line 330 of file pydoc.py.

The documentation for this class was generated from the following file: