+#!/usr/bin/env python

+#

+

+####

+# Copyright 2000 by Timothy O'Malley <timo@alum.mit.edu>

+#

+# All Rights Reserved

+#

+# Permission to use, copy, modify, and distribute this software

+# and its documentation for any purpose and without fee is hereby

+# granted, provided that the above copyright notice appear in all

+# copies and that both that copyright notice and this permission

+# notice appear in supporting documentation, and that the name of

+# Timothy O'Malley not be used in advertising or publicity

+# pertaining to distribution of the software without specific, written

+# prior permission.

+#

+# Timothy O'Malley DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS

+# SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY

+# AND FITNESS, IN NO EVENT SHALL Timothy O'Malley BE LIABLE FOR

+# ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

+# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS

+# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

+# PERFORMANCE OF THIS SOFTWARE.

+#

+####

+#

+# Id: Cookie.py,v 2.29 2000/08/23 05:28:49 timo Exp

+# by Timothy O'Malley <timo@alum.mit.edu>

+#

+# Cookie.py is a Python module for the handling of HTTP

+# cookies as a Python dictionary. See RFC 2109 for more

+# information on cookies.

+#

+# The original idea to treat Cookies as a dictionary came from

+# Dave Mitchell (davem@magnet.com) in 1995, when he released the

+# first version of nscookie.py.

+#

+####

+

+"""

+Here's a sample session to show how to use this module.

+At the moment, this is the only documentation.

+

+The Basics

+----------

+

+Importing is easy..

+

+ >>> import Cookie

+

+Most of the time you start by creating a cookie. Cookies come in

+three flavors, each with slighly different encoding semanitcs, but

+more on that later.

+

+ >>> C = Cookie.SimpleCookie()

+ >>> C = Cookie.SerialCookie()

+ >>> C = Cookie.SmartCookie()

+

+[Note: Long-time users of Cookie.py will remember using

+Cookie.Cookie() to create an Cookie object. Although deprecated, it

+is still supported by the code. See the Backward Compatibility notes

+for more information.]

+

+Once you've created your Cookie, you can add values just as if it were

+a dictionary.

+

+ >>> C = Cookie.SmartCookie()

+ >>> C["fig"] = "newton"

+ >>> C["sugar"] = "wafer"

+ >>> print C

+ Set-Cookie: sugar=wafer;

+ Set-Cookie: fig=newton;

+

+Notice that the printable representation of a Cookie is the

+appropriate format for a Set-Cookie: header. This is the

+default behavior. You can change the header and printed

+attributes by using the the .output() function

+

+ >>> C = Cookie.SmartCookie()

+ >>> C["rocky"] = "road"

+ >>> C["rocky"]["path"] = "/cookie"

+ >>> print C.output(header="Cookie:")

+ Cookie: rocky=road; Path=/cookie;

+ >>> print C.output(attrs=[], header="Cookie:")

+ Cookie: rocky=road;

+

+The load() method of a Cookie extracts cookies from a string. In a

+CGI script, you would use this method to extract the cookies from the

+HTTP_COOKIE environment variable.

+

+ >>> C = Cookie.SmartCookie()

+ >>> C.load("chips=ahoy; vienna=finger")

+ >>> print C

+ Set-Cookie: vienna=finger;

+ Set-Cookie: chips=ahoy;

+

+The load() method is darn-tootin smart about identifying cookies

+within a string. Escaped quotation marks, nested semicolons, and other

+such trickeries do not confuse it.

+

+ >>> C = Cookie.SmartCookie()

+ >>> C.load('keebler="E=everybody; L=\\"Loves\\"; fudge=\\012;";')

+ >>> print C

+ Set-Cookie: keebler="E=everybody; L=\"Loves\"; fudge=\012;";

+

+Each element of the Cookie also supports all of the RFC 2109

+Cookie attributes. Here's an example which sets the Path

+attribute.

+

+ >>> C = Cookie.SmartCookie()

+ >>> C["oreo"] = "doublestuff"

+ >>> C["oreo"]["path"] = "/"

+ >>> print C

+ Set-Cookie: oreo="doublestuff"; Path=/;

+

+Each dictionary element has a 'value' attribute, which gives you

+back the value associated with the key.

+

+ >>> C = Cookie.SmartCookie()

+ >>> C["twix"] = "none for you"

+ >>> C["twix"].value

+ 'none for you'

+

+

+A Bit More Advanced

+-------------------

+

+As mentioned before, there are three different flavors of Cookie

+objects, each with different encoding/decoding semantics. This

+section briefly discusses the differences.

+

+SimpleCookie

+

+The SimpleCookie expects that all values should be standard strings.

+Just to be sure, SimpleCookie invokes the str() builtin to convert

+the value to a string, when the values are set dictionary-style.

+

+ >>> C = Cookie.SimpleCookie()

+ >>> C["number"] = 7

+ >>> C["string"] = "seven"

+ >>> C["number"].value

+ '7'

+ >>> C["string"].value

+ 'seven'

+ >>> print C

+ Set-Cookie: number=7;

+ Set-Cookie: string=seven;

+

+

+SerialCookie

+

+The SerialCookie expects that all values should be serialized using

+cPickle (or pickle, if cPickle isn't available). As a result of

+serializing, SerialCookie can save almost any Python object to a

+value, and recover the exact same object when the cookie has been

+returned. (SerialCookie can yield some strange-looking cookie

+values, however.)

+

+ >>> C = Cookie.SerialCookie()

+ >>> C["number"] = 7

+ >>> C["string"] = "seven"

+ >>> C["number"].value

+ 7

+ >>> C["string"].value

+ 'seven'

+ >>> print C

+ Set-Cookie: number="I7\012.";

+ Set-Cookie: string="S'seven'\012p1\012.";

+

+Be warned, however, if SerialCookie cannot de-serialize a value (because

+it isn't a valid pickle'd object), IT WILL RAISE AN EXCEPTION.

+

+

+SmartCookie

+

+The SmartCookie combines aspects of each of the other two flavors.

+When setting a value in a dictionary-fashion, the SmartCookie will

+serialize (ala cPickle) the value *if and only if* it isn't a

+Python string. String objects are *not* serialized. Similarly,

+when the load() method parses out values, it attempts to de-serialize

+the value. If it fails, then it fallsback to treating the value

+as a string.

+

+ >>> C = Cookie.SmartCookie()

+ >>> C["number"] = 7

+ >>> C["string"] = "seven"

+ >>> C["number"].value

+ 7

+ >>> C["string"].value

+ 'seven'

+ >>> print C

+ Set-Cookie: number="I7\012.";

+ Set-Cookie: string=seven;

+

+

+Backwards Compatibility

+-----------------------

+

+In order to keep compatibilty with earlier versions of Cookie.py,

+it is still possible to use Cookie.Cookie() to create a Cookie. In

+fact, this simply returns a SmartCookie.

+

+ >>> C = Cookie.Cookie()

+ >>> C.__class__

+ <class Cookie.SmartCookie at 99f88>

+

+

+Finis.

+""" #"

