Back to index

moin  1.9.0~rc2
Public Member Functions | Public Attributes | Private Member Functions
MoinMoin.search.results.SearchResults Class Reference

List of all members.

Public Member Functions

def __init__
def stats
def pageList
def pageListWithContext
def formatContext
def firstInterestingMatch
def contextRange
def formatTitle
def formatMatch
def formatPageLinks
def formatHitInfoBar
def querystring
def formatInfo
def getvalue

Public Attributes

 query
 hits
 pages
 elapsed
 estimated_hits
 sort
 buffer
 formatter
 request
 matchLabel

Private Member Functions

def _sortByWeight
def _sortByPagename
def _reset

Detailed Description

Manage search results, supply different views

Search results can hold valid search results and format them for
many requests, until the wiki content changes.

For example, one might ask for full page list sorted from A to Z,
and then ask for the same list sorted from Z to A. Or sort results
by name and then by rank.

Definition at line 232 of file results.py.


Constructor & Destructor Documentation

def MoinMoin.search.results.SearchResults.__init__ (   self,
  query,
  hits,
  pages,
  elapsed,
  sort,
  estimated_hits 
)

Definition at line 244 of file results.py.

00244 
00245     def __init__(self, query, hits, pages, elapsed, sort, estimated_hits):
00246         self.query = query # the query
00247         self.hits = hits # hits list
00248         self.pages = pages # number of pages in the wiki
00249         self.elapsed = elapsed # search time
00250         self.estimated_hits = estimated_hits # about how much hits?
00251 
00252         if sort == 'weight':
00253             self._sortByWeight()
00254         elif sort == 'page_name':
00255             self._sortByPagename()
00256         self.sort = sort


Member Function Documentation

def MoinMoin.search.results.SearchResults._reset (   self,
  request,
  formatter 
) [private]
Update internal state before new output

Do not call this, it should be called only by the instance code.

Each request might need different translations or other user preferences.

@param request: current request
@param formatter: the formatter instance to use

Definition at line 794 of file results.py.

00794 
00795     def _reset(self, request, formatter):
00796         """ Update internal state before new output
00797 
00798         Do not call this, it should be called only by the instance code.
00799 
00800         Each request might need different translations or other user preferences.
00801 
00802         @param request: current request
00803         @param formatter: the formatter instance to use
00804         """
00805         self.buffer = StringIO.StringIO()
00806         self.formatter = formatter
00807         self.request = request
00808         # Use 1 match, 2 matches...
00809         _ = request.getText
00810         self.matchLabel = (_('match'), _('matches'))
00811 

Here is the caller graph for this function:

Sorts a list of found pages alphabetical by page/attachment name 

Definition at line 264 of file results.py.

00264 
00265     def _sortByPagename(self):
00266         """ Sorts a list of found pages alphabetical by page/attachment name """
00267         tmp = [(hit.page_name, hit.attachment, hit) for hit in self.hits]
00268         tmp.sort()
00269         self.hits = [item[2] for item in tmp]

Sorts found pages by the weight of the matches 

Definition at line 257 of file results.py.

00257 
00258     def _sortByWeight(self):
00259         """ Sorts found pages by the weight of the matches """
00260         tmp = [(hit.weight(), hit.page_name, hit.attachment, hit) for hit in self.hits]
00261         tmp.sort()
00262         tmp.reverse()
00263         self.hits = [item[3] for item in tmp]

def MoinMoin.search.results.SearchResults.contextRange (   self,
  context,
  match,
  start,
  last 
)
Compute context range

Add context around each match. If there is no room for context
before or after the match, show more context on the other side.

@param context: context length
@param match: current match
@param start: context should not start before that index, unless
      end is past the last character.
@param last: last character index
@rtype: tuple
@return: start, end of context

Definition at line 566 of file results.py.

00566 
00567     def contextRange(self, context, match, start, last):
00568         """ Compute context range
00569 
00570         Add context around each match. If there is no room for context
00571         before or after the match, show more context on the other side.
00572 
00573         @param context: context length
00574         @param match: current match
00575         @param start: context should not start before that index, unless
00576                       end is past the last character.
00577         @param last: last character index
00578         @rtype: tuple
00579         @return: start, end of context
00580         """
00581         # Start by giving equal context on both sides of match
00582         contextlen = max(context - len(match), 0)
00583         cstart = match.start - contextlen / 2
00584         cend = match.end + contextlen / 2
00585 
00586         # If context start before start, give more context on end
00587         if cstart < start:
00588             cend += start - cstart
00589             cstart = start
00590 
00591         # But if end if after last, give back context to start
00592         if cend > last:
00593             cstart -= cend - last
00594             cend = last
00595 
00596         # Keep context start positive for very short texts
00597         cstart = max(cstart, 0)
00598 
00599         return cstart, cend

