Python util.escape函数代码示例

 def add_message(self, cursor, forum, topic, replyto, author, body):
     sql = "INSERT INTO message (forum, topic, replyto, time, author," \
       " body) VALUES (%s, %s, %s, %s, %s, %s)"
     self.log.debug(sql % (forum, topic, replyto, int(time.time()),
       author, body))
     cursor.execute(sql, (forum, topic, replyto, int(time.time()),
       escape(author), escape(body)))

 def render(self, env, req):
     out = StringIO()
     can_vote = req.perm.has_permission('POLL_VOTE')
     if can_vote:
         out.write('<form id="%(id)s" method="get" action="%(href)s#%(id)s">\n'
                   '<input type="hidden" name="poll" value="%(id)s"/>\n'
                   % {'id': self.key, 'href': env.href(req.path_info)})
     out.write('<fieldset class="poll">\n'
               ' <legend>%s</legend>\n'
               ' <ul>\n'
               % escape(self.title))
     username = req.authname or 'anonymous'
     for id, style, vote in self.vote_defs:
         hid = escape(str(id))
         out.write('<li%s>\n' % (style and ' class="%s"' % style or ''))
         if can_vote:
             checked = username in self.votes[id]
             out.write('<input type="radio" name="vote" id="%(pvid)s" value="%(vid)s"%(checked)s/>\n'
                       '<label for="%(pvid)s">%(vote)s</label>\n'
                       % {'vid': hid,
                          'pvid': self.key + hid,
                          'vote': vote,
                          'checked': checked and ' checked="checked"' or ''})
         else:
             out.write(vote)
         if self.votes[id]:
             out.write(' <span class="voters">(<span class="voter">' +
                       '</span>, <span class="voter">'.join(self.votes[id]) +
                       '</span>)</span>')
         out.write('</li>\n')
     can_vote and out.write('<input type="submit" value="Vote"/>')
     out.write(' </ul>\n</fieldset>\n')
     can_vote and out.write('</form>\n')
     return out.getvalue()

    def _get_font(self):
        # Load the narcissus trac.ini font configuration into an instance variable
        buf = StringIO()
        trouble = False

        if 'narcissus' not in self.config.sections():
            msg = 'The narcissus section was not found in the trac configuration file.'
            buf.write(escape(msg))
            self.log.error(msg)
            trouble = True
        else:
            # check for the ttf_path entry
            self._ttf_path = self.config.get('narcissus', 'ttf_path')
            if not self._ttf_path:
                self._ttf = None # PIL will use default system font
                return None, None
            if not self._ttf_path[-4:].lower() == '.ttf':
                msg = 'The ttf_path is set to %s which is not a truetype font file.'\
                    % self._ttf_path
                buf.write(escape(msg))
                self.log.error(msg)
                trouble = True
            if not os.path.exists(self._ttf_path):
                msg = 'The ttf_path is set to %s but that path does not exist.'\
                    % self._ttf_path
                buf.write(escape(msg))
                self.log.error(msg)
                trouble = True
            self._ttf = ImageFont.truetype(self._ttf_path, 12)
        return trouble, buf

 def get_navigation_items(self, req):
     if req.authname and req.authname != 'anonymous':
         yield 'metanav', 'login', 'logged in as %s' % req.authname
         yield 'metanav', 'logout', Markup( '<a href="%s">Logout</a>' \
               % escape(self.env.href.logout()) )
     else:
         yield 'metanav', 'login', Markup( '<a href="%s">Login</a>' \
               % escape(self.env.href.login()) )

    def _load_config(self):
        # Load the narcissus trac.ini configuration into object instance variables.
        # The code in this function is modified from the graphviz plugin, (c) Peter Kropf
        buf = StringIO()
        trouble = False
        self.exe_suffix = ""
        if sys.platform == "win32":
            self.exe_suffix = ".exe"

        if "narcissus" not in self.config.sections():
            msg = "The narcissus section was not found in the trac configuration file."
            buf.write(escape(msg))
            self.log.error(msg)
            trouble = True
        else:
            # check for the cache_dir entry
            self.cache_dir = self.config.get("narcissus", "cache_dir")
            if not self.cache_dir:
                msg = "The narcissus section is missing the cache_dir field."
                buf.write(escape(msg))
                self.log.error(msg)
                trouble = True
            else:
                if not os.path.exists(self.cache_dir):
                    msg = "The cache_dir is set to %s but that path does not exist." % self.cache_dir
                    buf.write(escape(msg))
                    self.log.error(msg)
                    trouble = True

            # check for the cmd_path entry
            self.cmd_path = None
            if sys.platform in _CMD_PATHS:
                self.cmd_path = _CMD_PATHS[sys.platform]
            self.cmd_path = self.config.get("narcissus", "cmd_path", self.cmd_path)
            if not self.cmd_path:
                msg = (
                    """The narcissus section is missing the cmd_path field and
                    there is no default for %s."""
                    % sys.platform
                )
                buf.write(escape(msg))
                self.log.error(msg)
                trouble = True
            elif not os.path.exists(self.cmd_path):
                msg = "The cmd_path is set to %s but that path does not exist." % self.cmd_path
                buf.write(escape(msg))
                self.log.error(msg)
                trouble = True

            # check if we should run the cache manager
            self.cache_manager = self._boolean(self.config.get("narcissus", "cache_manager", False))
            if self.cache_manager:
                self.cache_max_size = int(self.config.get("narcissus", "cache_max_size", 10000000))
                self.cache_min_size = int(self.config.get("narcissus", "cache_min_size", 5000000))
                self.cache_max_count = int(self.config.get("narcissus", "cache_max_count", 2000))
                self.cache_min_count = int(self.config.get("narcissus", "cache_min_count", 1500))

        return trouble, buf

 def add_screenshot(self, cursor, name, description, time, author, tags,
   large_file, medium_file, small_file):
     sql = "INSERT INTO screenshot (name, description, time, author, tags," \
       " large_file, medium_file, small_file) VALUES (%s, %s, %s, %s, %s," \
       " %s, %s, %s)"
     self.log.debug(sql % (name, description, time, author, tags, large_file,
       medium_file, small_file))
     cursor.execute(sql, (escape(name), escape(description), time,
       escape(author), tags, large_file, medium_file, small_file))

 def get_navigation_items(self, req):
     if req.authname and req.authname != 'anonymous':
         yield 'metanav', 'login', Markup('logged in as <b>%s</b>' \
                 % req.authname)
         yield 'metanav', 'password', Markup('<a href="%s">Password</a>' \
               % escape(self.env.href.password()))
         yield 'metanav', 'logout', Markup('<a href="%s">Logout</a>' \
               % escape(self.env.href.logout()))
     else:
         yield 'metanav', 'login', Markup('<a href="%s">Login</a>' \
               % escape(self.env.href.login()))

 def _add_tags_and_branches(self, req, repos, rev):
     # TODO: consider pushing that in BrowserModule.process_request and
     #       extend the API with Repository.get_tags and Repository.get_branches
     tags = []
     for t, rev in repos.get_tags():
         tags.append({"name": escape(t), "rev": rev})
     branches = []
     for b, rev in repos.get_branches():
         branches.append({"name": escape(b), "rev": rev})
     req.hdf["browser.tags"] = tags
     req.hdf["browser.branches"] = branches

 def edit_forum(self, cursor, forum, name, subject, description, moderators,
   group):
     moderators = ' '.join(moderators)
     if not group:
         group = '0'
     sql = "UPDATE forum SET name = %s, subject = %s, description = %s," \
       " moderators = %s, forum_group = %s WHERE id = %s"
     self.log.debug(sql % (name, subject, description, moderators,
       group, forum))
     cursor.execute(sql, (escape(name), escape(subject),
       escape(description), escape(moderators), group, forum))

 def add_forum(self, cursor, name, author, subject, description, moderators,
   group):
     moderators = ' '.join(moderators)
     if not group:
         group = '0'
     sql = "INSERT INTO forum (name, author, time, moderators, subject," \
       " description, forum_group) VALUES (%s, %s, %s, %s, %s, %s, %s)"
     self.log.debug(sql % (name, author, str(int(time.time())), moderators,
       subject, description, group))
     cursor.execute(sql, (escape(name), escape(author),
       str(int(time.time())), escape(moderators), escape(subject),
       escape(description), group))

 def _update_acronyms(self):
     page = WikiPage(self.env, self.acronym_page)
     self.env.log.debug('Updating acronym database')
     self.acronyms = {}
     if not page.exists:
         return
     for line in page.text.splitlines():
         if line.startswith('||') and line.endswith('||') and line[3] != "'":
             try:
                 a, d, u, s = ([i.strip() for i in line.strip('||').split('||')] + ['', ''])[0:4]
                 assert self.valid_acronym.match(a), "Invalid acronym %s" % a
                 self.acronyms[a] = (escape(d), escape(u), escape(s))
             except Exception, e:
                 self.env.log.warning("Invalid acronym line: %s (%s)", line, e)