+# ^

+# |----helps out font-lock

+

+#

+# Import our required modules

+#

+import string, sys

+from UserDict import UserDict

+

+try:

+ from cPickle import dumps, loads

+except ImportError:

+ from pickle import dumps, loads

+

+try:

+ import re

+except ImportError:

+ raise ImportError, "Cookie.py requires 're' from Python 1.5 or later"

+

+

+#

+# Define an exception visible to External modules

+#

+class CookieError(Exception):

+ pass

+

+

+# These quoting routines conform to the RFC2109 specification, which in

+# turn references the character definitions from RFC2068. They provide

+# a two-way quoting algorithm. Any non-text character is translated

+# into a 4 character sequence: a forward-slash followed by the

+# three-digit octal equivalent of the character. Any '\' or '"' is

+# quoted with a preceeding '\' slash.

+#

+# These are taken from RFC2068 and RFC2109.

+# _LegalChars is the list of chars which don't require "'s

+# _Translator hash-table for fast quoting

+#

+_LegalChars = string.letters + string.digits + "!#$%&'*+-.^_`|~"

+_Translator = {

+ '\000' : '\\000', '\001' : '\\001', '\002' : '\\002',

+ '\003' : '\\003', '\004' : '\\004', '\005' : '\\005',

+ '\006' : '\\006', '\007' : '\\007', '\010' : '\\010',

+ '\011' : '\\011', '\012' : '\\012', '\013' : '\\013',

+ '\014' : '\\014', '\015' : '\\015', '\016' : '\\016',

+ '\017' : '\\017', '\020' : '\\020', '\021' : '\\021',

+ '\022' : '\\022', '\023' : '\\023', '\024' : '\\024',

+ '\025' : '\\025', '\026' : '\\026', '\027' : '\\027',

+ '\030' : '\\030', '\031' : '\\031', '\032' : '\\032',

+ '\033' : '\\033', '\034' : '\\034', '\035' : '\\035',

+ '\036' : '\\036', '\037' : '\\037',

+

+ '"' : '\\"', '\\' : '\\\\',

+

+ '\177' : '\\177', '\200' : '\\200', '\201' : '\\201',

+ '\202' : '\\202', '\203' : '\\203', '\204' : '\\204',

+ '\205' : '\\205', '\206' : '\\206', '\207' : '\\207',

+ '\210' : '\\210', '\211' : '\\211', '\212' : '\\212',

+ '\213' : '\\213', '\214' : '\\214', '\215' : '\\215',

+ '\216' : '\\216', '\217' : '\\217', '\220' : '\\220',

+ '\221' : '\\221', '\222' : '\\222', '\223' : '\\223',

+ '\224' : '\\224', '\225' : '\\225', '\226' : '\\226',

+ '\227' : '\\227', '\230' : '\\230', '\231' : '\\231',

+ '\232' : '\\232', '\233' : '\\233', '\234' : '\\234',

+ '\235' : '\\235', '\236' : '\\236', '\237' : '\\237',

+ '\240' : '\\240', '\241' : '\\241', '\242' : '\\242',

+ '\243' : '\\243', '\244' : '\\244', '\245' : '\\245',

+ '\246' : '\\246', '\247' : '\\247', '\250' : '\\250',

+ '\251' : '\\251', '\252' : '\\252', '\253' : '\\253',

+ '\254' : '\\254', '\255' : '\\255', '\256' : '\\256',

+ '\257' : '\\257', '\260' : '\\260', '\261' : '\\261',

+ '\262' : '\\262', '\263' : '\\263', '\264' : '\\264',

+ '\265' : '\\265', '\266' : '\\266', '\267' : '\\267',

+ '\270' : '\\270', '\271' : '\\271', '\272' : '\\272',

+ '\273' : '\\273', '\274' : '\\274', '\275' : '\\275',

+ '\276' : '\\276', '\277' : '\\277', '\300' : '\\300',

+ '\301' : '\\301', '\302' : '\\302', '\303' : '\\303',

+ '\304' : '\\304', '\305' : '\\305', '\306' : '\\306',

+ '\307' : '\\307', '\310' : '\\310', '\311' : '\\311',

+ '\312' : '\\312', '\313' : '\\313', '\314' : '\\314',

+ '\315' : '\\315', '\316' : '\\316', '\317' : '\\317',

+ '\320' : '\\320', '\321' : '\\321', '\322' : '\\322',

+ '\323' : '\\323', '\324' : '\\324', '\325' : '\\325',

+ '\326' : '\\326', '\327' : '\\327', '\330' : '\\330',

+ '\331' : '\\331', '\332' : '\\332', '\333' : '\\333',

+ '\334' : '\\334', '\335' : '\\335', '\336' : '\\336',

+ '\337' : '\\337', '\340' : '\\340', '\341' : '\\341',

+ '\342' : '\\342', '\343' : '\\343', '\344' : '\\344',

+ '\345' : '\\345', '\346' : '\\346', '\347' : '\\347',

+ '\350' : '\\350', '\351' : '\\351', '\352' : '\\352',

+ '\353' : '\\353', '\354' : '\\354', '\355' : '\\355',

+ '\356' : '\\356', '\357' : '\\357', '\360' : '\\360',

+ '\361' : '\\361', '\362' : '\\362', '\363' : '\\363',

+ '\364' : '\\364', '\365' : '\\365', '\366' : '\\366',

+ '\367' : '\\367', '\370' : '\\370', '\371' : '\\371',

+ '\372' : '\\372', '\373' : '\\373', '\374' : '\\374',

+ '\375' : '\\375', '\376' : '\\376', '\377' : '\\377'

+ }

