cubicweb: comparison web/http

equal deleted inserted replaced

-:aaf83cc07eed
+:73b2410bdadc
 header_case_mapping = {}
 def casemappingify(d):
 global header_case_mapping
-newd = dict([(key.lower(),key) for key in d])
+newd = dict([(key.lower(), key) for key in d])
 header_case_mapping.update(newd)
 def lowerify(d):
-return dict([(key.lower(),value) for key,value in d.items()])
+return dict([(key.lower(), value) for key, value in d.items()])
 class HeaderHandler(object):
 """HeaderHandler manages header generating and parsing functions.
 """
 if parser is None:
 raise ValueError("No header parser for header '%s', either add one or use getHeaderRaw." % (name,))
 try:
 for p in parser:
-# print "Parsing %s: %s(%s)" % (name, repr(p), repr(h))
+#print "==> Parsing %s: %s(%s)" % (name, repr(p), repr(header))
 header = p(header)
 # if isinstance(h, types.GeneratorType):
-#     h=list(h)
+#     h = list(h)
 except ValueError as v:
 # print v
-header=None
+header = None
 return header
 def generate(self, name, header):
 """
 # (Note: "GMT" is literal, not a variable timezone)
 # (also handles without without "GMT")
 # Two digit year, yucko.
 day, month, year = parts[1].split('-')
 time = parts[2]
-year=int(year)
+year = int(year)
 if year < 69:
 year = year + 2000
 elif year < 100:
 year = year + 1900
 elif len(parts) == 5:
 NOTE: not all headers can be parsed with this function.
 Takes a raw header value (list of strings), and
 Returns a generator of strings and Token class instances.
 """
-tokens=http_tokens
+tokens = http_tokens
-ctls=http_ctls
+ctls = http_ctls
 string = ",".join(header)
 list = []
 start = 0
 cur = 0
 elif x == '\\':
 qpair = True
 elif x == '"':
 quoted = False
 yield qstring+string[start:cur]
