from Common import * # If this is Python 2.2 or greater, import the standard Cookie module as CookieEngine. # Otherwise, import WebUtils.Cookie as CookieEngine. This is because there is a nasty # bug in the Cookie.py module included in Python 2.1 and earlier, and Python 1.5.2 # doesn't even include Cookie.py at all. pyVer = getattr(sys, 'version_info', None) if pyVer and pyVer[:2] >= (2, 2): # Get Python's Cookie module. # We have to do some work since it has the same name as we do. So we'll strip out # anything from the path that might cause us to import from the WebKit directory, then # import Cookie using that restricted path -- that ought to ensure that we're using Python's # module. import imp, string, sys def ok(directory): return directory not in ['', '.'] and directory[-6:].lower() != 'webkit' path = filter(ok, sys.path) try: (file, pathname, description) = imp.find_module('Cookie', path) CookieEngine = imp.load_module('Cookie', file, pathname, description) except: if file: file.close() else: # For Python versions < 2.2, we are including a copy of the standard Cookie.py module from # Python 2.2, but modified to work with Python 1.5.2 and up. from WebUtils import Cookie CookieEngine = Cookie del Cookie class Cookie(Object): """ Cookie is used to create cookies that have additional attributes beyond their value. Note that web browsers don't typically send any information with the cookie other than it's value. Therefore, in HTTPRequest, cookie() simply returns a value such as an integer or a string. When the server sends cookies back to the browser, it can send a cookie that simply has a value, or the cookie can be accompanied by various attributes (domain, path, max-age, ...) as described in RFC 2109. Therefore, in HTTPResponse, setCookie() can take either an instance of the Cookie class, as defined in this module, or a value. Note that Cookies values get pickled (see the pickle module), so you can set and get cookies that are integers, lists, dictionaries, etc. HTTP Cookies are officially described in RFC 2109: ftp://ftp.isi.edu/in-notes/rfc2109.txt FUTURE * This class should provide error checking in the setFoo() methods. Or maybe our internal Cookie implementation already does that? * This implementation is probably not as efficient as it should be, [a] it works and [b] the interface is stable. We can optimize later. """ ## Init ## def __init__(self, name, value): self._cookies = CookieEngine.SimpleCookie() self._name = name self._value = value self._cookies[name] = value self._cookie = self._cookies[name] ## Access attributes ## def comment(self): return self._cookie['comment'] def domain(self): return self._cookie['domain'] def maxAge(self): return self._cookie['max-age'] def expires(self): return self._cookie['expires'] def name(self): return self._name def path(self): return self._cookie['path'] def isSecure(self): return self._cookie['secure'] def value(self): return self._value def version(self): return self._cookie['version'] ## Setting attributes ## def setComment(self, comment): self._cookie['comment'] = comment def setDomain(self, domain): self._cookie['domain'] = domain def setExpires(self, expires): self._cookie['expires'] = expires def setMaxAge(self, maxAge): self._cookie['max-age'] = maxAge def setPath(self, path): self._cookie['path'] = path def setSecure(self, bool): self._cookie['secure'] = bool def setValue(self, value): self._value = value self._cookies[self._name] = value def setVersion(self, version): self._cookie['version'] = version ## Convenience ## def delete(self): self._value = '' self._cookie['expires'] = "Mon, 01-Jan-1900 00:00:00 GMT" self._cookie['max-age'] = 0 self._cookie['path'] = '/' ## HTTP Headers ## def headerValue(self): """ Returns a string with the value that should be used in the HTTP headers. """ items = self._cookies.items() assert(len(items)==1) return items[0][1].OutputString() def headerString(self): """ @@ 2000-06-09 ce: Not typically needed now that raw responses are structured dictionaries instead of opaque strigns. headerValue() is used instead. """ return str(self._cookies)