def render_table(items, colspec, render_item):
    try:
        columns = max(int(colspec), 1)
    except:
        columns = 3
    buf = StringIO()
    buf.write('<table class="wiki">'
              ' <tr>')
    headers = ['<th>Markup&nbsp;</th><th>&nbsp;Display</th>'] * columns
    buf.write('  <th>&nbsp;</th>'.join(headers))
    buf.write(' </tr>')
    items = items[:]
    items.sort()
    rows = []
    while items:
        rows.append(items[0:columns])
        items[0:columns] = []
    for r in rows:
        buf.write('<tr>')
        buf.write('<td>&nbsp;</td>'.join(['<td>%s</td><td>%s</td>' % \
                                          (escape(s), render_item(s))
                                          for s in r]))
        buf.write('</tr>')
    buf.write('</table>')
    return buf.getvalue()

    def render(self, req, mimetype, content, filename=None, url=None):
        if hasattr(content, 'read'):
            content = content.read()
	fd, path = tempfile.mkstemp(suffix='.xlsx', text=True)
	os.write(fd, content)
	os.close(fd)
	book = openpyxl.load_workbook(path)
        buf = []
	for sheetName in book.get_sheet_names():
	    sheet = book.get_sheet_by_name(sheetName)
	    if len(sheet.get_cell_collection()) == 0:
	        continue # Skip empty sheet
	    buf.append(u'<table class="listing"><caption>%s</caption>\n' % escape(sheetName))
            buf.append(u'<tbody>')
	    sheet.get_highest_row()
	    rowIdx = 0
	    for row in sheet.range(sheet.calculate_dimension()):
                buf.append(u'<tr class="%s">' % (rowIdx % 2 and 'odd' or 'even'))
		for cell in row:
		    if cell.value == None:
		        val = u''
	            else:
		        val = cell.value
                    buf.append(u'<td>%s</td>' % val)
                buf.append(u'</tr>\n')
		rowIdx = rowIdx + 1
            buf.append(u'</tbody>')
            buf.append(u'</table>\n')
	os.unlink(path)
        return u''.join(buf)

	def render_macro(self, req, name, content):
		content = content and REGEX_CRLF.sub("\n", escape(content).replace('"', '"')) or ''

		def inputstringcallback(match):
			if match.group('ur'):
				return '<span class="se-input-userreplacement">' + match.group('ur') + '</span>'
			if match.group('sq'):
				m = REGEXP_UR.sub(r'<span class="se-input-userreplacement">\1</span>', match.group('sq'))
				return '<span class="se-input-string">' + m + '</span>'
			if match.group('dq'):
				m = REGEXP_UR.sub(r'<span class="se-input-userreplacement">\1</span>', match.group('dq'))
				return '<span class="se-input-string">' + m + '</span>'
			if match.group('ct'):
				return '<span class="se-input-continuation">' + match.group('ct') + '</span>'
			if match.group('op'):
				return '<span class="se-input-option">' + match.group('op') + '</span>'
			return match.group(0)

		def linematcher_callback(match):
			if match.group('preinput'):
				s = ''
				if match.group('ps1'):
					if match.group('ps1start'):
						s += '<span class="se-prompt-start">' + match.group('ps1start') + '</span>'
					if match.group('user'):
						s += '<span class="se-prompt-user">' + match.group('user') + '</span>'
					if match.group('userhostsep'):
						s += '<span class="se-prompt-userhostseparator">' + match.group('userhostsep') + '</span>'
					if match.group('host'):
						s += '<span class="se-prompt-host">' + match.group('host') + '</span>'
					if match.group('userpathspace'):
						s += match.group('userpathspace')
					if match.group('path'):
						s += '<span class="se-prompt-path">' + match.group('path') + '</span>'
					if match.group('ps1end'):
						s += '<span class="se-prompt-end">' + match.group('ps1end') + '</span>'
					s = '<span class="se-prompt">' + s + '</span>';
				if match.group('cli'):
					if match.group('cli') == '# ':
						s += '<span class="se-root">' + match.group('cli') + '</span>'
					else:
						s += '<span class="se-unprivileged">' + match.group('cli') + '</span>'
					input = REGEXP_TAGS.sub(inputstringcallback, match.group('input'))
					s += '<span class="se-input">' + input + '</span>'
				return s;
			if match.group('note'):
				return '<span class="se-note">' + match.group('note') + '</span>'
			if match.group('delayedinput'):
				inputdelayed = REGEXP_TAGS.sub(inputstringcallback, match.group('delayedinput')[3:])
				return '<span class="se-input"><span class="se-input-delayed">' + inputdelayed + '</span></span>'
			if match.group('snippedoutput'):
				m = match.group('snippedoutput')
				sniptext = "&lt;Output Snipped&gt;" if len(m) == 5 else m[6:]
				return '<span class="se-output"><span class="se-output-snipped">' + sniptext + '</span></span>'
			if match.group('output'):
				return '<span class="se-output">' + match.group('output') + '</span>'
			return match.group(0)

		return Markup('<div class="code"><pre>' + REGEXP_LINE_MATCHER.sub(linematcher_callback, content) + '</pre></div>');

 def show_err(self, msg):
     """Display msg in an error box, using Trac style."""
     buf = StringIO()
     buf.write('<div id="content" class="error"><div class="message"> \n\
                <strong>Graphviz macro processor has detected an error. Please fix the problem before continuing.</strong> \n\
                <pre>%s</pre> \n\
                </div></div>' % escape(msg))
     self.log.error(msg)
     return buf