    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)