Here is the caller graph for this function:

def MoinMoin.search.results.SearchResults.firstInterestingMatch (   self,
  page,
  matches 
)
Return the first interesting match

This function is needed only because we don't have yet a weight
algorithm for page text matches.

Try to find the first match in the page text. If we can't find
one, we return the first match and start=0.

@rtype: tuple
@return: index of first match, start of text

Definition at line 545 of file results.py.

00545 
00546     def firstInterestingMatch(self, page, matches):
00547         """ Return the first interesting match
00548 
00549         This function is needed only because we don't have yet a weight
00550         algorithm for page text matches.
00551 
00552         Try to find the first match in the page text. If we can't find
00553         one, we return the first match and start=0.
00554 
00555         @rtype: tuple
00556         @return: index of first match, start of text
00557         """
00558         header = page.page.getPageHeader()
00559         start = len(header)
00560         # Find first match after start
00561         for i in xrange(len(matches)):
00562             if matches[i].start >= start and \
00563                     isinstance(matches[i], TextMatch):
00564                 return i, start
00565         return 0, 0

Here is the caller graph for this function:

def MoinMoin.search.results.SearchResults.formatContext (   self,
  page,
  context,
  maxlines 
)
Format search context for each matched page

Try to show first maxlines interesting matches context.

Definition at line 464 of file results.py.

00464 
00465     def formatContext(self, page, context, maxlines):
00466         """ Format search context for each matched page
00467 
00468         Try to show first maxlines interesting matches context.
00469         """
00470         f = self.formatter
00471         if not page.page:
00472             page.page = Page(self.request, page.page_name)
00473         body = page.page.get_raw_body()
00474         last = len(body) - 1
00475         lineCount = 0
00476         output = []
00477 
00478         # Get unique text matches sorted by match.start, try to ignore
00479         # matches in page header, and show the first maxlines matches.
00480         # TODO: when we implement weight algorithm for text matches, we
00481         # should get the list of text matches sorted by weight and show
00482         # the first maxlines matches.
00483         matches = page.get_matches(unique=1, sort='start', type=TextMatch)
00484         i, start = self.firstInterestingMatch(page, matches)
00485 
00486         # Format context
00487         while i < len(matches) and lineCount < maxlines:
00488             match = matches[i]
00489 
00490             # Get context range for this match
00491             start, end = self.contextRange(context, match, start, last)
00492 
00493             # Format context lines for matches. Each complete match in
00494             # the context will be highlighted, and if the full match is
00495             # in the context, we increase the index, and will not show
00496             # same match again on a separate line.
00497 
00498             output.append(f.text(u'...'))
00499 
00500             # Get the index of the first match completely within the
00501             # context.
00502             for j in xrange(0, len(matches)):
00503                 if matches[j].start >= start:
00504                     break
00505 
00506             # Add all matches in context and the text between them
00507             while True:
00508                 match = matches[j]
00509                 # Ignore matches behind the current position
00510                 if start < match.end:
00511                     # Append the text before match
00512                     if start < match.start:
00513                         output.append(f.text(body[start:match.start]))
00514                     # And the match
00515                     output.append(self.formatMatch(body, match, start))
00516                     start = match.end
00517                 # Get next match, but only if its completely within the context
00518                 if j < len(matches) - 1 and matches[j + 1].end <= end:
00519                     j += 1
00520                 else:
00521                     break
00522 
00523             # Add text after last match and finish the line
00524             if match.end < end:
00525                 output.append(f.text(body[match.end:end]))
00526             output.append(f.text(u'...'))
00527             output.append(f.linebreak(preformatted=0))
00528 
00529             # Increase line and point to the next match
00530             lineCount += 1
00531             i = j + 1
00532 
00533         output = ''.join(output)
00534 
00535         if not output:
00536             # Return the first context characters from the page text
00537             output = f.text(page.page.getPageText(length=context))
00538             output = output.strip()
00539             if not output:
00540                 # This is a page with no text, only header, for example,
00541                 # a redirect page.
00542                 output = f.text(page.page.getPageHeader(length=context))
00543 
00544         return output