+

+def _quote(str, LegalChars=_LegalChars,

+ join=string.join, idmap=string._idmap, translate=string.translate):

+ #

+ # If the string does not need to be double-quoted,

+ # then just return the string. Otherwise, surround

+ # the string in doublequotes and precede quote (with a \)

+ # special characters.

+ #

+ if "" == translate(str, idmap, LegalChars):

+ return str

+ else:

+ return '"' + join( map(_Translator.get, str, str), "" ) + '"'

+# end _quote

+

+

+_OctalPatt = re.compile(r"\\[0-3][0-7][0-7]")

+_QuotePatt = re.compile(r"[\\].")

+

+def _unquote(str, join=string.join, atoi=string.atoi):

+ # If there aren't any doublequotes,

+ # then there can't be any special characters. See RFC 2109.

+ if len(str) < 2:

+ return str

+ if str[0] != '"' or str[-1] != '"':

+ return str

+

+ # We have to assume that we must decode this string.

+ # Down to work.

+

+ # Remove the "s

+ str = str[1:-1]

+

+ # Check for special sequences. Examples:

+ # \012 --> \n

+ # \" --> "

+ #

+ i = 0

+ n = len(str)

+ res = []

+ while 0 <= i < n:

+ Omatch = _OctalPatt.search(str, i)

+ Qmatch = _QuotePatt.search(str, i)

+ if not Omatch and not Qmatch: # Neither matched

+ res.append(str[i:])

+ break

+ # else:

+ j = k = -1

+ if Omatch: j = Omatch.start(0)

+ if Qmatch: k = Qmatch.start(0)

+ if Qmatch and ( not Omatch or k < j ): # QuotePatt matched

+ res.append(str[i:k])

+ res.append(str[k+1])

+ i = k+2

+ else: # OctalPatt matched

+ res.append(str[i:j])

+ res.append( chr( atoi(str[j+1:j+4], 8) ) )

+ i = j+4

+ return join(res, "")

+# end _unquote

+

+# The _getdate() routine is used to set the expiration time in

+# the cookie's HTTP header. By default, _getdate() returns the

+# current time in the appropriate "expires" format for a

+# Set-Cookie header. The one optional argument is an offset from

+# now, in seconds. For example, an offset of -3600 means "one hour ago".

+# The offset may be a floating point number.

+#

+

+_weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']

+

