[Python-Dev] [Python-checkins] r88796 - in sandbox/trunk/pep362: pep362.py setup.py test_pep362.py tests (original) (raw)

Brett Cannon brett at python.org
Thu Mar 24 17:57:00 CET 2011

On Wed, Mar 23, 2011 at 21:38, Eric Snow <ericsnowcurrently at gmail.com>wrote:

Shouldn't the Signature class also support building from args and not just a function object? Then I could use a Signature object when building a function object, or vice versa. Having the ability to validate args/kwargs against a Signature object, sort of like provided by the bind method, will be helpful, particularly with the decorator use case.

I will probably try to add that functionality, but one thing at a time. =)

What does the tuple form of Parameter.name represent?

What tuple form? If you mean tuple parameters those no longer exist.

Did you come to any conclusion on the open issues in the PEP?

Nope. You are getting ahead of me. =)

-Brett

With the execclosure stuff I have been looking pretty closely at function-related C-API capability that might be worth exposing better in python, and Signature objects would help facilitate in a much clearer way. Not only that, but even though CPython won't use Signature objects behind the scenes, they can help to make the internal operations of Python more clear by exposing the underlying mechanisms in pure python. For example, with a validate method you could express how args and kwargs are mapped onto the different parts of the code object which correspond to the parts of the Signature object. I am looking forward to the inclusion of the function signature stuff in 3.3. -eric

On Wed, Mar 23, 2011 at 3:39 PM, brett.cannon <python-checkins at python.org>wrote: Author: brett.cannon Date: Wed Mar 23 22:39:32 2011 New Revision: 88796

Log: Update code for future inclusion in Python 3.3 (when I get around to it). Added: sandbox/trunk/pep362/testpep362.py - copied, changed from r88415, /sandbox/trunk/pep362/tests/testpep362.py Removed: sandbox/trunk/pep362/setup.py sandbox/trunk/pep362/tests/ Modified: sandbox/trunk/pep362/ (props changed) sandbox/trunk/pep362/pep362.py Modified: sandbox/trunk/pep362/pep362.py ============================================================================== --- sandbox/trunk/pep362/pep362.py (original) +++ sandbox/trunk/pep362/pep362.py Wed Mar 23 22:39:32 2011 @@ -8,7 +8,7 @@ pass