Here is the call graph for this function:

Here is the caller graph for this function:

Returns the code for the information below a search hit

@param page: the FoundPage instance

Definition at line 729 of file results.py.

00729 
00730     def formatHitInfoBar(self, page):
00731         """ Returns the code for the information below a search hit
00732 
00733         @param page: the FoundPage instance
00734         """
00735         request = self.request
00736         f = self.formatter
00737         _ = request.getText
00738         p = page.page
00739 
00740         rev = p.get_real_rev()
00741         if rev is None:
00742             rev = 0
00743 
00744         size_str = '%.1fk' % (p.size()/1024.0)
00745         revisions = p.getRevList()
00746         if len(revisions) and rev == revisions[0]:
00747             rev_str = '%s: %d (%s)' % (_('rev'), rev, _('current'))
00748         else:
00749             rev_str = '%s: %d' % (_('rev'), rev, )
00750         lastmod_str = _('last modified: %s') % p.mtime_printable(request)
00751 
00752         result = f.paragraph(1, attr={'class': 'searchhitinfobar'}) + \
00753                  f.text('%s - %s %s' % (size_str, rev_str, lastmod_str)) + \
00754                  f.paragraph(0)
00755         return result

Here is the caller graph for this function:

def MoinMoin.search.results.SearchResults.formatInfo (   self,
  formatter,
  page 
)
Return formatted match info

@param formatter: the formatter instance to use
@param page: the current page instance

Definition at line 770 of file results.py.

00770 
00771     def formatInfo(self, formatter, page):
00772         """ Return formatted match info
00773 
00774         @param formatter: the formatter instance to use
00775         @param page: the current page instance
00776         """
00777         template = u' . . . %s %s'
00778         template = u"%s%s%s" % (formatter.span(1, css_class="info"),
00779                                 template,
00780                                 formatter.span(0))
00781         # Count number of unique matches in text of all types
00782         count = len(page.get_matches(unique=1))
00783         info = template % (count, self.matchLabel[count != 1])
00784         return info

Here is the caller graph for this function:

def MoinMoin.search.results.SearchResults.formatMatch (   self,
  body,
  match,
  location 
)
Format single match in text

Format the part of the match after the current location in the
text. Matches behind location are ignored and an empty string is
returned.

@param body: text containing match
@param match: search match in text
@param location: current location in text
@rtype: unicode
@return: formatted match or empty string

Definition at line 639 of file results.py.

00639 
00640     def formatMatch(self, body, match, location):
00641         """ Format single match in text
00642 
00643         Format the part of the match after the current location in the
00644         text. Matches behind location are ignored and an empty string is
00645         returned.
00646 
00647         @param body: text containing match
00648         @param match: search match in text
00649         @param location: current location in text
00650         @rtype: unicode
00651         @return: formatted match or empty string
00652         """
00653         start = max(location, match.start)
00654         if start < match.end:
00655             f = self.formatter
00656             output = [
00657                 f.strong(1),
00658                 f.text(body[start:match.end]),
00659                 f.strong(0),
00660                 ]
00661             return ''.join(output)
00662         return ''

Here is the caller graph for this function:

def MoinMoin.search.results.SearchResults.formatPageLinks (   self,
  hitsFrom,
  hitsPerPage,
  hitsNum 
)
Format previous and next page links in page

@param hitsFrom: current position in the hits
@param hitsPerPage: number of hits per page
@param hitsNum: number of hits
@rtype: unicode
@return: links to previous and next pages (if exist)

Definition at line 663 of file results.py.

