20.21. cookielib — Cookie handling for HTTP clients
New in version 2.4.
Source code: Lib/cookielib.py
The cookielib module defines classes for automatic handling of HTTP cookies. It is useful for accessing web sites that require small pieces of data – cookies – to be set on the client machine by an HTTP response from a web server, and then returned to the server in later HTTP requests.
Both the regular Netscape cookie protocol and the protocol defined by RFC 2965 are handled. RFC 2965 handling is switched off by default. RFC 2109 cookies are parsed as Netscape cookies and subsequently treated either as Netscape or RFC 2965 cookies according to the ‘policy’ in effect. Note that the great majority of cookies on the Internet are Netscape cookies. cookielib attempts to follow the de-facto Netscape cookie protocol (which differs substantially from that set out in the original Netscape specification), including taking note of the
port cookie-attributes introduced with RFC 2965.
The various named parameters found in Set-Cookie and Set-Cookie2 headers (eg.
expires ) are conventionally referred to as attributes . To distinguish them from Python attributes, the documentation for this module uses the term cookie-attribute instead.
The module defines the following exception:
The following classes are provided:
The CookieJar class stores HTTP cookies. It extracts cookies from HTTP requests, and returns them in HTTP responses. CookieJar instances automatically expire contained cookies when necessary. Subclasses are also responsible for storing and retrieving cookies from a file or database.
A CookieJar which can load cookies from, and perhaps save cookies to, a file on disk. Cookies are NOT loaded from the named file until either the load() or revert() method is called. Subclasses of this class are documented in section FileCookieJar subclasses and co-operation with web browsers.
DefaultCookiePolicy implements the standard accept / reject rules for Netscape and RFC 2965 cookies. By default, RFC 2109 cookies (ie. cookies received in a Set-Cookie header with a version cookie-attribute of 1) are treated according to the RFC 2965 rules. However, if RFC 2965 handling is turned off or rfc2109_as_netscape is
True , RFC 2109 cookies are ‘downgraded’ by the CookieJar instance to Netscape cookies, by setting the
version attribute of the Cookie instance to 0. DefaultCookiePolicy also provides some parameters to allow some fine-tuning of policy.
CookieJar has the following methods:
The request object (usually a urllib2.Request instance) must support the methods
header_items() , and
add_unredirected_header() ,as documented by urllib2.
The response object (usually the result of a call to urllib2.urlopen(), or similar) should support an
info() method, which returns an object with a
getallmatchingheaders() method (usually a mimetools.Message instance).
The request object (usually a urllib2.Request instance) must support the methods
unverifiable() , and
get_origin_req_host() , as documented by urllib2. The request is used to set default values for cookie-attributes as well as for checking that the cookie is allowed to be set.
See the documentation for extract_cookies() for the interfaces required of the response and request arguments.
If invoked without arguments, clear all cookies. If given a single argument, only cookies belonging to that domain will be removed. If given two arguments, cookies belonging to the specified domain and URL path are removed. If given three arguments, then the cookie with the specified domain , path and name is removed.
Raises KeyError if no matching cookie exists.
Discards all contained cookies that have a true
discard attribute (usually because they had either no
expires cookie-attribute, or an explicit
discard cookie-attribute). For interactive browsers, the end of a session usually corresponds to closing the browser window.
Note that the
save() method won’t save session cookies anyway, unless you ask otherwise by passing a true ignore_discard argument.
FileCookieJar implements the following additional methods:
This base class raises NotImplementedError. Subclasses may leave this method unimplemented.
filename is the name of file in which to save cookies. If filename is not specified,
self.filename is used (whose default is the value passed to the constructor, if any); if
self.filename is None, ValueError is raised.
ignore_discard : save even cookies set to be discarded. ignore_expires : save even cookies that have expired
Old cookies are kept unless overwritten by newly loaded ones.
Arguments are as for save().
FileCookieJar instances have the following public attributes:
The following CookieJar subclasses are provided for reading and writing.
Version 3 of the Firefox web browser no longer writes cookies in the
cookies.txt file format.
This loses information about RFC 2965 cookies, and also about newer or non-standard cookie-attributes such as
Back up your cookies before saving if you have cookies whose loss / corruption would be inconvenient (there are some subtleties which may lead to slight changes in the file over a load / save round-trip).
Also note that cookies saved while Mozilla is running will get clobbered by Mozilla.
Objects implementing the CookiePolicy interface have the following methods:
This method is an optimization. It removes the need for checking every cookie with a particular domain (which might involve reading many files). Returning true from domain_return_ok() and path_return_ok() leaves all the work to return_ok().
If domain_return_ok() returns true for the cookie domain, path_return_ok() is called for the cookie path. Otherwise, path_return_ok() and return_ok() are never called for that cookie domain. If path_return_ok() returns true, return_ok() is called with the Cookie object itself for a full check. Otherwise, return_ok() is never called for that cookie path.
Note that domain_return_ok() is called for every cookie domain, not just for the request domain. For example, the function might be called with both
"www.example.com" if the request domain is
"www.example.com" . The same goes for path_return_ok().
The request argument is as documented for return_ok().
See the documentation for domain_return_ok().
In addition to implementing the methods above, implementations of the CookiePolicy interface must also supply the following attributes, indicating which protocols should be used, and how. All of these attributes may be assigned to.
Implements the standard rules for accepting and returning cookies.
Both RFC 2965 and Netscape cookies are covered. RFC 2965 handling is switched off by default.
The easiest way to provide your own policy is to override this class and call its methods in your overridden implementations before adding your own additional checks:
import cookielib class MyCookiePolicy(cookielib.DefaultCookiePolicy): def set_ok(self, cookie, request): if not cookielib.DefaultCookiePolicy.set_ok(self, cookie, request): return False if i_dont_want_to_store_this_cookie(cookie): return False return True
In addition to the features required to implement the CookiePolicy interface, this class allows you to block and allow domains from setting and receiving cookies. There are also some strictness switches that allow you to tighten up the rather loose Netscape protocol rules a little bit (at the cost of blocking some benign cookies).
A domain blacklist and whitelist is provided (both off by default). Only domains not in the blacklist and present in the whitelist (if the whitelist is active) participate in cookie setting and returning. Use the blocked_domains constructor argument, and
set_blocked_domains() methods (and the corresponding argument and methods for allowed_domains ). If you set a whitelist, you can turn it off again by setting it to None.
Domains in block or allow lists that do not start with a dot must equal the cookie domain to be matched. For example,
"example.com" matches a blacklist entry of
"example.com" , but
"www.example.com" does not. Domains that do start with a dot are matched by more specific domains too. For example, both
"example.com" itself does not). IP addresses are an exception, and must match exactly. For example, if blocked_domains contains
".168.1.2" , 192.168.1.2 is blocked, but 184.108.40.206 is not.
DefaultCookiePolicy implements the following additional methods:
DefaultCookiePolicy instances have the following attributes, which are all initialised from the constructor arguments of the same name, and which may all be assigned to.
New in version 2.5.
General strictness switches:
RFC 2965 protocol strictness switches:
Netscape protocol strictness switches:
strict_ns_domain is a collection of flags. Its value is constructed by or-ing together (for example,
DomainStrictNoDots|DomainStrictNonDomain means both flags are set).
The following attributes are provided for convenience, and are the most useful combinations of the above flags:
Cookie instances have Python attributes roughly corresponding to the standard cookie-attributes specified in the various cookie standards. The correspondence is not one-to-one, because there are complicated rules for assigning default values, because the
expires cookie-attributes contain equivalent information, and because RFC 2109 cookies may be ‘downgraded’ by cookielib from version 1 to version 0 (Netscape) cookies.
Assignment to these attributes should not be necessary other than in rare circumstances in a CookiePolicy method. The class does not enforce internal consistency, so you should know what you’re doing if you do that.
New in version 2.5.
Cookies may have additional non-standard cookie-attributes. These may be accessed using the following methods:
The Cookie class also defines the following method:
The first example shows the most common usage of cookielib:
import cookielib, urllib2 cj = cookielib.CookieJar() opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj)) r = opener.open("http://example.com/")
This example illustrates how to open a URL using your Netscape, Mozilla, or Lynx cookies (assumes Unix/Netscape convention for location of the cookies file):
import os, cookielib, urllib2 cj = cookielib.MozillaCookieJar() cj.load(os.path.join(os.path.expanduser("~"), ".netscape", "cookies.txt")) opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj)) r = opener.open("http://example.com/")
The next example illustrates the use of DefaultCookiePolicy. Turn on RFC 2965 cookies, be more strict about domains when setting and returning Netscape cookies, and block some domains from setting cookies or having them returned:
import urllib2 from cookielib import CookieJar, DefaultCookiePolicy policy = DefaultCookiePolicy( rfc2965=True, strict_ns_domain=DefaultCookiePolicy.DomainStrict, blocked_domains=["ads.net", ".ads.net"]) cj = CookieJar(policy) opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj)) r = opener.open("http://example.com/")