-qstring=None
+qstring = None
 start = cur+1
 elif x in tokens:
 if start != cur:
 if foldCase:
 yield string[start:cur].lower()
 Apache does it this way and has some comments about broken clients which
 forget commas (?), so I'm doing it the same way. It shouldn't
 hurt anything, in any case.
 """
-l=[]
+l = []
 for x in seq:
 if not isinstance(x, Token):
 l.append(x)
 return l
 raise ValueError, "Expected single token, not %s." % (tokens,)
 return tokens[0]
 def parseKeyValue(val):
 if len(val) == 1:
-return val[0],None
+return val[0], None
 elif len(val) == 3 and val[1] == Token('='):
-return val[0],val[2]
+return val[0], val[2]
 raise ValueError, "Expected key or key=value, but got %s." % (val,)
 def parseArgs(field):
-args=split(field, Token(';'))
+args = split(field, Token(';'))
 val = args.next()
 args = [parseKeyValue(arg) for arg in args]
-return val,args
+return val, args
 def listParser(fun):
 """Return a function which applies 'fun' to every element in the
 comma-separated list"""
 def listParserHelper(tokens):
 return listParserHelper
 def last(seq):
 """Return seq[-1]"""
 return seq[-1]
 def unique(seq):
 '''if seq is not a string, check it's a sequence of one element and return it'''
 if isinstance(seq, basestring):
 return [item]
 def generateKeyValues(kvs):
 l = []
 # print kvs
-for k,v in kvs:
+for k, v in kvs:
 if v is None:
 l.append('%s' % k)
 else:
-l.append('%s=%s' % (k,v))
+l.append('%s=%s' % (k, v))
 return ";".join(l)
 class MimeType(object):
 def fromString(klass, mimeTypeString):
 def __hash__(self):
 return hash(self.mediaType)^hash(self.mediaSubtype)^hash(tuple(self.params.iteritems()))
 ##### Specific header parsers.
 def parseAccept(field):
-type,args = parseArgs(field)
+type, args = parseArgs(field)
 if len(type) != 3 or type[1] != Token('/'):
 raise ValueError, "MIME Type "+str(type)+" invalid."
 # okay, this spec is screwy. A 'q' parameter is used as the separator
 # parameters.
 num = 0
 for arg in args:
 if arg[0] == 'q':
-mimeparams=tuple(args[0:num])
+mimeparams = tuple(args[0:num])
-params=args[num:]
+params = args[num:]
 break
 num = num + 1
 else:
-mimeparams=tuple(args)
+mimeparams = tuple(args)
-params=[]
+params = []
 # Default values for parameters:
 qval = 1.0
 # Parse accept parameters:
 for param in params:
-if param[0] =='q':
+if param[0] == 'q':
 qval = float(param[1])
 else:
 # Warn? ignored parameter.
 pass
-ret = MimeType(type[0],type[2],mimeparams),qval
+ret = MimeType(type[0], type[2], mimeparams), qval
 return ret
 def parseAcceptQvalue(field):
-type,args=parseArgs(field)
+type, args = parseArgs(field)
 type = checkSingleToken(type)
 qvalue = 1.0 # Default qvalue is 1
 for arg in args:
 if arg[0] == 'q':
 qvalue = float(arg[1])
-return type,qvalue
+return type, qvalue
 def addDefaultCharset(charsets):
 if charsets.get('*') is None and charsets.get('iso-8859-1') is None:
 charsets['iso-8859-1'] = 1.0
 return charsets
 def parseContentType(header):
 # Case folding is disabled for this header, because of use of
 # Content-Type: multipart/form-data; boundary=CaSeFuLsTuFf
 # So, we need to explicitly .lower() the type/subtype and arg keys.
-type,args = parseArgs(header)
+type, args = parseArgs(header)
 if len(type) != 3 or type[1] != Token('/'):
 raise ValueError, "MIME Type "+str(type)+" invalid."
 args = [(kv[0].lower(), kv[1]) for kv in args]
 def parseContentRange(header):
 """Parse a content-range header into (kind, start, end, realLength).
 realLength might be None if real length is not known ('*').
-start and end might be None if start,end unspecified (for response code 416)
+start and end might be None if start, end unspecified (for response code 416)
 """
 kind, other = header.strip().split()
 if kind.lower() != "bytes":
 raise ValueError("a range of type %r is not supported")
 startend, realLength = other.split("/")
 if startend.strip() == '*':
-start,end=None,None
+start, end = None, None
 else:
 start, end = map(int, startend.split("-"))
 if realLength == "*":
 realLength = None
 else:
 realLength = int(realLength)
 return (kind, start, end, realLength)
 def parseExpect(field):
-type,args=parseArgs(field)
+type, args = parseArgs(field)
-type=parseKeyValue(type)
+type = parseKeyValue(type)
 return (type[0], (lambda *args:args)(type[1], *args))
 def parseExpires(header):
 # """HTTP/1.1 clients and caches MUST treat other invalid date formats,
 #    especially including the value 0, as in the past (i.e., "already expired")."""
 def parseRange(range):
 range = list(range)
 if len(range) < 3 or range[1] != Token('='):
 raise ValueError("Invalid range header format: %s" %(range,))
-type=range[0]
+type = range[0]
 if type != 'bytes':
 raise ValueError("Unknown range unit: %s." % (type,))
-rangeset=split(range[2:], Token(','))
+rangeset = split(range[2:], Token(','))
 ranges = []
 for byterangespec in rangeset:
 if len(byterangespec) != 1:
 raise ValueError("Invalid range header format: %s" % (range,))
-start,end=byterangespec[0].split('-')
+start, end = byterangespec[0].split('-')
 if not start and not end:
 raise ValueError("Invalid range header format: %s" % (range,))
 if start:
 else:
 end = None
 if start and end and start > end:
 raise ValueError("Invalid range header, start > end: %s" % (range,))