00663 
00664     def formatPageLinks(self, hitsFrom, hitsPerPage, hitsNum):
00665         """ Format previous and next page links in page
00666 
00667         @param hitsFrom: current position in the hits
00668         @param hitsPerPage: number of hits per page
00669         @param hitsNum: number of hits
00670         @rtype: unicode
00671         @return: links to previous and next pages (if exist)
00672         """
00673         _ = self.request.getText
00674         f = self.formatter
00675         querydict = dict(wikiutil.parseQueryString(self.request.query_string))
00676 
00677         def page_url(n):
00678             querydict.update({'from': n * hitsPerPage})
00679             return self.request.page.url(self.request, querydict, escape=0)
00680 
00681         pages = hitsNum // hitsPerPage
00682         remainder = hitsNum % hitsPerPage
00683         if remainder:
00684             pages += 1
00685         cur_page = hitsFrom // hitsPerPage
00686 
00687         textlinks = []
00688 
00689         # previous page available
00690         if cur_page > 0:
00691             textlinks.append(''.join([
00692                         f.url(1, href=page_url(cur_page-1)),
00693                         f.text(_('Previous')),
00694                         f.url(0)]))
00695         else:
00696             textlinks.append('')
00697 
00698         # list of pages to be shown
00699         page_range = range(*(
00700             cur_page - 5 < 0 and
00701                 (0, pages > 10 and 10 or pages) or
00702                 (cur_page - 5, cur_page + 6 > pages and
00703                     pages or cur_page + 6)))
00704         textlinks.extend([''.join([
00705                 i != cur_page and f.url(1, href=page_url(i)) or '',
00706                 f.text(str(i+1)),
00707                 i != cur_page and f.url(0) or '',
00708             ]) for i in page_range])
00709 
00710         # next page available
00711         if cur_page < pages - 1:
00712             textlinks.append(''.join([
00713                 f.url(1, href=page_url(cur_page+1)),
00714                 f.text(_('Next')),
00715                 f.url(0)]))
00716         else:
00717             textlinks.append('')
00718 
00719         return ''.join([
00720             f.table(1, attrs={'tableclass': 'searchpages'}),
00721             f.table_row(1),
00722                 f.table_cell(1),
00723                 # textlinks
00724                 (f.table_cell(0) + f.table_cell(1)).join(textlinks),
00725                 f.table_cell(0),
00726             f.table_row(0),
00727             f.table(0),
00728         ])

Here is the caller graph for this function:

Format page title

Invoke format match on all unique matches in page title.

@param page: found page
@rtype: unicode
@return: formatted title

Definition at line 600 of file results.py.

00600 
00601     def formatTitle(self, page):
00602         """ Format page title
00603 
00604         Invoke format match on all unique matches in page title.
00605 
00606         @param page: found page
00607         @rtype: unicode
00608         @return: formatted title
00609         """
00610         # Get unique title matches sorted by match.start
00611         matches = page.get_matches(unique=1, sort='start', type=TitleMatch)
00612 
00613         # Format
00614         pagename = page.page_name
00615         f = self.formatter
00616         output = []
00617         start = 0
00618         for match in matches:
00619             # Ignore matches behind the current position
00620             if start < match.end:
00621                 # Append the text before the match
00622                 if start < match.start:
00623                     output.append(f.text(pagename[start:match.start]))
00624                 # And the match
00625                 output.append(self.formatMatch(pagename, match, start))
00626                 start = match.end
00627         # Add text after match
00628         if start < len(pagename):
00629             output.append(f.text(pagename[start:]))
00630 
00631         if page.attachment: # show the attachment that matched
00632             output.extend([
00633                     " ",
00634                     f.strong(1),
00635                     f.text("(%s)" % page.attachment),
00636                     f.strong(0)])
00637 
00638         return ''.join(output)

Here is the call graph for this function:

Here is the caller graph for this function:

Return output in div with CSS class 

Definition at line 785 of file results.py.

00785 
00786     def getvalue(self):
00787         """ Return output in div with CSS class """
00788         value = [
00789             self.formatter.div(1, css_class='searchresults'),
00790             self.buffer.getvalue(),
00791             self.formatter.div(0),
00792             ]
00793         return '\n'.join(value)

Here is the caller graph for this function:

def MoinMoin.search.results.SearchResults.pageList (   self,
  request,
  formatter,
  info = 0,
  numbered = 1,
  paging = True,
  hitsFrom = 0,
  hitsInfo = 0 
)
Format a list of found pages

@param request: current request
@param formatter: formatter to use
@param info: show match info in title
@param numbered: use numbered list for display
@param paging: toggle paging
@param hitsFrom: current position in the hits
@param hitsInfo: toggle hits info line
@rtype: unicode
@return formatted page list

Definition at line 305 of file results.py.

