Python utils.safestr函数代码示例

def setcookie(name, value, expires='', domain=None,
              secure=False, httponly=False, path=None):
    """Sets a cookie."""
    morsel = Cookie.Morsel()
    name, value = safestr(name), safestr(value)
    morsel.set(name, value, urllib.quote(value))
    if expires < 0:
        expires = -1000000000
    morsel['expires'] = expires
    #"""
    if path:
        morsel['path'] = path
    else:
        if ctx.homepath == '':
            morsel['path'] = '/'
        else:
            morsel['path'] = ctx.homepath
    #"""
    #morsel['path'] = path or ctx.homepath+'/'

    if domain:
        morsel['domain'] = domain
    if secure:
        morsel['secure'] = secure
    value = morsel.OutputString()
    if httponly:
        value += '; httponly'
    header('Set-Cookie', value)

def header(hdr, value, unique=False):
    hdr, value = safestr(hdr), safestr(value)
    if '\n' in hdr or '\r' in hdr or '\n' in value or '\r' in value:
        raise ValueError, "invalid characters in header"

    if unique is True:
        for h, v in ctx.headers:
            if h.lower() == hdr.lower(): return

    ctx.headers.append((hdr, value))

    def query(self, paramstyle=None):
	s = []
	for x in self.items:
	    if isinstance(x, SQLParam):
		x = x.get_marker(paramstyle)
		s.append(safestr(x))
	    else:
		x = safestr(x)
		if paramstyle in ['format', 'pyformat']:
		    if '%' in x and '%%' not in x:
			x = x.replace('%', '%%')
		s.append(x)

	return "".join(s)

 def generate_code(text, filename):
     # parse the text
     rootnode = Parser(text, filename).parse()
             
     # generate python code from the parse tree
     code = rootnode.emit(indent="").strip()
     return safestr(code)

    def _render_option(self, arg, indent='  '):
        if isinstance(arg, (tuple, list)):
            value, desc= arg
        else:
            value, desc = arg, arg 

        value = utils.safestr(value)
        if isinstance(self.value, (tuple, list)):
            s_value = [utils.safestr(x) for x in self.value]
        else:
            s_value = utils.safestr(self.value)
        
        if s_value == value or (isinstance(s_value, list) and value in s_value):
            select_p = ' selected="selected"'
        else:
            select_p = ''
        return indent + '<option%s value="%s">%s</option>\n' % (select_p, net.websafe(value), net.websafe(desc))