-class Parameter(object): +class Parameter: """Represent a parameter in a function signature. @@ -31,8 +31,9 @@ """ - def init(self, name, position, hasdefault=False, defaultvalue=None, - keywordonly=False, hasannotation=False, annotation=None): + def init(self, name, position, *, hasdefault=False, + default=None, keywordonly=False, hasannotation=False, + annotation=None): """Initialize a Parameter instance. For has* arguments, if they are False then the corresponding * @@ -42,13 +43,13 @@ self.name = name self.position = position if hasdefault: - self.defaultvalue = defaultvalue + self.default = default self.keywordonly = keywordonly if hasannotation: self.annotation = annotation -class Signature(object): +class Signature: """Object to represent the signature of a function/method. @@ -74,39 +75,19 @@ def init(self, func): """Initialize from a function or method object.""" - if hasattr(func, 'imfunc'): - func = func.imfunc - try: - funccode = func.code - except AttributeError: - # Compatibility for versions < 2.6._ _- funccode = func.funccode_ _-_ _+ funccode = func._code__ _self.name = func._name__ _-_ _- try:_ _- # Unneeded once 2.x support is removed; can easily get info_ _the_ _- # "hard" way._ _- argspec = inspect.getfullargspec(func)[:4]_ _- except AttributeError:_ _- # Needed only for tuple parameters._ _- argspec = inspect.getargspec(func)_ _+ # XXX replace with own implementation_ _+ argspec = inspect.getfullargspec(func)[:4]_ _parameters = {}_ _# Parameter information._ _poscount = funccode.coargcount_ _- if hasattr(funccode, 'cokwonlyargcount'):_ _- keywordonlycount = funccode.cokwonlyargcount_ _- else:_ _- keywordonlycount = 0_ _+ keywordonlycount = funccode.cokwonlyargcount_ _positional = argspec[0]_ _keywordonly = funccode.covarnames[poscount:_ _poscount+keywordonlycount]_ _- try:_ _- fxndefaults = func._defaults__ _- except AttributeError:_ _- # Deal with old names prior to 2.6._ _- fxndefaults = func.funcdefaults_ _+ fxndefaults = func._defaults__ _if fxndefaults:_ _posdefaultcount = len(fxndefaults)_ _else:_ _@@ -126,7 +107,7 @@_ _hasannotation, annotation = self.findannotation(func, name)_ _defaultvalue = fxndefaults[offset]_ _param = Parameter(name, offset+nondefaultcount,_ _- hasdefault=True,_ _defaultvalue=defaultvalue,_ _+ hasdefault=True, default=defaultvalue,_ _hasannotation=hasannotation,_ _annotation=annotation)_ _parameters[name] = param_ _@@ -134,16 +115,14 @@_ _for offset, name in enumerate(keywordonly):_ _hasannotation, annotation = self.findannotation(func, name)_ _hasdefault, defaultvalue = False, None_ _- # hasattr check only needed for versions < 2.6._ _- if (hasattr(func, '_kwdefaults_') and func._kwdefaults__ _and_ _- name in func._kwdefaults_):_ _+ if func._kwdefaults_ and name in func._kwdefaults_:_ _hasdefault = True_ _defaultvalue = func._kwdefaults_[name]_ _param = Parameter(name, offset+poscount, keywordonly=True,_ _- hasdefault=hasdefault,_ _- defaultvalue=defaultvalue,_ _- hasannotation=hasannotation,_ _- annotation=annotation)_ _+ hasdefault=hasdefault,_ _+ default=defaultvalue,_ _+ hasannotation=hasannotation,_ _+ annotation=annotation)_ _parameters[name] = param_ _# Variable parameters._ _index = poscount + keywordonlycount_ _@@ -172,9 +151,8 @@_ _self.parameters = parameters_ _# Return annotation._ _- if hasattr(func, '_annotations_'):_ _- if 'return' in func._annotations_:_ _- self.returnannotation = func._annotations_['return']_ _+ if 'return' in func._annotations_:_ _+ self.returnannotation = func._annotations_['return']_ _def _getitem_(self, key):_ _return self.parameters[key]_ _@@ -186,10 +164,9 @@_ _"""Return True if an annotation exists for the named parameter_ _along_ _with its annotation, else return False and None."""_ _hasannotation, annotation = False, None_ _- if hasattr(func, '_annotations_'):_ _- if name in func._annotations_:_ _- hasannotation = True_ _- annotation = func._annotations_[name]_ _+ if name in func._annotations_:_ _+ hasannotation = True_ _+ annotation = func._annotations_[name]_ _return hasannotation, annotation_ _def convertname(self, name):_ _@@ -234,7 +211,7 @@_ _break_ _else:_ _raise BindError("too many positional arguments")_ _- self.tuplebind(bindings, param.name, positionarg)_ _+ bindings[param.name] = positionarg_ _args = args[1:]_ _# Keyword arguments & default values._ _else:_ _@@ -247,9 +224,8 @@_ _except KeyError:_ _raise BindError("%r unbound" % paramname)_ _else:_ _- if hasattr(positionalparam, 'defaultvalue'):_ _- self.tuplebind(bindings, paramname,_ _-_ _positionalparam.defaultvalue)_ _+ if hasattr(positionalparam, 'default'):_ _+ bindings[paramname] = positionalparam.default_ _else:_ _raise BindError("%r parameter lacking default_ _value" %_ _paramname)_ _@@ -276,39 +252,14 @@_ _# Keyword-only default values._ _else:_ _for name, param in keywordonly.items():_ _- if hasattr(param, 'defaultvalue'):_ _- bindings[name] = param.defaultvalue_ _+ if hasattr(param, 'default'):_ _+ bindings[name] = param.default_ _else:_ _raise BindError("%s parameter lacking a default value"_ _%_ _name)_ _return bindings_ _- def tuplebind(self, bindings, possibletuple, value):_ _- """Where a tuple could be a parameter, handle binding the values_ _to the_ _- tuple and storing into the bindings mapping."""_ _- if not isinstance(possibletuple, tuple):_ _- bindings[possibletuple] = value_ _- else:_ _- # Need to make sure that value is as long as the parameter,_ _but not_ _- # vice-versa._ _- errormsg = "not enough values to unpack for %r"_ _- tupleiter = iter(possibletuple)_ _- try:_ _- valueiter = iter(value)_ _- except TypeError:_ _- raise BindError(errormsg % possibletuple)_ _- while True:_ _- try:_ _- subparam = tupleiter.next()_ _- except StopIteration:_ _- break_ _- try:_ _- subvalue = valueiter.next()_ _- except StopIteration:_ _- raise BindError(errormsg % possibletuple)_ _- self.tuplebind(bindings, subparam, subvalue)_ _-_ _def signature(func):_ _"""Return a Signature object for the function or method._ _@@ -318,15 +269,9 @@_ _attribute if possible (but is not required)._ _"""_ _- if hasattr(func, 'imfunc'):_ _- func = func.imfunc_ _- sig = Signature(func)_ _- if not hasattr(func, '_signature_'):_ _- try:_ _- func._signature_ = sig_ _- except AttributeError:_ _- pass_ _- else:_ _- sig = func._signature__ _-_ _- return sig_ _+ try:_ _+ return func._signature__ _+ except AttributeError:_ _+ sig = Signature(func)_ _+ func._signature_ = sig_ _+ return sig_ _Deleted: sandbox/trunk/pep362/setup.py_ _==============================================================================_ _--- sandbox/trunk/pep362/setup.py Wed Mar 23 22:39:32 2011_ _+++ (empty file)_ _@@ -1,25 +0,0 @@_ _-from distutils.core import setup_ _-_ _-setup(_ _- # Package metadata._ _- name='pep362',_ _- version='0.6.2',_ _- description='Implementation of PEP 362 (Function Signature_ _objects)',_ _- author='Brett Cannon',_ _- authoremail='brett at python.org',_ _- url='http://svn.python.org/view/sandbox/trunk/pep362/',_ _- # Files._ _- pymodules=['pep362', 'examples'],_ _- packages=['tests'],_ _- datafiles=['README'],_ _- classifiers=[_ _- 'Programming Language :: Python :: 2',_ _- 'Programming Language :: Python :: 2.5',_ _- 'Programming Language :: Python :: 2.6',_ _- 'Programming Language :: Python :: 2.7',_ _- 'Programming Language :: Python :: 3',_ _- 'Programming Language :: Python :: 3.0',_ _- 'Programming Language :: Python :: 3.1',_ _- 'Programming Language :: Python :: 3.2',_ _- ]_ _- )_ _Copied: sandbox/trunk/pep362/testpep362.py (from r88415,_ _/sandbox/trunk/pep362/tests/testpep362.py)_ _==============================================================================_ _--- /sandbox/trunk/pep362/tests/testpep362.py (original)_ _+++ sandbox/trunk/pep362/testpep362.py Wed Mar 23 22:39:32 2011_ _@@ -1,23 +1,49 @@_ _import pep362_ _import unittest_ _-from tests import pep362fodder_ _-try:_ _- from tests import pep362py2fodder_ _- from test import testsupport_ _-except SyntaxError:_ _- from tests import pep362py3kfodder_ _- from test import support as testsupport_ _+from test import support as testsupport_ _from sys import versioninfo_ _-def versionspecific(majornumber):_ _- def inner(fxn):_ _- if versioninfo[0] == majornumber:_ _- return fxn_ _- else:_ _- return lambda self: self_ _- return inner_ _+def noargs():_ _+ pass_ _+_ _+def varargs(*args):_ _+ pass_ _+_ _+def varkwargs(**kwargs):_ _+ pass_ _+_ _+def nodefaultargs(a):_ _+ pass_ _+_ _+def defaultargs(a=42):_ _+ pass_ _+_ _+def keywordonly(*, a):_ _+ pass_ _+_ _+def keywordonlydefault(*, a=42):_ _+ pass_ _+_ _+def argannotation(a:int):_ _+ pass_ _+_ _+def argannotationdefault(a:int=42):_ _+ pass_ _+_ _+def argannotationvar(*args:int, **kwargs:str):_ _+ pass_ _+_ _+def argannotationkeywordonly(*, a:int):_ _+ pass_ _+_ _+def returnannotation() -> int: + pass + +def allargs(a:int, d=0, *args:int, + g:int, h:int=8, **kwargs:int) -> int: + return a, d, g, h, args, kwargs class ParameterObjectTests(unittest.TestCase): @@ -41,13 +67,14 @@ self.assertEqual(param.position, pos) def testdefaultvalues(self): - # Testing that 'defaultvalue' is not set is handled in the testing of + # Testing that 'default' is not set is handled in the testing of # that attribute. defaultvalue = 42 - param = pep362.Parameter('', 0, True, defaultvalue) - self.assertEqual(param.defaultvalue, defaultvalue) - param = pep362.Parameter('', 0, False) - self.assertTrue(not hasattr(param, 'defaultvalue')) + param = pep362.Parameter('', 0, hasdefault=True, + default=defaultvalue) + self.assertEqual(param.default, defaultvalue) + param = pep362.Parameter('', 0, hasdefault=False) + self.assertTrue(not hasattr(param, 'default')) def testkeywordonly(self): # Setting the value for keywordonly should create an attribute. @@ -70,21 +97,21 @@ def testgetitem(self): # getitem() should return the Parameter object for the name # parameter. - sig = pep362.Signature(pep362fodder.defaultargs) + sig = pep362.Signature(defaultargs) self.assertTrue(sig['a']) param = sig['a'] self.assertTrue(param.name, 'a') def testiter(self): # The iterator should return all Parameter objects in the proper order. - sig = pep362.Signature(pep362fodder.defaultargs) + sig = pep362.Signature(defaultargs) params = list(sig) self.assertEqual(len(params), 1) self.assertEqual(params[0].name, 'a') def testnoargs(self): # Test a function with no arguments. - sig = pep362.Signature(pep362fodder.noargs) + sig = pep362.Signature(noargs) self.assertEqual('noargs', sig.name) self.assertTrue(not sig.varargs) self.assertTrue(not sig.varkwargs) @@ -92,115 +119,87 @@ def testvarargs(self): # Test the varargs attribute. - sig = pep362.Signature(pep362fodder.varargs) + sig = pep362.Signature(varargs) self.assertEqual('args', sig.varargs) self.assertEqual(0, len(list(sig))) - sig = pep362.Signature(pep362fodder.noargs) + sig = pep362.Signature(noargs) self.assertEqual('', sig.varargs) def testvarkwargs(self): # Test the varkwargs attribute and annotations. - sig = pep362.Signature(pep362fodder.varkwargs) + sig = pep362.Signature(varkwargs) self.assertEqual('varkwargs', sig.name) self.assertEqual('kwargs', sig.varkwargs) self.assertEqual(0, len(list(sig))) - sig = pep362.Signature(pep362fodder.noargs) + sig = pep362.Signature(noargs) self.assertEqual('', sig.varkwargs) def testparameterpositional(self): # A function with positional arguments should work. - sig = pep362.Signature(pep362fodder.nodefaultargs) + sig = pep362.Signature(nodefaultargs) self.assertEqual('nodefaultargs', sig.name) param = sig['a'] self.assertEqual('a', param.name) self.assertEqual(0, param.position) - self.assertTrue(not hasattr(param, 'defaultvalue')) + self.assertTrue(not hasattr(param, 'default')) def testparameterdefault(self): # Default parameters for a function should work. - sig = pep362.Signature(pep362fodder.defaultargs) + sig = pep362.Signature(defaultargs) self.assertEqual('defaultargs', sig.name) param = sig['a'] self.assertEqual('a', param.name) self.assertEqual(0, param.position) - self.assertEqual(42, param.defaultvalue) - - @versionspecific(2) - def testparametertuple(self): - # A function with a tuple as a parameter should work. - sig = pep362.Signature(pep362py2fodder.tupleargs) - self.assertEqual('tupleargs', sig.name) - param = list(sig)[0] - self.assertTrue(isinstance(param.name, tuple)) - self.assertEqual(('a', ('b',)), param.name) - self.assertEqual(0, param.position) - self.assertTrue(not hasattr(param, 'defaultvalue')) + self.assertEqual(42, param.default) - @versionspecific(2) - def testparametertupledefault(self): - # A default argument for a tuple parameter needs to work. - sig = pep362.Signature(pep362py2fodder.defaulttupleargs) - self.assertEqual('defaulttupleargs', sig.name) - param = list(sig)[0] - self.assertEqual(('a', ('b',)), param.name) - self.assertEqual(0, param.position) - self.assertEqual((1, (2,)), param.defaultvalue) - - @versionspecific(3) def testkeywordonly(self): # Is a function containing keyword-only parameters handled properly? - sig = pep362.Signature(pep362py3kfodder.keywordonly) + sig = pep362.Signature(keywordonly) param = sig['a'] self.assertEqual(param.name, 'a') self.assertTrue(param.keywordonly) self.assertEqual(param.position, 0) - @versionspecific(3) def testkeywordonlydefault(self): # Default arguments can work for keyword-only parameters. - sig = pep362.Signature(pep362py3kfodder.keywordonlydefault) + sig = pep362.Signature(keywordonlydefault) param = sig['a'] self.assertEqual(param.name, 'a') self.assertTrue(param.keywordonly) self.assertEqual(param.position, 0) - self.assertEqual(param.defaultvalue, 42) + self.assertEqual(param.default, 42) - @versionspecific(3) def testannotations(self): # Make sure the proper annotation is found. - sig = pep362.Signature(pep362py3kfodder.argannotation) + sig = pep362.Signature(argannotation) param = sig['a'] self.assertEqual(param.name, 'a') self.assertEqual(param.annotation, int) - @versionspecific(3) def testannotationsdefault(self): # Annotations with a default value should work. - sig = pep362.Signature(pep362py3kfodder.argannotationdefault) + sig = pep362.Signature(argannotationdefault) param = sig['a'] self.assertEqual(param.name, 'a') self.assertEqual(param.annotation, int) - self.assertEqual(param.defaultvalue, 42) + self.assertEqual(param.default, 42) - @versionspecific(3) def testannotationkeywordonly(self): # Keyword-only parameters can have an annotation. - sig = pep362.Signature(pep362py3kfodder.argannotationkeywordonly) + sig = pep362.Signature(argannotationkeywordonly) param = sig['a'] self.assertEqual(param.name, 'a') self.assertEqual(param.annotation, int) self.assertTrue(param.keywordonly) - @versionspecific(3) def testreturnannotation(self): # The return value annotation. - sig = pep362.Signature(pep362py3kfodder.returnannotation) + sig = pep362.Signature(returnannotation) self.assertEqual(sig.returnannotation, int) - @versionspecific(3) def testvarannotations(self): # Annotation on variable arguments (*args & **kwargs). - sig = pep362.Signature(pep362py3kfodder.argannotationvar) + sig = pep362.Signature(argannotationvar) self.assertEqual(sig.varannotations[sig.varargs], int) self.assertEqual(sig.varannotations[sig.varkwargs], str) @@ -224,14 +223,14 @@ """Test Signature.bind().""" def testnoparameters(self): - sig = pep362.Signature(pep362fodder.noargs) + sig = pep362.Signature(noargs) binding = sig.bind() self.assertEqual({}, binding) self.assertRaises(pep362.BindError, sig.bind, 42) self.assertRaises(pep362.BindError, sig.bind, a=0) def testvarparameters(self): - sig = pep362.Signature(pep362fodder.varargs) + sig = pep362.Signature(varargs) binding = sig.bind(0, 1, 2) self.assertEqual({'args':(0, 1, 2)}, binding) binding = sig.bind() @@ -239,7 +238,7 @@ self.assertRaises(pep362.BindError, sig.bind, a=0) def testvarkwparameters(self): - sig = pep362.Signature(pep362fodder.varkwargs) + sig = pep362.Signature(varkwargs) binding = sig.bind(a=0) self.assertEqual({'kwargs':{'a':0}}, binding) binding = sig.bind() @@ -247,7 +246,7 @@ self.assertRaises(pep362.BindError, sig.bind, 42) def testpositionalparameters(self): - sig = pep362.Signature(pep362fodder.nodefaultargs) + sig = pep362.Signature(nodefaultargs) binding = sig.bind(42) self.assertEqual({'a':42}, binding) binding = sig.bind(a=42) @@ -257,7 +256,7 @@ self.assertRaises(pep362.BindError, sig.bind, b=0) def testkeywordparameters(self): - sig = pep362.Signature(pep362fodder.defaultargs) + sig = pep362.Signature(defaultargs) binding = sig.bind() self.assertEqual({'a':42}, binding) binding = sig.bind(0) @@ -268,73 +267,24 @@ self.assertRaises(pep362.BindError, sig.bind, a=0, b=1) self.assertRaises(pep362.BindError, sig.bind, b=1) - @versionspecific(2) - def testtupleparameter(self): - sig = pep362.Signature(pep362py2fodder.tupleargs) - arg = (1, ((2,),)) - binding = sig.bind(arg) - self.assertEqual({'a':1, 'b':(2,)}, binding) - self.assertRaises(pep362.BindError, sig.bind, (1,2,3)) - self.assertRaises(pep362.BindError, sig.bind, (1, 2)) - - @versionspecific(2) - def testdefaulttupleparameter(self): - sig = pep362.Signature(pep362py2fodder.defaulttupleargs) - binding = sig.bind() - self.assertEqual({'a':1, 'b':2}, binding) - arg = (0, (1,)) - binding = sig.bind(arg) - self.assertEqual({'a':0, 'b':1}, binding) - - @versionspecific(2) - def testpy2allargs(self): - sig = pep362.Signature(pep362py2fodder.allargs) - # a, (b, (c,)), d=0, (e, (f,))=(4, (5,)), *g, **h - # name, position, hasdefault, default value - expect = (('a', 0, False, None), - (('b', ('c',)), 1, False, None), - ('d', 2, True, 0), - (('e', ('f',)), 3, True, (4, (5,)))) - self.assertEqual(len(list(sig)), len(expect)) - for param, check in zip(list(sig), expect): - name, pos, hasdefault, defaultvalue = check - self.assertEqual(param.name, name) - self.assertEqual(param.position, pos) - if hasdefault: - self.assertEqual(param.defaultvalue, defaultvalue) - else: - self.assertTrue(not hasattr(param, 'defaultvalue')) - self.assertTrue(not param.keywordonly) - self.assertTrue(not hasattr(param, 'annotation')) - self.assertEqual(sig.varargs, 'g') - self.assertEqual(sig.varkwargs, 'h') - self.assertEqual(len(sig.varannotations), 0) - binding = sig.bind(0, (1, (2,)), d=3, i=7) - expected = {'a':0, 'b':1, 'c':2, 'd':3, 'e':4, 'f':5, 'g':tuple(), - 'h':{'i':7}} - self.assertEqual(expected, binding) - - @versionspecific(3) def testkeywordonly(self): - sig = pep362.Signature(pep362py3kfodder.keywordonly) + sig = pep362.Signature(keywordonly) binding = sig.bind(a=42) self.assertEqual(binding, {'a':42}) self.assertRaises(pep362.BindError, sig.bind) self.assertRaises(pep362.BindError, sig.bind, 42) - @versionspecific(3) def testkeywordonlydefault(self): - sig = pep362.Signature(pep362py3kfodder.keywordonlydefault) + sig = pep362.Signature(keywordonlydefault) binding = sig.bind() self.assertEqual(binding, {'a':42}) binding = sig.bind(a=1) self.assertEqual(binding, {'a':1}) self.assertRaises(pep362.BindError, sig.bind, 1) - @versionspecific(3) def testallpy3kargs(self): # a:int, d=0, *args:int, g:int, h:int=8, **kwargs:int) -> int - sig = pep362.Signature(pep362py3kfodder.allargs) + sig = pep362.Signature(allargs) # name, position, kw only, hasdefault, default, has anno, anno expected = (('a', 0, False, False, None, True, int), ('d', 1, False, True, 0, False, None), @@ -353,9 +303,9 @@ else: self.assertTrue(not param.keywordonly) if hasdefault: - self.assertEqual(param.defaultvalue, default) + self.assertEqual(param.default, default) else: - self.assertTrue(not hasattr(param, 'defaultvalue')) + self.assertTrue(not hasattr(param, 'default')) if hasanno: self.assertEqual(param.annotation, anno) else: @@ -373,7 +323,7 @@ def testtoomanyarguments(self): # Only one argument should pair up with a parameter. - sig = pep362.Signature(pep362fodder.nodefaultargs) + sig = pep362.Signature(nodefaultargs) self.assertRaises(pep362.BindError, sig.bind, 1, a=1)

Python-checkins mailing list Python-checkins at python.org http://mail.python.org/mailman/listinfo/python-checkins

Python-Dev mailing list Python-Dev at python.org http://mail.python.org/mailman/listinfo/python-dev Unsubscribe: http://mail.python.org/mailman/options/python-dev/brett%40python.org -------------- next part -------------- An HTML attachment was scrubbed... URL: <http://mail.python.org/pipermail/python-dev/attachments/20110324/b3a1d328/attachment-0001.html>

More information about the Python-Dev mailing list