00305 
00306             paging=True, hitsFrom=0, hitsInfo=0):
00307         """ Format a list of found pages
00308 
00309         @param request: current request
00310         @param formatter: formatter to use
00311         @param info: show match info in title
00312         @param numbered: use numbered list for display
00313         @param paging: toggle paging
00314         @param hitsFrom: current position in the hits
00315         @param hitsInfo: toggle hits info line
00316         @rtype: unicode
00317         @return formatted page list
00318         """
00319         self._reset(request, formatter)
00320         f = formatter
00321         write = self.buffer.write
00322         if numbered:
00323             lst = lambda on: f.number_list(on, start=hitsFrom+1)
00324         else:
00325             lst = f.bullet_list
00326 
00327         if paging and len(self.hits) <= request.cfg.search_results_per_page:
00328             paging = False
00329 
00330         # Add pages formatted as list
00331         if self.hits:
00332             write(lst(1))
00333 
00334             if paging:
00335                 hitsTo = hitsFrom + request.cfg.search_results_per_page
00336                 displayHits = self.hits[hitsFrom:hitsTo]
00337             else:
00338                 displayHits = self.hits
00339 
00340             for page in displayHits:
00341                 # TODO handle interwiki search hits
00342                 if page.attachment:
00343                     querydict = {
00344                         'action': 'AttachFile',
00345                         'do': 'view',
00346                         'target': page.attachment,
00347                     }
00348                 elif page.rev and page.rev != page.page.getRevList()[0]:
00349                     querydict = {
00350                         'rev': page.rev,
00351                     }
00352                 else:
00353                     querydict = None
00354                 querystr = self.querystring(querydict)
00355 
00356                 matchInfo = ''
00357                 if info:
00358                     matchInfo = self.formatInfo(f, page)
00359 
00360                 info_for_hits = u''
00361                 if hitsInfo:
00362                     info_for_hits = self.formatHitInfoBar(page)
00363 
00364                 item = [
00365                     f.listitem(1),
00366                     f.pagelink(1, page.page_name, querystr=querystr),
00367                     self.formatTitle(page),
00368                     f.pagelink(0, page.page_name),
00369                     matchInfo,
00370                     info_for_hits,
00371                     f.listitem(0),
00372                     ]
00373                 write(''.join(item))
00374             write(lst(0))
00375             if paging:
00376                 write(self.formatPageLinks(hitsFrom=hitsFrom,
00377                     hitsPerPage=request.cfg.search_results_per_page,
00378                     hitsNum=len(self.hits)))
00379 
00380         return self.getvalue()

Here is the call graph for this function:

Here is the caller graph for this function:

def MoinMoin.search.results.SearchResults.pageListWithContext (   self,
  request,
  formatter,
  info = 1,
  context = 180,
  maxlines = 1,
  paging = True,
  hitsFrom = 0,
  hitsInfo = 0 
)
Format a list of found pages with context

@param request: current request
@param formatter: formatter to use
@param info: show match info near the page link
@param context: how many characters to show around each match.
@param maxlines: how many contexts lines to show.
@param paging: toggle paging
@param hitsFrom: current position in the hits
@param hitsInfo: toggle hits info line
@rtype: unicode
@return formatted page list with context

Definition at line 382 of file results.py.

00382 
00383                             maxlines=1, paging=True, hitsFrom=0, hitsInfo=0):
00384         """ Format a list of found pages with context
00385 
00386         @param request: current request
00387         @param formatter: formatter to use
00388         @param info: show match info near the page link
00389         @param context: how many characters to show around each match.
00390         @param maxlines: how many contexts lines to show.
00391         @param paging: toggle paging
00392         @param hitsFrom: current position in the hits
00393         @param hitsInfo: toggle hits info line
00394         @rtype: unicode
00395         @return formatted page list with context
00396         """
00397         self._reset(request, formatter)
00398         f = formatter
00399         write = self.buffer.write
00400         _ = request.getText
00401 
00402         if paging and len(self.hits) <= request.cfg.search_results_per_page:
00403             paging = False
00404 
00405         # Add pages formatted as definition list
00406         if self.hits:
00407             write(f.definition_list(1))
00408 
00409             if paging:
00410                 hitsTo = hitsFrom + request.cfg.search_results_per_page
00411                 displayHits = self.hits[hitsFrom:hitsTo]
00412             else:
00413                 displayHits = self.hits
00414 
00415             for page in displayHits:
00416                 # TODO handle interwiki search hits
00417                 matchInfo = ''
00418                 if info:
00419                     matchInfo = self.formatInfo(f, page)
00420                 if page.attachment:
00421                     fmt_context = ""
00422                     querydict = {
00423                         'action': 'AttachFile',
00424                         'do': 'view',
00425                         'target': page.attachment,
00426                     }
00427                 elif page.page_name.startswith('FS/'): # XXX FS hardcoded
00428                     fmt_context = ""
00429                     querydict = None
00430                 else:
00431                     fmt_context = self.formatContext(page, context, maxlines)
00432                     if page.rev and page.rev != page.page.getRevList()[0]:
00433                         querydict = {
00434                             'rev': page.rev,
00435                         }
00436                     else:
00437                         querydict = None
00438                 querystr = self.querystring(querydict)
00439                 item = [
00440                     f.definition_term(1),
00441                     f.pagelink(1, page.page_name, querystr=querystr),
00442                     self.formatTitle(page),
00443                     f.pagelink(0, page.page_name),
00444                     matchInfo,
00445                     f.definition_term(0),
00446                     f.definition_desc(1),
00447                     fmt_context,
00448                     f.definition_desc(0),
00449                     self.formatHitInfoBar(page),
00450                     ]
00451                 write(''.join(item))
00452             write(f.definition_list(0))
00453             if paging:
00454                 write(self.formatPageLinks(hitsFrom=hitsFrom,
00455                     hitsPerPage=request.cfg.search_results_per_page,
00456                     hitsNum=len(self.hits)))
00457 
00458         return self.getvalue()