def header(hdr, value, unique=False):
    """
    Adds the header `hdr: value` with the response.
    
    If `unique` is True and a header with that name already exists,
    it doesn't add a new one. 
    """
    hdr, value = safestr(hdr), safestr(value)
    # protection against HTTP response splitting attack
    if '\n' in hdr or '\r' in hdr or '\n' in value or '\r' in value:
        raise ValueError, 'invalid characters in header'
        
    if unique is True:
        for h, v in ctx.headers:
            if h.lower() == hdr.lower(): return
    
    ctx.headers.append((hdr, value))

 def generate_code(text, filename, parser=None):
     # parse the text
     parser = parser or Parser()
     rootnode = parser.parse(text, filename)
             
     # generate python code from the parse tree
     code = rootnode.emit(indent="").strip()
     return safestr(code)

 def log(self, status, environ):
     outfile = environ.get('wsgi.errors', web.debug)
     req = environ.get('PATH_INFO', '_')
     protocol = environ.get('ACTUAL_SERVER_PROTOCOL', '-')
     method = environ.get('REQUEST_METHOD', '-')
     host = "%s:%s"% (environ.get('REMOTE_ADDR', '-'),
                     environ.get('REMOTE_PORT', '-'))
     time = self.log_date_time_string()
     msg = self.format% (host, time, protocol, method, req, status)
     print >> outfile, utils.safestr(msg)

 def specialFilter(self):
     if len(self.filters) > 0:
         for filter in self.filters:
             rule = filter;
             rule = rule.replace('(*)', '(.+)?')
             if isinstance(self.content, unicode):
                 rule = safeunicode(rule)
             else:
                 rule = safestr(rule)
             self.content = re.compile(rule, re.I).sub("", self.content);

 def _generate_session_id(self):
     while True:
         rand = os.urandom(16)
         now = time.time()
         secret_key = self._config.secret_key
         session_id = sha1("%s%s%s%s" %(rand, now, utils.safestr(web.ctx.ip), secret_key))
         session_id = session_id.hexdigest()
         if session_id not in self.store:
             break
     return session_id

    def log(self, status, environ):
        outfile = environ.get("wsgi.errors", web.debug)
        req = environ.get("PATH_INFO", "_")
        protocol = environ.get("ACTUAL_SERVER_PROTOCOL", "-")
        method = environ.get("REQUEST_METHOD", "-")
        host = "%s:%s" % (environ.get("REMOTE_ADDR", "-"), environ.get("REMOTE_PORT", "-"))

        time = self.log_date_time_string()

        msg = self.format % (host, time, protocol, method, req, status)
        print >> outfile, utils.safestr(msg)

        def log(self, status, environ):
            outfile = environ.get('wsgi.errors', web.debug)
            req = environ.get('PATH_INFO', '_')
            protocol = environ.get('ACTUAL_SERVER_PROTOCOL', '-')
            method = environ.get('REQUEST_METHOD', '-')
            host = "%s:%s" % (environ.get('REMOTE_ADDR','-'), 
                              environ.get('REMOTE_PORT','-'))

            #@@ It is really bad to extend from 
            #@@ BaseHTTPRequestHandler just for this method
            time = self.log_date_time_string()

            msg = self.format % (host, time, protocol, method, req, status)
            print >> outfile, utils.safestr(msg)

    def __call__(self, env, start_response):
        for path,what in self.handlers:
            match = path.match(env['PATH_INFO'])
            if match:
                handle = what(env, self.render)
                args = [x for x in match.groups()]
                try:
                    result = getattr(handle, env['REQUEST_METHOD'])(*args)
                except:
                    print sys.stderr, traceback.format_exc()
                    if not self.debug:
                        result = "Internal Server Error"
                    else:
                        result = traceback.format_exc()
                    handle.response.status = "500 Internal Server Error"
                    #for x in handle.response.headers:
                    #    if x[0] == "Content-Type":
                    #        handle.response.headers.remove(x)
                    #        handle.response.headers.append(('Content-Type', "text/plain; charset=UTF-8"))
                    #        break
                #if "Content-Length" not in [k for k,_ in handle.response.headers]:
                #    handle.response.headers.append(('Content-Length', len(result)))
                #start_response(handle.response.status, [(k,v) for (k,v) in handle.response.headers.items()])
                start_response(handle.response.status, handle.response.headers)
                if hasattr(result, "next"):
                    for x in result:
                        yield safestr(x)
                else:
                    yield safestr(result)
                handle.cleanup()
                env.clear()
                handle = None
                return 

        start_response('404 Not Found', [('Content-Type', 'text/html')])
        yield ['<h1>Not Found</h1>']

    def fetchListPages(self, listtype="html"):
        print "Start to fetch and parse List"
	urls = self.listRule.getListUrls()
        for url in urls:
	    print "Fetching list page: ", url, "charset:", safestr(self.seed["charset"]), "timeout:", safestr(self.seed["timeout"])
            f = Fetch(url, charset = self.seed["charset"], timeout = self.seed["timeout"])
	    if f.isReady():
		doc = f.read()

		if listtype == "html":
		    self.parseListPage(f, doc, url)
		elif listtype == "json":
		    self.parseJsonPage(f, doc, url)

        print "List has finished parsing. It has %s docs." % ansicolor.red(self.__len__())

 def query(self, paramstyle=None):
     """
     Returns the query part of the sql query.
         >>> q = SQLQuery(["SELECT * FROM test WHERE name=", SQLParam('joe')])
         >>> q.query()
         'SELECT * FROM test WHERE name=%s'
         >>> q.query(paramstyle='qmark')
         'SELECT * FROM test WHERE name=?'
     """
     s = ''
     for x in self.items:
         if isinstance(x, SQLParam):
             x = x.get_marker(paramstyle)
         s += safestr(x)
     return s