+_monthname = [None,

+ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',

+ 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']

+

+def _getdate(future=0, weekdayname=_weekdayname, monthname=_monthname):

+ from time import gmtime, time

+ now = time()

+ year, month, day, hh, mm, ss, wd, y, z = gmtime(now + future)

+ return "%s, %02d-%3s-%4d %02d:%02d:%02d GMT" % \

+ (weekdayname[wd], day, monthname[month], year, hh, mm, ss)

+

+

+#

+# A class to hold ONE key,value pair.

+# In a cookie, each such pair may have several attributes.

+# so this class is used to keep the attributes associated

+# with the appropriate key,value pair.

+# This class also includes a coded_value attribute, which

+# is used to hold the network representation of the

+# value. This is most useful when Python objects are

+# pickled for network transit.

+#

+

+class Morsel(UserDict):

+ # RFC 2109 lists these attributes as reserved:

+ # path comment domain

+ # max-age secure version

+ #

+ # For historical reasons, these attributes are also reserved:

+ # expires

+ #

+ # This dictionary provides a mapping from the lowercase

+ # variant on the left to the appropriate traditional

+ # formatting on the right.

+ _reserved = { "expires" : "expires",

+ "path" : "Path",

+ "comment" : "Comment",

+ "domain" : "Domain",

+ "max-age" : "Max-Age",

+ "secure" : "secure",

+ "version" : "Version",

+ }

+ _reserved_keys = _reserved.keys()

+

+ def __init__(self):

+ # Set defaults

+ self.key = self.value = self.coded_value = None

+ UserDict.__init__(self)

+

+ # Set default attributes

+ for K in self._reserved_keys:

+ UserDict.__setitem__(self, K, "")

+ # end __init__

+

+ def __setitem__(self, K, V):

+ K = string.lower(K)

+ if not K in self._reserved_keys:

+ raise CookieError("Invalid Attribute %s" % K)

+ UserDict.__setitem__(self, K, V)

+ # end __setitem__

+

+ def isReservedKey(self, K):

+ return string.lower(K) in self._reserved_keys

+ # end isReservedKey

+

+ def set(self, key, val, coded_val,

+ LegalChars=_LegalChars,

+ idmap=string._idmap, translate=string.translate ):

+ # First we verify that the key isn't a reserved word

+ # Second we make sure it only contains legal characters

+ if string.lower(key) in self._reserved_keys:

+ raise CookieError("Attempt to set a reserved key: %s" % key)

+ if "" != translate(key, idmap, LegalChars):

+ raise CookieError("Illegal key value: %s" % key)

+

+ # It's a good key, so save it.

+ self.key = key

+ self.value = val

+ self.coded_value = coded_val

+ # end set

+

+ def output(self, attrs=None, header = "Set-Cookie:"):

+ return "%s %s" % ( header, self.OutputString(attrs) )

+

+ __str__ = output

+

+ def __repr__(self):

+ return '<%s: %s=%s>' % (self.__class__.__name__,

+ self.key, repr(self.value) )

+

+ def js_output(self, attrs=None):

+ # Print javascript

+ return """

+ <SCRIPT LANGUAGE="JavaScript">

+ <!-- begin hiding

+ document.cookie = \"%s\"

+ // end hiding -->

+ </script>

+ """ % ( self.OutputString(attrs), )

+ # end js_output()

+

+ def OutputString(self, attrs=None):

+ # Build up our result

+ #

+ result = []

+ RA = result.append

+

+ # First, the key=value pair

+ RA("%s=%s;" % (self.key, self.coded_value))

+

+ # Now add any defined attributes

+ if attrs == None:

+ attrs = self._reserved_keys

+ for K,V in self.items():

+ if V == "": continue

+ if K not in attrs: continue

+ if K == "expires" and type(V) == type(1):

+ RA("%s=%s;" % (self._reserved[K], _getdate(V)))

+ elif K == "max-age" and type(V) == type(1):

+ RA("%s=%d;" % (self._reserved[K], V))

+ elif K == "secure":

+ RA("%s;" % self._reserved[K])

+ else:

+ RA("%s=%s;" % (self._reserved[K], V))

+

+ # Return the result

+ return string.join(result, " ")

+ # end OutputString

+# end Morsel class

+

+

+

+#

+# Pattern for finding cookie

+#

+# This used to be strict parsing based on the RFC2109 and RFC2068

+# specifications. I have since discovered that MSIE 3.0x doesn't

+# follow the character rules outlined in those specs. As a

+# result, the parsing rules here are less strict.

+#

+

+_LegalCharsPatt = r"[\w\d!#%&'~_`><@,:/\$\*\+\-\.\^\|\)\(\?\}\{]"

+_CookiePattern = re.compile(

+ r"(?x)" # This is a Verbose pattern

+ r"(?P<key>" # Start of group 'key'

+ ""+ _LegalCharsPatt +"+" # Any word of at least one letter

+ r")" # End of group 'key'

+ r"\s*=\s*" # Equal Sign

+ r"(?P<val>" # Start of group 'val'

+ r'"(?:[^\\"]|\\.)*"' # Any doublequoted string

+ r"|" # or

+ ""+ _LegalCharsPatt +"*" # Any word or empty string

+ r")" # End of group 'val'

+ r"\s*;?" # Probably ending in a semi-colon

+ )

+

+

+# At long last, here is the cookie class.

+# Using this class is almost just like using a dictionary.

+# See this module's docstring for example usage.

+#

+class BaseCookie(UserDict):

+ # A container class for a set of Morsels

+ #

+

+ def value_decode(self, val):

+ """real_value, coded_value = value_decode(STRING)

+ Called prior to setting a cookie's value from the network

+ representation. The VALUE is the value read from HTTP

+ header.

+ Override this function to modify the behavior of cookies.

+ """

+ return val, val

+ # end value_encode

+

+ def value_encode(self, val):

+ """real_value, coded_value = value_encode(VALUE)

+ Called prior to setting a cookie's value from the dictionary

+ representation. The VALUE is the value being assigned.

+ Override this function to modify the behavior of cookies.

+ """

+ strval = str(val)

+ return strval, strval

+ # end value_encode

+

+ def __init__(self, input=None):

+ UserDict.__init__(self)

+ if input: self.load(input)

+ # end __init__

+

+ def __set(self, key, real_value, coded_value):

+ """Private method for setting a cookie's value"""

+ M = self.get(key, Morsel())

+ M.set(key, real_value, coded_value)

+ UserDict.__setitem__(self, key, M)

+ # end __set

+

+ def __setitem__(self, key, value):

+ """Dictionary style assignment."""

+ rval, cval = self.value_encode(value)

+ self.__set(key, rval, cval)

+ # end __setitem__

+

+ def output(self, attrs=None, header="Set-Cookie:", sep="\n"):

+ """Return a string suitable for HTTP."""

+ result = []

+ for K,V in self.items():

+ result.append( V.output(attrs, header) )

+ return string.join(result, sep)

+ # end output

+

+ __str__ = output

+

+ def __repr__(self):

+ L = []

+ for K,V in self.items():

+ L.append( '%s=%s' % (K,repr(V.value) ) )

+ return '<%s: %s>' % (self.__class__.__name__, string.join(L))

+

+ def js_output(self, attrs=None):

+ """Return a string suitable for JavaScript."""

+ result = []

+ for K,V in self.items():

+ result.append( V.js_output(attrs) )

+ return string.join(result, "")

+ # end js_output

+

+ def load(self, rawdata):

+ """Load cookies from a string (presumably HTTP_COOKIE) or

+ from a dictionary. Loading cookies from a dictionary 'd'

+ is equivalent to calling:

+ map(Cookie.__setitem__, d.keys(), d.values())

+ """

+ if type(rawdata) == type(""):

+ self.__ParseString(rawdata)

+ else:

+ self.update(rawdata)

+ return

+ # end load()

+

+ def __ParseString(self, str, patt=_CookiePattern):

+ i = 0 # Our starting point

+ n = len(str) # Length of string

+ M = None # current morsel

+

+ while 0 <= i < n:

+ # Start looking for a cookie

+ match = patt.search(str, i)

+ if not match: break # No more cookies

+

+ K,V = match.group("key"), match.group("val")

+ i = match.end(0)

+

+ # Parse the key, value in case it's metainfo

+ if K[0] == "$":

+ # We ignore attributes which pertain to the cookie

+ # mechanism as a whole. See RFC 2109.

+ # (Does anyone care?)

+ if M:

+ M[ K[1:] ] = V

+ elif string.lower(K) in Morsel._reserved_keys:

+ if M:

+ M[ K ] = _unquote(V)

+ else:

+ rval, cval = self.value_decode(V)

+ self.__set(K, rval, cval)

+ M = self[K]

+ # end __ParseString

+# end BaseCookie class

+

+class SimpleCookie(BaseCookie):

+ """SimpleCookie

+ SimpleCookie supports strings as cookie values. When setting

+ the value using the dictionary assignment notation, SimpleCookie

+ calls the builtin str() to convert the value to a string. Values

+ received from HTTP are kept as strings.

+ """

+ def value_decode(self, val):

+ return _unquote( val ), val

+ def value_encode(self, val):

+ strval = str(val)

+ return strval, _quote( strval )

+# end SimpleCookie

+

+class SerialCookie(BaseCookie):

+ """SerialCookie

+ SerialCookie supports arbitrary objects as cookie values. All

+ values are serialized (using cPickle) before being sent to the

+ client. All incoming values are assumed to be valid Pickle

+ representations. IF AN INCOMING VALUE IS NOT IN A VALID PICKLE

+ FORMAT, THEN AN EXCEPTION WILL BE RAISED.

+

+ Note: Large cookie values add overhead because they must be

+ retransmitted on every HTTP transaction.

+

+ Note: HTTP has a 2k limit on the size of a cookie. This class

+ does not check for this limit, so be careful!!!

+ """

+ def value_decode(self, val):

+ # This could raise an exception!

+ return loads( _unquote(val) ), val

+ def value_encode(self, val):

+ return val, _quote( dumps(val) )

+# end SerialCookie

+

+class SmartCookie(BaseCookie):

+ """SmartCookie

+ SmartCookie supports arbitrary objects as cookie values. If the

+ object is a string, then it is quoted. If the object is not a

+ string, however, then SmartCookie will use cPickle to serialize

+ the object into a string representation.

+

+ Note: Large cookie values add overhead because they must be

+ retransmitted on every HTTP transaction.

+

+ Note: HTTP has a 2k limit on the size of a cookie. This class

+ does not check for this limit, so be careful!!!

+ """

+ def value_decode(self, val):

+ strval = _unquote(val)

+ try:

+ return loads(strval), val

+ except:

+ return strval, val

+ def value_encode(self, val):

+ if type(val) == type(""):

+ return val, _quote(val)

+ else:

+ return val, _quote( dumps(val) )

+# end SmartCookie

+

+

+###########################################################

+# Backwards Compatibility: Don't break any existing code!

+

+# We provide Cookie() as an alias for SmartCookie()

+Cookie = SmartCookie

+

+#

+###########################################################

+

+

+

+#Local Variables:

+#tab-width: 4

+#end:

+"""Common tests shared by test_string and test_userstring"""

+

+import string

+

+transtable = '\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037 !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`xyzdefghijklmnopqrstuvwxyz{|}~\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377'

+

+from UserList import UserList

+

+class Sequence:

+ def __init__(self): self.seq = 'wxyz'

+ def __len__(self): return len(self.seq)

+ def __getitem__(self, i): return self.seq[i]

+

+class BadSeq1(Sequence):

+ def __init__(self): self.seq = [7, 'hello', 123L]

+

+class BadSeq2(Sequence):

+ def __init__(self): self.seq = ['a', 'b', 'c']

+ def __len__(self): return 8

+

+def run_module_tests(test):

+ """Run all tests that exercise a function in the string module"""

+

+ test('atoi', " 1 ", 1)

+ test('atoi', " 1x", ValueError)

+ test('atoi', " x1 ", ValueError)

+ test('atol', " 1 ", 1L)

+ test('atol', " 1x ", ValueError)

+ test('atol', " x1 ", ValueError)

+ test('atof', " 1 ", 1.0)

+ test('atof', " 1x ", ValueError)

+ test('atof', " x1 ", ValueError)

+

+ test('maketrans', 'abc', transtable, 'xyz')

+ test('maketrans', 'abc', ValueError, 'xyzq')

+

+ # join now works with any sequence type

+ test('join', ['a', 'b', 'c', 'd'], 'a b c d')

+ test('join', ('a', 'b', 'c', 'd'), 'abcd', '')

+ test('join', Sequence(), 'w x y z')

+ test('join', 7, TypeError)

+

+ test('join', BadSeq1(), TypeError)

+ test('join', BadSeq2(), 'a b c')

+

+ # try a few long ones

+ print string.join(['x' * 100] * 100, ':')

+ print string.join(('x' * 100,) * 100, ':')

+

+

+def run_method_tests(test):

+ """Run all tests that exercise a method of a string object"""

+

+ test('capitalize', ' hello ', ' hello ')

+ test('capitalize', 'hello ', 'Hello ')

+ test('find', 'abcdefghiabc', 0, 'abc')

+ test('find', 'abcdefghiabc', 9, 'abc', 1)

+ test('find', 'abcdefghiabc', -1, 'def', 4)

+ test('rfind', 'abcdefghiabc', 9, 'abc')

+ test('lower', 'HeLLo', 'hello')

+ test('lower', 'hello', 'hello')

+ test('upper', 'HeLLo', 'HELLO')

+ test('upper', 'HELLO', 'HELLO')

+

+ test('title', ' hello ', ' Hello ')

+ test('title', 'hello ', 'Hello ')

+ test('title', "fOrMaT thIs aS titLe String", 'Format This As Title String')

+ test('title', "fOrMaT,thIs-aS*titLe;String", 'Format,This-As*Title;String')

+ test('title', "getInt", 'Getint')

+

+ test('expandtabs', 'abc\rab\tdef\ng\thi', 'abc\rab def\ng hi')

+ test('expandtabs', 'abc\rab\tdef\ng\thi', 'abc\rab def\ng hi', 8)

+ test('expandtabs', 'abc\rab\tdef\ng\thi', 'abc\rab def\ng hi', 4)

+ test('expandtabs', 'abc\r\nab\tdef\ng\thi', 'abc\r\nab def\ng hi', 4)

+

+ test('islower', 'a', 1)

+ test('islower', 'A', 0)

+ test('islower', '\n', 0)

+ test('islower', 'abc', 1)

+ test('islower', 'aBc', 0)

+ test('islower', 'abc\n', 1)

+

+ test('isupper', 'a', 0)

+ test('isupper', 'A', 1)

+ test('isupper', '\n', 0)

+ test('isupper', 'ABC', 1)

+ test('isupper', 'AbC', 0)

+ test('isupper', 'ABC\n', 1)

+

+ test('istitle', 'a', 0)

+ test('istitle', 'A', 1)

+ test('istitle', '\n', 0)

+ test('istitle', 'A Titlecased Line', 1)

+ test('istitle', 'A\nTitlecased Line', 1)

+ test('istitle', 'A Titlecased, Line', 1)

+ test('istitle', 'Not a capitalized String', 0)

+ test('istitle', 'Not\ta Titlecase String', 0)

+ test('istitle', 'Not--a Titlecase String', 0)

+

+ test('isalpha', 'a', 1)

+ test('isalpha', 'A', 1)

+ test('isalpha', '\n', 0)

+ test('isalpha', 'abc', 1)

+ test('isalpha', 'aBc123', 0)

+ test('isalpha', 'abc\n', 0)

+

+ test('isalnum', 'a', 1)

+ test('isalnum', 'A', 1)

+ test('isalnum', '\n', 0)

+ test('isalnum', '123abc456', 1)

+ test('isalnum', 'a1b3c', 1)

+ test('isalnum', 'aBc000 ', 0)

+ test('isalnum', 'abc\n', 0)

+

+ # join now works with any sequence type

+ test('join', ' ', 'a b c d', ['a', 'b', 'c', 'd'])

+ test('join', '', 'abcd', ('a', 'b', 'c', 'd'))

+ test('join', ' ', 'w x y z', Sequence())

+ test('join', 'a', 'abc', ('abc',))

+ test('join', 'a', 'z', UserList(['z']))

+ test('join', u'.', u'a.b.c', ['a', 'b', 'c'])

+ test('join', '.', u'a.b.c', [u'a', 'b', 'c'])

+ test('join', '.', u'a.b.c', ['a', u'b', 'c'])

+ test('join', '.', u'a.b.c', ['a', 'b', u'c'])

+ test('join', '.', TypeError, ['a', u'b', 3])

+ for i in [5, 25, 125]:

+ test('join', '-', ((('a' * i) + '-') * i)[:-1],

+ ['a' * i] * i)

+

+ test('join', ' ', TypeError, BadSeq1())

+ test('join', ' ', 'a b c', BadSeq2())

+

+ test('splitlines', "abc\ndef\n\rghi", ['abc', 'def', '', 'ghi'])

+ test('splitlines', "abc\ndef\n\r\nghi", ['abc', 'def', '', 'ghi'])

+ test('splitlines', "abc\ndef\r\nghi", ['abc', 'def', 'ghi'])

+ test('splitlines', "abc\ndef\r\nghi\n", ['abc', 'def', 'ghi'])

+ test('splitlines', "abc\ndef\r\nghi\n\r", ['abc', 'def', 'ghi', ''])

+ test('splitlines', "\nabc\ndef\r\nghi\n\r", ['', 'abc', 'def', 'ghi', ''])

+ test('splitlines', "\nabc\ndef\r\nghi\n\r", ['\n', 'abc\n', 'def\r\n', 'ghi\n', '\r'], 1)

+

+ test('split', 'this is the split function',

+ ['this', 'is', 'the', 'split', 'function'])

+ test('split', 'a|b|c|d', ['a', 'b', 'c', 'd'], '|')

+ test('split', 'a|b|c|d', ['a', 'b', 'c|d'], '|', 2)

+ test('split', 'a b c d', ['a', 'b c d'], None, 1)

+ test('split', 'a b c d', ['a', 'b', 'c d'], None, 2)

+ test('split', 'a b c d', ['a', 'b', 'c', 'd'], None, 3)

+ test('split', 'a b c d', ['a', 'b', 'c', 'd'], None, 4)

+ test('split', 'a b c d', ['a b c d'], None, 0)

+ test('split', 'a b c d', ['a', 'b', 'c d'], None, 2)

+ test('split', 'a b c d ', ['a', 'b', 'c', 'd'])

+

+ test('strip', ' hello ', 'hello')

+ test('lstrip', ' hello ', 'hello ')

+ test('rstrip', ' hello ', ' hello')

+ test('strip', 'hello', 'hello')

+

+ test('swapcase', 'HeLLo cOmpUteRs', 'hEllO CoMPuTErS')

+ test('translate', 'xyzabcdef', 'xyzxyz', transtable, 'def')

+

+ table = string.maketrans('a', 'A')

+ test('translate', 'abc', 'Abc', table)

+ test('translate', 'xyz', 'xyz', table)

+

+ test('replace', 'one!two!three!', 'one@two!three!', '!', '@', 1)

+ test('replace', 'one!two!three!', 'onetwothree', '!', '')

+ test('replace', 'one!two!three!', 'one@two@three!', '!', '@', 2)

+ test('replace', 'one!two!three!', 'one@two@three@', '!', '@', 3)

+ test('replace', 'one!two!three!', 'one@two@three@', '!', '@', 4)

+ test('replace', 'one!two!three!', 'one!two!three!', '!', '@', 0)

+ test('replace', 'one!two!three!', 'one@two@three@', '!', '@')

+ test('replace', 'one!two!three!', 'one!two!three!', 'x', '@')

+ test('replace', 'one!two!three!', 'one!two!three!', 'x', '@', 2)

+

+ test('startswith', 'hello', 1, 'he')

+ test('startswith', 'hello', 1, 'hello')

+ test('startswith', 'hello', 0, 'hello world')

+ test('startswith', 'hello', 1, '')

+ test('startswith', 'hello', 0, 'ello')

+ test('startswith', 'hello', 1, 'ello', 1)

+ test('startswith', 'hello', 1, 'o', 4)

+ test('startswith', 'hello', 0, 'o', 5)

+ test('startswith', 'hello', 1, '', 5)

+ test('startswith', 'hello', 0, 'lo', 6)

+ test('startswith', 'helloworld', 1, 'lowo', 3)

+ test('startswith', 'helloworld', 1, 'lowo', 3, 7)

+ test('startswith', 'helloworld', 0, 'lowo', 3, 6)

+

+ test('endswith', 'hello', 1, 'lo')

+ test('endswith', 'hello', 0, 'he')

+ test('endswith', 'hello', 1, '')

+ test('endswith', 'hello', 0, 'hello world')

+ test('endswith', 'helloworld', 0, 'worl')

+ test('endswith', 'helloworld', 1, 'worl', 3, 9)

+ test('endswith', 'helloworld', 1, 'world', 3, 12)

+ test('endswith', 'helloworld', 1, 'lowo', 1, 7)

+ test('endswith', 'helloworld', 1, 'lowo', 2, 7)

+ test('endswith', 'helloworld', 1, 'lowo', 3, 7)

+ test('endswith', 'helloworld', 0, 'lowo', 4, 7)

+ test('endswith', 'helloworld', 0, 'lowo', 3, 8)

+ test('endswith', 'ab', 0, 'ab', 0, 1)

+ test('endswith', 'ab', 0, 'ab', 0, 0)

+

+# Augmented assignment test.

+

+x = 2

+x += 1

+x *= 2

+x **= 2

+x -= 8

+x /= 2

+x %= 12

+x &= 2

+x |= 5

+x ^= 1

+

+print x

+

+x = [2]

+x[0] += 1

+x[0] *= 2

+x[0] **= 2

+x[0] -= 8

+x[0] /= 2

+x[0] %= 12

+x[0] &= 2

+x[0] |= 5

+x[0] ^= 1

+

+print x

+

+x = {0: 2}

+x[0] += 1

+x[0] *= 2

+x[0] **= 2

+x[0] -= 8

+x[0] /= 2

+x[0] %= 12

+x[0] &= 2

+x[0] |= 5

+x[0] ^= 1

+

+print x[0]

+

+x = [1,2]

+x += [3,4]

+x *= 2

+

+print x

+

+x = [1, 2, 3]

+y = x

+x[1:2] *= 2

+y[1:2] += [1]

+

+print x

+print x is y

+

+class aug_test:

+ def __init__(self, value):

+ self.val = value

+ def __radd__(self, val):

+ return self.val + val

+ def __add__(self, val):

+ return aug_test(self.val + val)

+

+

+class aug_test2(aug_test):

+ def __iadd__(self, val):

+ self.val = self.val + val

+ return self

+

+class aug_test3(aug_test):

+ def __iadd__(self, val):

+ return aug_test3(self.val + val)

+

+x = aug_test(1)

+y = x

+x += 10

+

+print isinstance(x, aug_test)

+print y is not x

+print x.val

+

+x = aug_test2(2)

+y = x

+x += 10

+

+print y is x

+print x.val

+

+x = aug_test3(3)

+y = x

+x += 10

+

+print isinstance(x, aug_test3)

+print y is not x

+print x.val

+

+class testall:

+

+ def __add__(self, val):

+ print "__add__ called"

+ def __radd__(self, val):

+ print "__radd__ called"

+ def __iadd__(self, val):

+ print "__iadd__ called"

+ return self

+

+ def __sub__(self, val):

+ print "__sub__ called"

+ def __rsub__(self, val):

+ print "__rsub__ called"

+ def __isub__(self, val):

+ print "__isub__ called"

+ return self

+

+ def __mul__(self, val):

+ print "__mul__ called"

+ def __rmul__(self, val):

+ print "__rmul__ called"

+ def __imul__(self, val):

+ print "__imul__ called"

+ return self

+

+ def __div__(self, val):

+ print "__div__ called"

+ def __rdiv__(self, val):

+ print "__rdiv__ called"

+ def __idiv__(self, val):

+ print "__idiv__ called"

+ return self

+

+ def __mod__(self, val):

+ print "__mod__ called"

+ def __rmod__(self, val):

+ print "__rmod__ called"

+ def __imod__(self, val):

+ print "__imod__ called"

+ return self

+

+ def __pow__(self, val):

+ print "__pow__ called"

+ def __rpow__(self, val):

+ print "__rpow__ called"

+ def __ipow__(self, val):

+ print "__ipow__ called"

+ return self

+

+ def __or__(self, val):

+ print "__or__ called"

+ def __ror__(self, val):

+ print "__ror__ called"

+ def __ior__(self, val):

+ print "__ior__ called"

+ return self

+

+ def __and__(self, val):

+ print "__and__ called"

+ def __rand__(self, val):

+ print "__rand__ called"

+ def __iand__(self, val):

+ print "__iand__ called"

+ return self

+

+ def __xor__(self, val):

+ print "__xor__ called"

+ def __rxor__(self, val):

+ print "__rxor__ called"

+ def __ixor__(self, val):

+ print "__ixor__ called"

+ return self

+

+ def __rshift__(self, val):

+ print "__rshift__ called"

+ def __rrshift__(self, val):

+ print "__rrshift__ called"

+ def __irshift__(self, val):

+ print "__irshift__ called"

+ return self

+

+ def __lshift__(self, val):

+ print "__lshift__ called"

+ def __rlshift__(self, val):

+ print "__rlshift__ called"

+ def __ilshift__(self, val):

+ print "__ilshift__ called"

+ return self

+

+x = testall()

+x + 1

+1 + x

+x += 1

+

+x - 1

+1 - x

+x -= 1

+

+x * 1

+1 * x

+x *= 1

+

+x / 1

+1 / x

+x /= 1

+

+x % 1

+1 % x

+x %= 1

+

+x ** 1

+1 ** x

+x **= 1

+

+x | 1

+1 | x

+x |= 1

+

+x & 1

+1 & x

+x &= 1

+

+x ^ 1

+1 ^ x

+x ^= 1

+

+x >> 1

+1 >> x

+x >>= 1

+

+x << 1

+1 << x

+x <<= 1

+