-ranges.append((start,end))
+ranges.append((start, end))
-return type,ranges
+return type, ranges
 def parseRetryAfter(header):
 try:
 # delta seconds
 return time.time() + int(header)
 # in the unquoted base64 encoded credentials
 return scheme.lower(), rest
 #### Header generators
 def generateAccept(accept):
-mimeType,q = accept
+mimeType, q = accept
-out="%s/%s"%(mimeType.mediaType, mimeType.mediaSubtype)
+out ="%s/%s"%(mimeType.mediaType, mimeType.mediaSubtype)
 if mimeType.params:
 out+=';'+generateKeyValues(mimeType.params.iteritems())
 if q != 1.0:
 out+=(';q=%.3f' % (q,)).rstrip('0').rstrip('.')
 else:
 if k == 'no-cache' or k == 'private':
 # quoted list of values
 v = quoteString(generateList(
 [header_case_mapping.get(name) or dashCapitalize(name) for name in v]))
-return '%s=%s' % (k,v)
+return '%s=%s' % (k, v)
 def generateContentRange(tup):
 """tup is (type, start, end, len)
 len can be None.
 """
 def noneOr(s):
 if s is None:
 return ''
 return s
-type,ranges=range
+type, ranges = range
 if type != 'bytes':
 raise ValueError("Unknown range unit: "+type+".")
 return (type+'='+
 def generateRetryAfter(when):
 # always generate delta seconds format
 return str(int(when - time.time()))
 def generateContentType(mimeType):
-out="%s/%s"%(mimeType.mediaType, mimeType.mediaSubtype)
+out = "%s/%s" % (mimeType.mediaType, mimeType.mediaSubtype)
 if mimeType.params:
-out+=';'+generateKeyValues(mimeType.params.iteritems())
+out += ';' + generateKeyValues(mimeType.params.iteritems())
 return out
 def generateIfRange(dateOrETag):
 if isinstance(dateOrETag, ETag):
 return dateOrETag.generate()
 # If we're going to parse out to something other than a dict
 # we need to be able to generate from something other than a dict
 try:
 l = []
-for k,v in dict(challenge).iteritems():
+for k, v in dict(challenge).iteritems():
 l.append("%s=%s" % (k, quoteString(v)))
 _generated.append("%s %s" % (scheme, ", ".join(l)))
 except ValueError:
 _generated.append("%s %s" % (scheme, challenge))
 def __repr__(self):
 return "Etag(%r, weak=%r)" % (self.tag, self.weak)
 def parse(tokens):
-tokens=tuple(tokens)
+tokens = tuple(tokens)
 if len(tokens) == 1 and not isinstance(tokens[0], Token):
 return ETag(tokens[0])
 if(len(tokens) == 3 and tokens[0] == "w"
 and tokens[1] == Token('/')):
 return ETag(tokens[2], weak=True)
 raise ValueError("Invalid ETag.")
-parse=staticmethod(parse)
+parse = staticmethod(parse)
 def generate(self):
 if self.weak:
 return 'W/'+quoteString(self.tag)
 else:
 return quoteString(self.tag)
 def parseStarOrETag(tokens):
-tokens=tuple(tokens)
+tokens = tuple(tokens)
 if tokens == ('*',):
 return '*'
 else:
 return ETag.parse(tokens)
 def generateStarOrETag(etag):
-if etag=='*':
+if etag == '*':
 return etag
 else:
 return etag.generate()
 #### Cookies. Blech!
 class Cookie(object):
 # __slots__ = ['name', 'value', 'path', 'domain', 'ports', 'expires', 'discard', 'secure', 'comment', 'commenturl', 'version']
 def __init__(self, name, value, path=None, domain=None, ports=None, expires=None, discard=False, secure=False, comment=None, commenturl=None, version=0):
-self.name=name
+self.name = name
-self.value=value
+self.value = value
-self.path=path
+self.path = path
-self.domain=domain
+self.domain = domain
-self.ports=ports
+self.ports = ports
-self.expires=expires
+self.expires = expires
-self.discard=discard
+self.discard = discard
-self.secure=secure
+self.secure = secure
-self.comment=comment
+self.comment = comment
-self.commenturl=commenturl
+self.commenturl = commenturl
-self.version=version
+self.version = version
 def __repr__(self):
-s="Cookie(%r=%r" % (self.name, self.value)
+s = "Cookie(%r=%r" % (self.name, self.value)
 if self.path is not None: s+=", path=%r" % (self.path,)
 if self.domain is not None: s+=", domain=%r" % (self.domain,)
 if self.ports is not None: s+=", ports=%r" % (self.ports,)
 if self.expires is not None: s+=", expires=%r" % (self.expires,)
 if self.secure is not False: s+=", secure=%r" % (self.secure,)
 # Neither new RFC2965 cookies nor old netscape cookies are.
 header = ';'.join(headers)
 if header[0:8].lower() == "$version":
 # RFC2965 cookie
-h=tokenize([header], foldCase=False)
+h = tokenize([header], foldCase=False)
 r_cookies = split(h, Token(','))
 for r_cookie in r_cookies:
 last_cookie = None
 rr_cookies = split(r_cookie, Token(';'))
 for cookie in rr_cookies:
 (name,), (value,) = nameval
 else:
 (name,), = nameval
 value = None
-name=name.lower()
+name = name.lower()
 if name == '$version':
 continue
 if name[0] == '$':
 if last_cookie is not None:
 if name == '$path':
-last_cookie.path=value
+last_cookie.path = value
 elif name == '$domain':
-last_cookie.domain=value
+last_cookie.domain = value
 elif name == '$port':
 if value is None:
 last_cookie.ports = ()
 else:
-last_cookie.ports=tuple([int(s) for s in value.split(',')])
+last_cookie.ports = tuple([int(s) for s in value.split(',')])
 else:
 last_cookie = Cookie(name, value, version=1)
 cookies.append(last_cookie)
 else:
 # Oldstyle cookies don't do quoted strings or anything sensible.
 # All characters are valid for names except ';' and '=', and all
 # characters are valid for values except ';'. Spaces are stripped,
 # however.
 r_cookies = header.split(';')
 for r_cookie in r_cookies:
-name,value = r_cookie.split('=', 1)
+name, value = r_cookie.split('=', 1)
-name=name.strip(' \t')
+name = name.strip(' \t')
-value=value.strip(' \t')
+value = value.strip(' \t')
 cookies.append(Cookie(name, value))
 return cookies
 # the other side.
 if cookie_validname_re.match(cookie.name) is None:
 continue
-value=cookie.value
+value = cookie.value
 if cookie_validvalue_re.match(cookie.value) is None:
 value = quoteString(value)
 str_cookies.append("%s=%s" % (cookie.name, value))
 else:
 l = []
 for part in parts:
 namevalue = part.split('=',1)
 if len(namevalue) == 1:
-name=namevalue[0]
+name = namevalue[0]
-value=None
+value = None
 else:
-name,value=namevalue
+name, value = namevalue
-value=value.strip(' \t')
+value = value.strip(' \t')
-name=name.strip(' \t')
+name = name.strip(' \t')
 l.append((name, value))
 setCookies.append(makeCookieFromList(l, True))
 except ValueError:
 if name.startswith("$"):
 raise ValueError("Invalid cookie name: %r, starts with '$'." % name)
 cookie = Cookie(name, value)
 hadMaxAge = False
-for name,value in tup[1:]:
+for name, value in tup[1:]:
 name = name.lower()
 if value is None:
 if name in ("discard", "secure"):
 # Boolean attrs
 #         if item1[0] == item2[0]:
 #             return 0
 # def getMimeQuality(mimeType, accepts):
-#     type,args = parseArgs(mimeType)
+#     type, args = parseArgs(mimeType)
-#     type=type.split(Token('/'))
+#     type = type.split(Token('/'))
 #     if len(type) != 2:
 #         raise ValueError, "MIME Type "+s+" invalid."
 #     for accept in accepts:
-#         accept,acceptQual=accept
+#         accept, acceptQual = accept
-#         acceptType=accept[0:1]
+#         acceptType = accept[0:1]
-#         acceptArgs=accept[2]
+#         acceptArgs = accept[2]
 #         if ((acceptType == type or acceptType == (type[0],'*') or acceptType==('*','*')) and
 #             (args == acceptArgs or len(acceptArgs) == 0)):
 #             return acceptQual
 hasHeader = __contains__
 def getRawHeaders(self, name, default=None):
 """Returns a list of headers matching the given name as the raw string given."""
-name=name.lower()
+name = name.lower()
 raw_header = self._raw_headers.get(name, default)
 if raw_header is not _RecalcNeeded:
 return raw_header
 return self._toRaw(name)
 If no parser for the header exists, raise ValueError.
 If the header doesn't exist, return default (or None if not specified)
 """
-name=name.lower()
+name = name.lower()
 parsed = self._headers.get(name, default)
 if parsed is not _RecalcNeeded:
 return parsed
 return self._toParsed(name)
 def setRawHeaders(self, name, value):
 """Sets the raw representation of the given header.
 Value should be a list of strings, each being one header of the
 given name.
 """
-name=name.lower()
+name = name.lower()
 self._raw_headers[name] = value
 self._headers[name] = _RecalcNeeded
 def setHeader(self, name, value):
 """Sets the parsed representation of the given header.
 Value should be a list of objects whose exact form depends
 on the header in question.
 """
-name=name.lower()
+name = name.lower()
 self._raw_headers[name] = _RecalcNeeded
 self._headers[name] = value
 def addRawHeader(self, name, value):
 """
 Add a raw value to a header that may or may not already exist.
 If it exists, add it as a separate header to output; do not
 replace anything.
 """
-name=name.lower()
+name = name.lower()
 raw_header = self._raw_headers.get(name)
 if raw_header is None:
 # No header yet
 raw_header = []
 self._raw_headers[name] = raw_header
 """
 Add a parsed representatoin to a header that may or may not already exist.
 If it exists, add it as a separate header to output; do not
 replace anything.
 """
-name=name.lower()
+name = name.lower()
 header = self._headers.get(name)
 if header is None:
 # No header yet
 header = []
 self._headers[name] = header
 header.append(value)
 self._raw_headers[name] = _RecalcNeeded
 def removeHeader(self, name):
 """Removes the header named."""
-name=name.lower()
+name = name.lower()
 if name in self._raw_headers:
 del self._raw_headers[name]
 del self._headers[name]
 def __repr__(self):
 """Return the name with the canonical capitalization, if known,
 otherwise, Caps-After-Dashes"""
 return header_case_mapping.get(name) or dashCapitalize(name)
 def getAllRawHeaders(self):
-"""Return an iterator of key,value pairs of all headers
+"""Return an iterator of key, value pairs of all headers
 contained in this object, as strings. The keys are capitalized
 in canonical capitalization."""
-for k,v in self._raw_headers.iteritems():
+for k, v in self._raw_headers.iteritems():
 if v is _RecalcNeeded:
 v = self._toRaw(k)
 yield self.canonicalNameCaps(k), v
 def makeImmutable(self):
 iteritems = lambda x: x.iteritems()
 parser_general_headers = {
-'Cache-Control':(tokenize, listParser(parseCacheControl), dict),
+'Cache-Control': (tokenize, listParser(parseCacheControl), dict),
-'Connection':(tokenize,filterTokens),
+'Connection': (tokenize, filterTokens),
-'Date':(last,parseDateTime),
+'Date': (last, parseDateTime),
 #    'Pragma':tokenize
 #    'Trailer':tokenize
-'Transfer-Encoding':(tokenize,filterTokens),
+'Transfer-Encoding': (tokenize, filterTokens),
 #    'Upgrade':tokenize
-#    'Via':tokenize,stripComment
+#    'Via':tokenize, stripComment
 #    'Warning':tokenize
 }
 generator_general_headers = {
-'Cache-Control':(iteritems, listGenerator(generateCacheControl), singleHeader),
+'Cache-Control': (iteritems, listGenerator(generateCacheControl), singleHeader),
-'Connection':(generateList,singleHeader),
+'Connection': (generateList, singleHeader),
-'Date':(generateDateTime,singleHeader),
+'Date': (generateDateTime, singleHeader),
 #    'Pragma':
 #    'Trailer':
-'Transfer-Encoding':(generateList,singleHeader),
+'Transfer-Encoding': (generateList, singleHeader),
 #    'Upgrade':
 #    'Via':
 #    'Warning':
 }
 parser_request_headers = {
 'Accept': (tokenize, listParser(parseAccept), dict),
 'Accept-Charset': (tokenize, listParser(parseAcceptQvalue), dict, addDefaultCharset),
-'Accept-Encoding':(tokenize, listParser(parseAcceptQvalue), dict, addDefaultEncoding),
+'Accept-Encoding': (tokenize, listParser(parseAcceptQvalue), dict, addDefaultEncoding),
-'Accept-Language':(tokenize, listParser(parseAcceptQvalue), dict),
+'Accept-Language': (tokenize, listParser(parseAcceptQvalue), dict),
 'Access-Control-Allow-Origin': (last, parseAllowOrigin,),
 'Access-Control-Allow-Credentials': (last, parseAllowCreds,),
 'Access-Control-Allow-Methods': (tokenize, listParser(parseHTTPMethod), list),
 'Access-Control-Request-Method': (parseHTTPMethod, ),
 'Access-Control-Request-Headers': (filterTokens, ),
 'Access-Control-Expose-Headers': (filterTokens, ),
 'Authorization': (last, parseAuthorization),
-'Cookie':(parseCookie,),
+'Cookie': (parseCookie,),
-'Expect':(tokenize, listParser(parseExpect), dict),
+'Expect': (tokenize, listParser(parseExpect), dict),
-'From':(last,),
-'Host':(last,),
-'If-Match':(tokenize, listParser(parseStarOrETag), list),
-'If-Modified-Since':(last, parseIfModifiedSince),
-'If-None-Match':(tokenize, listParser(parseStarOrETag), list),
-'If-Range':(parseIfRange,),
-'If-Unmodified-Since':(last,parseDateTime),
-'Max-Forwards':(last,int),
 'Origin': (last,),
+'From': (last,),
+'Host': (last,),
+'If-Match': (tokenize, listParser(parseStarOrETag), list),
+'If-Modified-Since': (last, parseIfModifiedSince),
+'If-None-Match': (tokenize, listParser(parseStarOrETag), list),
+'If-Range': (parseIfRange,),
+'If-Unmodified-Since': (last, parseDateTime),
+'Max-Forwards': (last, int),
 #    'Proxy-Authorization':str, # what is "credentials"
-'Range':(tokenize, parseRange),
+'Range': (tokenize, parseRange),
-'Referer':(last,str), # TODO: URI object?
+'Referer': (last, str), # TODO: URI object?
-'TE':(tokenize, listParser(parseAcceptQvalue), dict),
+'TE': (tokenize, listParser(parseAcceptQvalue), dict),
-'User-Agent':(last,str),
+'User-Agent': (last, str),
 }
 generator_request_headers = {
-'Accept': (iteritems,listGenerator(generateAccept),singleHeader),
+'Accept': (iteritems, listGenerator(generateAccept), singleHeader),
-'Accept-Charset': (iteritems, listGenerator(generateAcceptQvalue),singleHeader),
+'Accept-Charset': (iteritems, listGenerator(generateAcceptQvalue), singleHeader),
-'Accept-Encoding': (iteritems, removeDefaultEncoding, listGenerator(generateAcceptQvalue),singleHeader),
+'Accept-Encoding': (iteritems, removeDefaultEncoding,
-'Accept-Language': (iteritems, listGenerator(generateAcceptQvalue),singleHeader),
+listGenerator(generateAcceptQvalue), singleHeader),
+'Accept-Language': (iteritems, listGenerator(generateAcceptQvalue), singleHeader),
 'Access-Control-Request-Method': (unique, str, singleHeader, ),
 'Access-Control-Expose-Headers': (listGenerator(str), ),
 'Access-Control-Allow-Headers': (listGenerator(str), ),
 'Authorization': (generateAuthorization,), # what is "credentials"
-'Cookie':(generateCookie,singleHeader),
+'Cookie': (generateCookie, singleHeader),
-'Expect':(iteritems, listGenerator(generateExpect), singleHeader),
+'Expect': (iteritems, listGenerator(generateExpect), singleHeader),
-'From':(unique, str,singleHeader),
+'From': (unique, str, singleHeader),
-'Host':(unique, str,singleHeader),
+'Host': (unique, str, singleHeader),
+'If-Match': (listGenerator(generateStarOrETag), singleHeader),
+'If-Modified-Since': (generateDateTime, singleHeader),
+'If-None-Match': (listGenerator(generateStarOrETag), singleHeader),
+'If-Range': (generateIfRange, singleHeader),
+'If-Unmodified-Since': (generateDateTime, singleHeader),
+'Max-Forwards': (unique, str, singleHeader),
 'Origin': (unique, str, singleHeader),
-'If-Match':(listGenerator(generateStarOrETag), singleHeader),
-'If-Modified-Since':(generateDateTime,singleHeader),
-'If-None-Match':(listGenerator(generateStarOrETag), singleHeader),
-'If-Range':(generateIfRange, singleHeader),
-'If-Unmodified-Since':(generateDateTime,singleHeader),
-'Max-Forwards':(unique, str, singleHeader),
 #    'Proxy-Authorization':str, # what is "credentials"
-'Range':(generateRange,singleHeader),
+'Range': (generateRange, singleHeader),
-'Referer':(unique, str,singleHeader),
+'Referer': (unique, str, singleHeader),
-'TE': (iteritems, listGenerator(generateAcceptQvalue),singleHeader),
+'TE': (iteritems, listGenerator(generateAcceptQvalue), singleHeader),
-'User-Agent':(unique, str,singleHeader),
+'User-Agent': (unique, str, singleHeader),
 }
 parser_response_headers = {
-'Accept-Ranges':(tokenize, filterTokens),
+'Accept-Ranges': (tokenize, filterTokens),
-'Age':(last,int),
+'Age': (last, int),
-'ETag':(tokenize, ETag.parse),
+'ETag': (tokenize, ETag.parse),
-'Location':(last,), # TODO: URI object?
+'Location': (last,), # TODO: URI object?
 #    'Proxy-Authenticate'
-'Retry-After':(last, parseRetryAfter),
+'Retry-After': (last, parseRetryAfter),
-'Server':(last,),
+'Server': (last,),
-'Set-Cookie':(parseSetCookie,),
+'Set-Cookie': (parseSetCookie,),
-'Set-Cookie2':(tokenize, parseSetCookie2),
+'Set-Cookie2': (tokenize, parseSetCookie2),
-'Vary':(tokenize, filterTokens),
+'Vary': (tokenize, filterTokens),
 'WWW-Authenticate': (lambda h: tokenize(h, foldCase=False),
 parseWWWAuthenticate,)
 }
 generator_response_headers = {
-'Accept-Ranges':(generateList, singleHeader),
+'Accept-Ranges': (generateList, singleHeader),
-'Age':(unique, str, singleHeader),
+'Age': (unique, str, singleHeader),
-'ETag':(ETag.generate, singleHeader),
+'ETag': (ETag.generate, singleHeader),
-'Location':(unique, str, singleHeader),
+'Location': (unique, str, singleHeader),
 #    'Proxy-Authenticate'
-'Retry-After':(generateRetryAfter, singleHeader),
+'Retry-After': (generateRetryAfter, singleHeader),
-'Server':(unique, str, singleHeader),
+'Server': (unique, str, singleHeader),
-'Set-Cookie':(generateSetCookie,),
+'Set-Cookie': (generateSetCookie,),
-'Set-Cookie2':(generateSetCookie2,),
+'Set-Cookie2': (generateSetCookie2,),
-'Vary':(generateList, singleHeader),
+'Vary': (generateList, singleHeader),
-'WWW-Authenticate':(generateWWWAuthenticate,)
+'WWW-Authenticate': (generateWWWAuthenticate,)
 }
 parser_entity_headers = {
-'Allow':(lambda str:tokenize(str, foldCase=False), filterTokens),
+'Allow': (lambda str:tokenize(str, foldCase=False), filterTokens),
-'Content-Encoding':(tokenize, filterTokens),
+'Content-Encoding': (tokenize, filterTokens),
-'Content-Language':(tokenize, filterTokens),
+'Content-Language': (tokenize, filterTokens),
-'Content-Length':(last, int),
+'Content-Length': (last, int),
-'Content-Location':(last,), # TODO: URI object?
+'Content-Location': (last,), # TODO: URI object?
-'Content-MD5':(last, parseContentMD5),
+'Content-MD5': (last, parseContentMD5),
-'Content-Range':(last, parseContentRange),
+'Content-Range': (last, parseContentRange),
-'Content-Type':(lambda str:tokenize(str, foldCase=False), parseContentType),
+'Content-Type': (lambda str:tokenize(str, foldCase=False), parseContentType),
-'Expires':(last, parseExpires),
+'Expires': (last, parseExpires),
-'Last-Modified':(last, parseDateTime),
+'Last-Modified': (last, parseDateTime),
 }
 generator_entity_headers = {
-'Allow':(generateList, singleHeader),
+'Allow': (generateList, singleHeader),
-'Content-Encoding':(generateList, singleHeader),
+'Content-Encoding': (generateList, singleHeader),
-'Content-Language':(generateList, singleHeader),
+'Content-Language': (generateList, singleHeader),
-'Content-Length':(unique, str, singleHeader),
+'Content-Length': (unique, str, singleHeader),
-'Content-Location':(unique, str, singleHeader),
+'Content-Location': (unique, str, singleHeader),
-'Content-MD5':(base64.encodestring, lambda x: x.strip("\n"), singleHeader),
+'Content-MD5': (base64.encodestring, lambda x: x.strip("\n"), singleHeader),
-'Content-Range':(generateContentRange, singleHeader),
+'Content-Range': (generateContentRange, singleHeader),
-'Content-Type':(generateContentType, singleHeader),
+'Content-Type': (generateContentType, singleHeader),
-'Expires':(generateDateTime, singleHeader),
+'Expires': (generateDateTime, singleHeader),
-'Last-Modified':(generateDateTime, singleHeader),
+'Last-Modified': (generateDateTime, singleHeader),
 }
 DefaultHTTPHandler.updateParsers(parser_general_headers)
 DefaultHTTPHandler.updateParsers(parser_request_headers)
 DefaultHTTPHandler.updateParsers(parser_response_headers)

changeset 9572	73b2410bdadc
parent 9571	aaf83cc07eed
child 9726	8905267dc7ae
child 9936	5dbf45204109