Here is the call graph for this function:

Here is the caller graph for this function:

def MoinMoin.search.results.SearchResults.querystring (   self,
  querydict = None 
)
Return query string, used in the page link

@keyword querydict: use these parameters (default: None)

Definition at line 756 of file results.py.

00756 
00757     def querystring(self, querydict=None):
00758         """ Return query string, used in the page link
00759 
00760         @keyword querydict: use these parameters (default: None)
00761         """
00762         if querydict is None:
00763             querydict = {}
00764         if 'action' not in querydict or querydict['action'] == 'AttachFile':
00765             highlight = self.query.highlight_re()
00766             if highlight:
00767                 querydict.update({'highlight': highlight})
00768         querystr = wikiutil.makeQueryString(querydict)
00769         return querystr

Here is the caller graph for this function:

def MoinMoin.search.results.SearchResults.stats (   self,
  request,
  formatter,
  hitsFrom 
)
Return search statistics, formatted with formatter

@param request: current request
@param formatter: formatter to use
@param hitsFrom: current position in the hits
@rtype: unicode
@return formatted statistics

Definition at line 270 of file results.py.

00270 
00271     def stats(self, request, formatter, hitsFrom):
00272         """ Return search statistics, formatted with formatter
00273 
00274         @param request: current request
00275         @param formatter: formatter to use
00276         @param hitsFrom: current position in the hits
00277         @rtype: unicode
00278         @return formatted statistics
00279         """
00280         _ = request.getText
00281 
00282         if not self.estimated_hits:
00283             self.estimated_hits = ('', len(self.hits))
00284 
00285         output = [
00286             formatter.paragraph(1, attr={'class': 'searchstats'}),
00287             _("Results %(bs)s%(hitsFrom)d - %(hitsTo)d%(be)s "
00288                     "of %(aboutHits)s %(bs)s%(hits)d%(be)s results out of "
00289                     "about %(pages)d pages.") %
00290                 {'aboutHits': self.estimated_hits[0],
00291                     'hits': self.estimated_hits[1], 'pages': self.pages,
00292                     'hitsFrom': hitsFrom + 1,
00293                     'hitsTo': hitsFrom +
00294                             min(self.estimated_hits[1] - hitsFrom,
00295                                 request.cfg.search_results_per_page),
00296                     'bs': formatter.strong(1), 'be': formatter.strong(0)},
00297             u' (%s %s)' % (''.join([formatter.strong(1),
00298                 formatter.text("%.2f" % self.elapsed),
00299                 formatter.strong(0)]),
00300                 formatter.text(_("seconds"))),
00301             formatter.paragraph(0),
00302             ]
00303         return ''.join(output)

Here is the call graph for this function:


Member Data Documentation

Definition at line 804 of file results.py.

Definition at line 248 of file results.py.

Definition at line 249 of file results.py.

Definition at line 805 of file results.py.

Definition at line 246 of file results.py.

Definition at line 809 of file results.py.

Definition at line 247 of file results.py.

Definition at line 245 of file results.py.

Definition at line 806 of file results.py.

Definition at line 255 of file results.py.


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