diff -r 7c9327ff5de6 Lib/hmac.py --- a/Lib/hmac.py Sat Dec 15 22:36:49 2012 +0100 +++ b/Lib/hmac.py Sun Dec 16 01:24:10 2012 -0600 @@ -4,7 +4,7 @@ """ import warnings as _warnings -from operator import _compare_digest as compare_digest +from _operator import _compare_digest as compare_digest trans_5C = bytes((x ^ 0x5C) for x in range(256)) trans_36 = bytes((x ^ 0x36) for x in range(256)) diff -r 7c9327ff5de6 Lib/operator.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Lib/operator.py Sun Dec 16 01:24:10 2012 -0600 @@ -0,0 +1,356 @@ +#!/usr/bin/env python3 +""" +Operator Interface + +This module exports a set of functions corresponding to the intrinsic +operators of Python. For example, operator.add(x, y) is equivalent +to the expression x+y. The function names are those used for special +methods; variants without leading and trailing '__' are also provided +for convenience. + +This is the pure Python implementation of the module. +""" + +import builtins as _bi + +def lt(a, b): + "Same as a < b." + return a < b +__lt__ = lt + +def le(a, b): + "Same as a <= b." + return a <= b +__le__ = le + +def eq(a, b): + "Same as a == b." + return a == b +__eq__ = eq + +def ne(a, b): + "Same as a != b." + return a != b +__ne__ = ne + +def ge(a, b): + "Same as a >= b." + return a >= b +__ge__ = ge + +def gt(a, b): + "Same as a > b." + return a > b +__gt__ = gt + +def not_(a): + "Same as not a." + return not a +__not__ = not_ + +def truth(a): + "Return True if a is true, False otherwise." + return _bi.bool(a) + +def is_(a, b): + "Same as a is b." + return a is b + +def is_not(a, b): + "Same as a is not b." + return a is not b + +def abs(a): + "Same as abs(a)." + return _bi.abs(a) +__abs__ = abs + +def add(a, b): + "Same as a + b." + return a + b +__add__ = add + +def and_(a, b): + "Same as a & b." + return a & b +__and__ = and_ + +def floordiv(a, b): + "Same as a // b." + return a // b +__floordiv__ = floordiv + +def index(a): + "Same as a.__index__()." + return a.__index__() +__index__ = index + +def inv(a): + "Same as ~a." + return ~a +invert = __inv__ = __invert__ = inv + +def lshift(a, b): + "Same as a << b." + return a << b +__lshift__ = lshift + +def mod(a, b): + "Same as a % b." + return a % b +__mod__ = mod + +def mul(a, b): + "Same as a * b." + return a * b +__mul__ = mul + +def neg(a): + "Same as -a." + return -a +__neg__ = neg + +def or_(a, b): + "Same as a | b." + return a | b +__or__ = or_ + +def pos(a): + "Same as +a." + return +a +__pos__ = pos + +def pow(a, b): + "Same as a ** b." + return a ** b +__pow__ = pow + +def rshift(a, b): + "Same as a >> b." + return a >> b +__rshift__ = rshift + +def sub(a, b): + "Same as a - b." + return a - b +__sub__ = sub + +def truediv(a, b): + "Same as a / b." + return a / b +__truediv__ = truediv + +def xor(a, b): + "Same as a ^ b." + return a ^ b +__xor__ = xor + +def concat(a, b): + "Same as a + b, for a and b sequences." + if not (hasattr(a, '__getitem__') and hasattr(b, '__getitem__')): + raise TypeError('a and b must be sequences') + return a + b +__concat__ = concat + +def contains(a, b): + "Same as b in a (note reversed operands)." + return b in a +__contains__ = contains + +def countOf(a, b): + "Return the number of times b occurs in a." + count = 0 + for i in a: + if i == b: + count += 1 + return count + +def delitem(a, b): + "Same as del a[b]." + del a[b] +__delitem__ = delitem + +def getitem(a, b): + "Same as a[b]." + return a[b] +__getitem__ = getitem + +def indexOf(a, b): + "Return the first index of b in a." + for i, j in _bi.enumerate(a): + if j == b: + return i + else: + raise ValueError('b not found in a') + +def setitem(a, b, c): + "Same as a[b] = c." + a[b] = c +__setitem__ = setitem + +class attrgetter: + """ + Return a callable object that fetches the given attribute(s) from its operand. + After f=attrgetter('name'), the call f(r) returns r.name. + After g=attrgetter('name', 'date'), the call g(r) returns (r.name, r.date). + After h=attrgetter('name.first', 'name.last'), the call h(r) returns + (r.name.first, r.name.last). + """ + def __init__(self, attr, *attrs): + self._attrs = (attr,) + self._attrs += attrs + if any(not isinstance(attr, str) for attr in self._attrs): + raise TypeError('attribute name must be a string') + + @staticmethod + def _resolve_attr(obj, attr): + for name in attr.split('.'): + obj = _bi.getattr(obj, name) + return obj + + def __call__(self, obj): + if len(self._attrs) == 1: + return self._resolve_attr(obj, self._attrs[0]) + return tuple(self._resolve_attr(obj, attr) for attr in self._attrs) + +class itemgetter: + """ + Return a callable object that fetches the given item(s) from its operand. + After f=itemgetter(2), the call f(r) returns r[2]. + After g=itemgetter(2,5,3), the call g(r) returns (r[2], r[5], r[3]) + """ + def __init__(self, item, *items): + self._items = (item,) + self._items += items + + def __call__(self, obj): + if len(self._items) == 1: + return obj[self._items[0]] + return tuple(obj[item] for item in self._items) + +class methodcaller: + """ + Return a callable object that calls the given method on its operand. + After f = methodcaller('name'), the call f(r) returns r.name(). + After g = methodcaller('name', 'date', foo=1), the call g(r) returns + r.name('date', foo=1). + """ + + def __init__(self, name, *args, **kwargs): + self._name = name + self._args = args + self._kwargs = kwargs + + def __call__(self, obj): + return getattr(obj, self._name)(*self._args, **self._kwargs) + + +def iadd(a, b): + "Same as a += b." + a += b + return a +__iadd__ = iadd + +def iand(a, b): + "Same as a &= b." + a &= b + return a +__iand__ = iand + +def iconcat(a, b): + "Same as a += b, for a and b sequences." + if not (hasattr(a, '__getitem__') and hasattr(b, '__getitem__')): + raise TypeError('a and b must be sequences') + a += b + return a +__iconcat__ = iconcat + +def ifloordiv(a, b): + "Same as a //= b." + a //= b + return a +__ifloordiv__ = ifloordiv + +def ilshift(a, b): + "Same as a <<= b." + a <<= b + return a +__ilshift__ = ilshift + +def imod(a, b): + "Same as a %= b." + a %= b + return a +__imod__ = imod + +def imul(a, b): + "Same as a *= b." + a *= b + return a +__imul__ = imul + +def ior(a, b): + "Same as a |= b." + a |= b + return a +__ior__ = ior + +def ipow(a, b): + "Same as a **= b." + a **=b + return a +__ipow__ = ipow + +def irshift(a, b): + "Same as a >>= b." + a >>= b + return a +__irshift__ = irshift + +def isub(a, b): + "Same as a -= b." + a -= b + return a +__isub__ = isub + +def itruediv(a, b): + "Same as a /= b." + a /= b + return a +__itruediv__ = itruediv + +def ixor(a, b): + "Same as a ^= b." + a ^= b + return a +__ixor__ = ixor + +def length_hint(obj, default=0): + """ + Return an estimate of the number of items in obj. + This is useful for presizing containers when building from an iterable. + + If the object supports len(), the result will be exact. Otherwise, it may + over- or under-estimate by an arbitrary amount. The result will be an + integer >= 0. + """ + try: + return len(obj) + except TypeError: + try: + val = obj.__length_hint__() + if val is NotImplemented: + raise TypeError + except (AttributeError, TypeError): + return default + else: + if not val > 0: + raise ValueError('default must be > 0') + return val + + +try: + from _operator import * + from _operator import __doc__ +except ImportError: + pass diff -r 7c9327ff5de6 Lib/test/test_operator.py --- a/Lib/test/test_operator.py Sat Dec 15 22:36:49 2012 +0100 +++ b/Lib/test/test_operator.py Sun Dec 16 01:24:10 2012 -0600 @@ -1,8 +1,10 @@ -import operator import unittest from test import support +py_operator = support.import_fresh_module('operator', blocked=['_operator']) +c_operator = support.import_fresh_module('operator', fresh=['_operator']) + class Seq1: def __init__(self, lst): self.lst = lst @@ -33,338 +35,340 @@ class OperatorTestCase(unittest.TestCase): + module = None + def test_lt(self): - self.assertRaises(TypeError, operator.lt) - self.assertRaises(TypeError, operator.lt, 1j, 2j) - self.assertFalse(operator.lt(1, 0)) - self.assertFalse(operator.lt(1, 0.0)) - self.assertFalse(operator.lt(1, 1)) - self.assertFalse(operator.lt(1, 1.0)) - self.assertTrue(operator.lt(1, 2)) - self.assertTrue(operator.lt(1, 2.0)) + self.assertRaises(TypeError, self.module.lt) + self.assertRaises(TypeError, self.module.lt, 1j, 2j) + self.assertFalse(self.module.lt(1, 0)) + self.assertFalse(self.module.lt(1, 0.0)) + self.assertFalse(self.module.lt(1, 1)) + self.assertFalse(self.module.lt(1, 1.0)) + self.assertTrue(self.module.lt(1, 2)) + self.assertTrue(self.module.lt(1, 2.0)) def test_le(self): - self.assertRaises(TypeError, operator.le) - self.assertRaises(TypeError, operator.le, 1j, 2j) - self.assertFalse(operator.le(1, 0)) - self.assertFalse(operator.le(1, 0.0)) - self.assertTrue(operator.le(1, 1)) - self.assertTrue(operator.le(1, 1.0)) - self.assertTrue(operator.le(1, 2)) - self.assertTrue(operator.le(1, 2.0)) + self.assertRaises(TypeError, self.module.le) + self.assertRaises(TypeError, self.module.le, 1j, 2j) + self.assertFalse(self.module.le(1, 0)) + self.assertFalse(self.module.le(1, 0.0)) + self.assertTrue(self.module.le(1, 1)) + self.assertTrue(self.module.le(1, 1.0)) + self.assertTrue(self.module.le(1, 2)) + self.assertTrue(self.module.le(1, 2.0)) def test_eq(self): class C(object): def __eq__(self, other): raise SyntaxError - self.assertRaises(TypeError, operator.eq) - self.assertRaises(SyntaxError, operator.eq, C(), C()) - self.assertFalse(operator.eq(1, 0)) - self.assertFalse(operator.eq(1, 0.0)) - self.assertTrue(operator.eq(1, 1)) - self.assertTrue(operator.eq(1, 1.0)) - self.assertFalse(operator.eq(1, 2)) - self.assertFalse(operator.eq(1, 2.0)) + self.assertRaises(TypeError, self.module.eq) + self.assertRaises(SyntaxError, self.module.eq, C(), C()) + self.assertFalse(self.module.eq(1, 0)) + self.assertFalse(self.module.eq(1, 0.0)) + self.assertTrue(self.module.eq(1, 1)) + self.assertTrue(self.module.eq(1, 1.0)) + self.assertFalse(self.module.eq(1, 2)) + self.assertFalse(self.module.eq(1, 2.0)) def test_ne(self): class C(object): def __ne__(self, other): raise SyntaxError - self.assertRaises(TypeError, operator.ne) - self.assertRaises(SyntaxError, operator.ne, C(), C()) - self.assertTrue(operator.ne(1, 0)) - self.assertTrue(operator.ne(1, 0.0)) - self.assertFalse(operator.ne(1, 1)) - self.assertFalse(operator.ne(1, 1.0)) - self.assertTrue(operator.ne(1, 2)) - self.assertTrue(operator.ne(1, 2.0)) + self.assertRaises(TypeError, self.module.ne) + self.assertRaises(SyntaxError, self.module.ne, C(), C()) + self.assertTrue(self.module.ne(1, 0)) + self.assertTrue(self.module.ne(1, 0.0)) + self.assertFalse(self.module.ne(1, 1)) + self.assertFalse(self.module.ne(1, 1.0)) + self.assertTrue(self.module.ne(1, 2)) + self.assertTrue(self.module.ne(1, 2.0)) def test_ge(self): - self.assertRaises(TypeError, operator.ge) - self.assertRaises(TypeError, operator.ge, 1j, 2j) - self.assertTrue(operator.ge(1, 0)) - self.assertTrue(operator.ge(1, 0.0)) - self.assertTrue(operator.ge(1, 1)) - self.assertTrue(operator.ge(1, 1.0)) - self.assertFalse(operator.ge(1, 2)) - self.assertFalse(operator.ge(1, 2.0)) + self.assertRaises(TypeError, self.module.ge) + self.assertRaises(TypeError, self.module.ge, 1j, 2j) + self.assertTrue(self.module.ge(1, 0)) + self.assertTrue(self.module.ge(1, 0.0)) + self.assertTrue(self.module.ge(1, 1)) + self.assertTrue(self.module.ge(1, 1.0)) + self.assertFalse(self.module.ge(1, 2)) + self.assertFalse(self.module.ge(1, 2.0)) def test_gt(self): - self.assertRaises(TypeError, operator.gt) - self.assertRaises(TypeError, operator.gt, 1j, 2j) - self.assertTrue(operator.gt(1, 0)) - self.assertTrue(operator.gt(1, 0.0)) - self.assertFalse(operator.gt(1, 1)) - self.assertFalse(operator.gt(1, 1.0)) - self.assertFalse(operator.gt(1, 2)) - self.assertFalse(operator.gt(1, 2.0)) + self.assertRaises(TypeError, self.module.gt) + self.assertRaises(TypeError, self.module.gt, 1j, 2j) + self.assertTrue(self.module.gt(1, 0)) + self.assertTrue(self.module.gt(1, 0.0)) + self.assertFalse(self.module.gt(1, 1)) + self.assertFalse(self.module.gt(1, 1.0)) + self.assertFalse(self.module.gt(1, 2)) + self.assertFalse(self.module.gt(1, 2.0)) def test_abs(self): - self.assertRaises(TypeError, operator.abs) - self.assertRaises(TypeError, operator.abs, None) - self.assertEqual(operator.abs(-1), 1) - self.assertEqual(operator.abs(1), 1) + self.assertRaises(TypeError, self.module.abs) + self.assertRaises(TypeError, self.module.abs, None) + self.assertEqual(self.module.abs(-1), 1) + self.assertEqual(self.module.abs(1), 1) def test_add(self): - self.assertRaises(TypeError, operator.add) - self.assertRaises(TypeError, operator.add, None, None) - self.assertTrue(operator.add(3, 4) == 7) + self.assertRaises(TypeError, self.module.add) + self.assertRaises(TypeError, self.module.add, None, None) + self.assertTrue(self.module.add(3, 4) == 7) def test_bitwise_and(self): - self.assertRaises(TypeError, operator.and_) - self.assertRaises(TypeError, operator.and_, None, None) - self.assertTrue(operator.and_(0xf, 0xa) == 0xa) + self.assertRaises(TypeError, self.module.and_) + self.assertRaises(TypeError, self.module.and_, None, None) + self.assertTrue(self.module.and_(0xf, 0xa) == 0xa) def test_concat(self): - self.assertRaises(TypeError, operator.concat) - self.assertRaises(TypeError, operator.concat, None, None) - self.assertTrue(operator.concat('py', 'thon') == 'python') - self.assertTrue(operator.concat([1, 2], [3, 4]) == [1, 2, 3, 4]) - self.assertTrue(operator.concat(Seq1([5, 6]), Seq1([7])) == [5, 6, 7]) - self.assertTrue(operator.concat(Seq2([5, 6]), Seq2([7])) == [5, 6, 7]) - self.assertRaises(TypeError, operator.concat, 13, 29) + self.assertRaises(TypeError, self.module.concat) + self.assertRaises(TypeError, self.module.concat, None, None) + self.assertTrue(self.module.concat('py', 'thon') == 'python') + self.assertTrue(self.module.concat([1, 2], [3, 4]) == [1, 2, 3, 4]) + self.assertTrue(self.module.concat(Seq1([5, 6]), Seq1([7])) == [5, 6, 7]) + self.assertTrue(self.module.concat(Seq2([5, 6]), Seq2([7])) == [5, 6, 7]) + self.assertRaises(TypeError, self.module.concat, 13, 29) def test_countOf(self): - self.assertRaises(TypeError, operator.countOf) - self.assertRaises(TypeError, operator.countOf, None, None) - self.assertTrue(operator.countOf([1, 2, 1, 3, 1, 4], 3) == 1) - self.assertTrue(operator.countOf([1, 2, 1, 3, 1, 4], 5) == 0) + self.assertRaises(TypeError, self.module.countOf) + self.assertRaises(TypeError, self.module.countOf, None, None) + self.assertTrue(self.module.countOf([1, 2, 1, 3, 1, 4], 3) == 1) + self.assertTrue(self.module.countOf([1, 2, 1, 3, 1, 4], 5) == 0) def test_delitem(self): a = [4, 3, 2, 1] - self.assertRaises(TypeError, operator.delitem, a) - self.assertRaises(TypeError, operator.delitem, a, None) - self.assertTrue(operator.delitem(a, 1) is None) + self.assertRaises(TypeError, self.module.delitem, a) + self.assertRaises(TypeError, self.module.delitem, a, None) + self.assertTrue(self.module.delitem(a, 1) is None) self.assertTrue(a == [4, 2, 1]) def test_floordiv(self): - self.assertRaises(TypeError, operator.floordiv, 5) - self.assertRaises(TypeError, operator.floordiv, None, None) - self.assertTrue(operator.floordiv(5, 2) == 2) + self.assertRaises(TypeError, self.module.floordiv, 5) + self.assertRaises(TypeError, self.module.floordiv, None, None) + self.assertTrue(self.module.floordiv(5, 2) == 2) def test_truediv(self): - self.assertRaises(TypeError, operator.truediv, 5) - self.assertRaises(TypeError, operator.truediv, None, None) - self.assertTrue(operator.truediv(5, 2) == 2.5) + self.assertRaises(TypeError, self.module.truediv, 5) + self.assertRaises(TypeError, self.module.truediv, None, None) + self.assertTrue(self.module.truediv(5, 2) == 2.5) def test_getitem(self): a = range(10) - self.assertRaises(TypeError, operator.getitem) - self.assertRaises(TypeError, operator.getitem, a, None) - self.assertTrue(operator.getitem(a, 2) == 2) + self.assertRaises(TypeError, self.module.getitem) + self.assertRaises(TypeError, self.module.getitem, a, None) + self.assertTrue(self.module.getitem(a, 2) == 2) def test_indexOf(self): - self.assertRaises(TypeError, operator.indexOf) - self.assertRaises(TypeError, operator.indexOf, None, None) - self.assertTrue(operator.indexOf([4, 3, 2, 1], 3) == 1) - self.assertRaises(ValueError, operator.indexOf, [4, 3, 2, 1], 0) + self.assertRaises(TypeError, self.module.indexOf) + self.assertRaises(TypeError, self.module.indexOf, None, None) + self.assertTrue(self.module.indexOf([4, 3, 2, 1], 3) == 1) + self.assertRaises(ValueError, self.module.indexOf, [4, 3, 2, 1], 0) def test_invert(self): - self.assertRaises(TypeError, operator.invert) - self.assertRaises(TypeError, operator.invert, None) - self.assertEqual(operator.inv(4), -5) + self.assertRaises(TypeError, self.module.invert) + self.assertRaises(TypeError, self.module.invert, None) + self.assertEqual(self.module.inv(4), -5) def test_lshift(self): - self.assertRaises(TypeError, operator.lshift) - self.assertRaises(TypeError, operator.lshift, None, 42) - self.assertTrue(operator.lshift(5, 1) == 10) - self.assertTrue(operator.lshift(5, 0) == 5) - self.assertRaises(ValueError, operator.lshift, 2, -1) + self.assertRaises(TypeError, self.module.lshift) + self.assertRaises(TypeError, self.module.lshift, None, 42) + self.assertTrue(self.module.lshift(5, 1) == 10) + self.assertTrue(self.module.lshift(5, 0) == 5) + self.assertRaises(ValueError, self.module.lshift, 2, -1) def test_mod(self): - self.assertRaises(TypeError, operator.mod) - self.assertRaises(TypeError, operator.mod, None, 42) - self.assertTrue(operator.mod(5, 2) == 1) + self.assertRaises(TypeError, self.module.mod) + self.assertRaises(TypeError, self.module.mod, None, 42) + self.assertTrue(self.module.mod(5, 2) == 1) def test_mul(self): - self.assertRaises(TypeError, operator.mul) - self.assertRaises(TypeError, operator.mul, None, None) - self.assertTrue(operator.mul(5, 2) == 10) + self.assertRaises(TypeError, self.module.mul) + self.assertRaises(TypeError, self.module.mul, None, None) + self.assertTrue(self.module.mul(5, 2) == 10) def test_neg(self): - self.assertRaises(TypeError, operator.neg) - self.assertRaises(TypeError, operator.neg, None) - self.assertEqual(operator.neg(5), -5) - self.assertEqual(operator.neg(-5), 5) - self.assertEqual(operator.neg(0), 0) - self.assertEqual(operator.neg(-0), 0) + self.assertRaises(TypeError, self.module.neg) + self.assertRaises(TypeError, self.module.neg, None) + self.assertEqual(self.module.neg(5), -5) + self.assertEqual(self.module.neg(-5), 5) + self.assertEqual(self.module.neg(0), 0) + self.assertEqual(self.module.neg(-0), 0) def test_bitwise_or(self): - self.assertRaises(TypeError, operator.or_) - self.assertRaises(TypeError, operator.or_, None, None) - self.assertTrue(operator.or_(0xa, 0x5) == 0xf) + self.assertRaises(TypeError, self.module.or_) + self.assertRaises(TypeError, self.module.or_, None, None) + self.assertTrue(self.module.or_(0xa, 0x5) == 0xf) def test_pos(self): - self.assertRaises(TypeError, operator.pos) - self.assertRaises(TypeError, operator.pos, None) - self.assertEqual(operator.pos(5), 5) - self.assertEqual(operator.pos(-5), -5) - self.assertEqual(operator.pos(0), 0) - self.assertEqual(operator.pos(-0), 0) + self.assertRaises(TypeError, self.module.pos) + self.assertRaises(TypeError, self.module.pos, None) + self.assertEqual(self.module.pos(5), 5) + self.assertEqual(self.module.pos(-5), -5) + self.assertEqual(self.module.pos(0), 0) + self.assertEqual(self.module.pos(-0), 0) def test_pow(self): - self.assertRaises(TypeError, operator.pow) - self.assertRaises(TypeError, operator.pow, None, None) - self.assertEqual(operator.pow(3,5), 3**5) - self.assertEqual(operator.__pow__(3,5), 3**5) - self.assertRaises(TypeError, operator.pow, 1) - self.assertRaises(TypeError, operator.pow, 1, 2, 3) + self.assertRaises(TypeError, self.module.pow) + self.assertRaises(TypeError, self.module.pow, None, None) + self.assertEqual(self.module.pow(3,5), 3**5) + self.assertEqual(self.module.__pow__(3,5), 3**5) + self.assertRaises(TypeError, self.module.pow, 1) + self.assertRaises(TypeError, self.module.pow, 1, 2, 3) def test_rshift(self): - self.assertRaises(TypeError, operator.rshift) - self.assertRaises(TypeError, operator.rshift, None, 42) - self.assertTrue(operator.rshift(5, 1) == 2) - self.assertTrue(operator.rshift(5, 0) == 5) - self.assertRaises(ValueError, operator.rshift, 2, -1) + self.assertRaises(TypeError, self.module.rshift) + self.assertRaises(TypeError, self.module.rshift, None, 42) + self.assertTrue(self.module.rshift(5, 1) == 2) + self.assertTrue(self.module.rshift(5, 0) == 5) + self.assertRaises(ValueError, self.module.rshift, 2, -1) def test_contains(self): - self.assertRaises(TypeError, operator.contains) - self.assertRaises(TypeError, operator.contains, None, None) - self.assertTrue(operator.contains(range(4), 2)) - self.assertFalse(operator.contains(range(4), 5)) + self.assertRaises(TypeError, self.module.contains) + self.assertRaises(TypeError, self.module.contains, None, None) + self.assertTrue(self.module.contains(range(4), 2)) + self.assertFalse(self.module.contains(range(4), 5)) def test_setitem(self): a = list(range(3)) - self.assertRaises(TypeError, operator.setitem, a) - self.assertRaises(TypeError, operator.setitem, a, None, None) - self.assertTrue(operator.setitem(a, 0, 2) is None) + self.assertRaises(TypeError, self.module.setitem, a) + self.assertRaises(TypeError, self.module.setitem, a, None, None) + self.assertTrue(self.module.setitem(a, 0, 2) is None) self.assertTrue(a == [2, 1, 2]) - self.assertRaises(IndexError, operator.setitem, a, 4, 2) + self.assertRaises(IndexError, self.module.setitem, a, 4, 2) def test_sub(self): - self.assertRaises(TypeError, operator.sub) - self.assertRaises(TypeError, operator.sub, None, None) - self.assertTrue(operator.sub(5, 2) == 3) + self.assertRaises(TypeError, self.module.sub) + self.assertRaises(TypeError, self.module.sub, None, None) + self.assertTrue(self.module.sub(5, 2) == 3) def test_truth(self): class C(object): def __bool__(self): raise SyntaxError - self.assertRaises(TypeError, operator.truth) - self.assertRaises(SyntaxError, operator.truth, C()) - self.assertTrue(operator.truth(5)) - self.assertTrue(operator.truth([0])) - self.assertFalse(operator.truth(0)) - self.assertFalse(operator.truth([])) + self.assertRaises(TypeError, self.module.truth) + self.assertRaises(SyntaxError, self.module.truth, C()) + self.assertTrue(self.module.truth(5)) + self.assertTrue(self.module.truth([0])) + self.assertFalse(self.module.truth(0)) + self.assertFalse(self.module.truth([])) def test_bitwise_xor(self): - self.assertRaises(TypeError, operator.xor) - self.assertRaises(TypeError, operator.xor, None, None) - self.assertTrue(operator.xor(0xb, 0xc) == 0x7) + self.assertRaises(TypeError, self.module.xor) + self.assertRaises(TypeError, self.module.xor, None, None) + self.assertTrue(self.module.xor(0xb, 0xc) == 0x7) def test_is(self): a = b = 'xyzpdq' c = a[:3] + b[3:] - self.assertRaises(TypeError, operator.is_) - self.assertTrue(operator.is_(a, b)) - self.assertFalse(operator.is_(a,c)) + self.assertRaises(TypeError, self.module.is_) + self.assertTrue(self.module.is_(a, b)) + self.assertFalse(self.module.is_(a,c)) def test_is_not(self): a = b = 'xyzpdq' c = a[:3] + b[3:] - self.assertRaises(TypeError, operator.is_not) - self.assertFalse(operator.is_not(a, b)) - self.assertTrue(operator.is_not(a,c)) + self.assertRaises(TypeError, self.module.is_not) + self.assertFalse(self.module.is_not(a, b)) + self.assertTrue(self.module.is_not(a,c)) def test_attrgetter(self): class A: pass a = A() a.name = 'arthur' - f = operator.attrgetter('name') + f = self.module.attrgetter('name') self.assertEqual(f(a), 'arthur') - f = operator.attrgetter('rank') + f = self.module.attrgetter('rank') self.assertRaises(AttributeError, f, a) - self.assertRaises(TypeError, operator.attrgetter, 2) - self.assertRaises(TypeError, operator.attrgetter) + self.assertRaises(TypeError, self.module.attrgetter, 2) + self.assertRaises(TypeError, self.module.attrgetter) # multiple gets record = A() record.x = 'X' record.y = 'Y' record.z = 'Z' - self.assertEqual(operator.attrgetter('x','z','y')(record), ('X', 'Z', 'Y')) - self.assertRaises(TypeError, operator.attrgetter, ('x', (), 'y')) + self.assertEqual(self.module.attrgetter('x','z','y')(record), ('X', 'Z', 'Y')) + self.assertRaises(TypeError, self.module.attrgetter, ('x', (), 'y')) class C(object): def __getattr__(self, name): raise SyntaxError - self.assertRaises(SyntaxError, operator.attrgetter('foo'), C()) + self.assertRaises(SyntaxError, self.module.attrgetter('foo'), C()) # recursive gets a = A() a.name = 'arthur' a.child = A() a.child.name = 'thomas' - f = operator.attrgetter('child.name') + f = self.module.attrgetter('child.name') self.assertEqual(f(a), 'thomas') self.assertRaises(AttributeError, f, a.child) - f = operator.attrgetter('name', 'child.name') + f = self.module.attrgetter('name', 'child.name') self.assertEqual(f(a), ('arthur', 'thomas')) - f = operator.attrgetter('name', 'child.name', 'child.child.name') + f = self.module.attrgetter('name', 'child.name', 'child.child.name') self.assertRaises(AttributeError, f, a) - f = operator.attrgetter('child.') + f = self.module.attrgetter('child.') self.assertRaises(AttributeError, f, a) - f = operator.attrgetter('.child') + f = self.module.attrgetter('.child') self.assertRaises(AttributeError, f, a) a.child.child = A() a.child.child.name = 'johnson' - f = operator.attrgetter('child.child.name') + f = self.module.attrgetter('child.child.name') self.assertEqual(f(a), 'johnson') - f = operator.attrgetter('name', 'child.name', 'child.child.name') + f = self.module.attrgetter('name', 'child.name', 'child.child.name') self.assertEqual(f(a), ('arthur', 'thomas', 'johnson')) def test_itemgetter(self): a = 'ABCDE' - f = operator.itemgetter(2) + f = self.module.itemgetter(2) self.assertEqual(f(a), 'C') - f = operator.itemgetter(10) + f = self.module.itemgetter(10) self.assertRaises(IndexError, f, a) class C(object): def __getitem__(self, name): raise SyntaxError - self.assertRaises(SyntaxError, operator.itemgetter(42), C()) + self.assertRaises(SyntaxError, self.module.itemgetter(42), C()) - f = operator.itemgetter('name') + f = self.module.itemgetter('name') self.assertRaises(TypeError, f, a) - self.assertRaises(TypeError, operator.itemgetter) + self.assertRaises(TypeError, self.module.itemgetter) d = dict(key='val') - f = operator.itemgetter('key') + f = self.module.itemgetter('key') self.assertEqual(f(d), 'val') - f = operator.itemgetter('nonkey') + f = self.module.itemgetter('nonkey') self.assertRaises(KeyError, f, d) # example used in the docs inventory = [('apple', 3), ('banana', 2), ('pear', 5), ('orange', 1)] - getcount = operator.itemgetter(1) + getcount = self.module.itemgetter(1) self.assertEqual(list(map(getcount, inventory)), [3, 2, 5, 1]) self.assertEqual(sorted(inventory, key=getcount), [('orange', 1), ('banana', 2), ('apple', 3), ('pear', 5)]) # multiple gets data = list(map(str, range(20))) - self.assertEqual(operator.itemgetter(2,10,5)(data), ('2', '10', '5')) - self.assertRaises(TypeError, operator.itemgetter(2, 'x', 5), data) + self.assertEqual(self.module.itemgetter(2,10,5)(data), ('2', '10', '5')) + self.assertRaises(TypeError, self.module.itemgetter(2, 'x', 5), data) def test_methodcaller(self): - self.assertRaises(TypeError, operator.methodcaller) + self.assertRaises(TypeError, self.module.methodcaller) class A: def foo(self, *args, **kwds): return args[0] + args[1] def bar(self, f=42): return f a = A() - f = operator.methodcaller('foo') + f = self.module.methodcaller('foo') self.assertRaises(IndexError, f, a) - f = operator.methodcaller('foo', 1, 2) + f = self.module.methodcaller('foo', 1, 2) self.assertEqual(f(a), 3) - f = operator.methodcaller('bar') + f = self.module.methodcaller('bar') self.assertEqual(f(a), 42) self.assertRaises(TypeError, f, a, a) - f = operator.methodcaller('bar', f=5) + f = self.module.methodcaller('bar', f=5) self.assertEqual(f(a), 5) def test_inplace(self): @@ -383,32 +387,32 @@ def __ixor__ (self, other): return "ixor" def __getitem__(self, other): return 5 # so that C is a sequence c = C() - self.assertEqual(operator.iadd (c, 5), "iadd") - self.assertEqual(operator.iand (c, 5), "iand") - self.assertEqual(operator.ifloordiv(c, 5), "ifloordiv") - self.assertEqual(operator.ilshift (c, 5), "ilshift") - self.assertEqual(operator.imod (c, 5), "imod") - self.assertEqual(operator.imul (c, 5), "imul") - self.assertEqual(operator.ior (c, 5), "ior") - self.assertEqual(operator.ipow (c, 5), "ipow") - self.assertEqual(operator.irshift (c, 5), "irshift") - self.assertEqual(operator.isub (c, 5), "isub") - self.assertEqual(operator.itruediv (c, 5), "itruediv") - self.assertEqual(operator.ixor (c, 5), "ixor") - self.assertEqual(operator.iconcat (c, c), "iadd") - self.assertEqual(operator.__iadd__ (c, 5), "iadd") - self.assertEqual(operator.__iand__ (c, 5), "iand") - self.assertEqual(operator.__ifloordiv__(c, 5), "ifloordiv") - self.assertEqual(operator.__ilshift__ (c, 5), "ilshift") - self.assertEqual(operator.__imod__ (c, 5), "imod") - self.assertEqual(operator.__imul__ (c, 5), "imul") - self.assertEqual(operator.__ior__ (c, 5), "ior") - self.assertEqual(operator.__ipow__ (c, 5), "ipow") - self.assertEqual(operator.__irshift__ (c, 5), "irshift") - self.assertEqual(operator.__isub__ (c, 5), "isub") - self.assertEqual(operator.__itruediv__ (c, 5), "itruediv") - self.assertEqual(operator.__ixor__ (c, 5), "ixor") - self.assertEqual(operator.__iconcat__ (c, c), "iadd") + self.assertEqual(self.module.iadd (c, 5), "iadd") + self.assertEqual(self.module.iand (c, 5), "iand") + self.assertEqual(self.module.ifloordiv(c, 5), "ifloordiv") + self.assertEqual(self.module.ilshift (c, 5), "ilshift") + self.assertEqual(self.module.imod (c, 5), "imod") + self.assertEqual(self.module.imul (c, 5), "imul") + self.assertEqual(self.module.ior (c, 5), "ior") + self.assertEqual(self.module.ipow (c, 5), "ipow") + self.assertEqual(self.module.irshift (c, 5), "irshift") + self.assertEqual(self.module.isub (c, 5), "isub") + self.assertEqual(self.module.itruediv (c, 5), "itruediv") + self.assertEqual(self.module.ixor (c, 5), "ixor") + self.assertEqual(self.module.iconcat (c, c), "iadd") + self.assertEqual(self.module.__iadd__ (c, 5), "iadd") + self.assertEqual(self.module.__iand__ (c, 5), "iand") + self.assertEqual(self.module.__ifloordiv__(c, 5), "ifloordiv") + self.assertEqual(self.module.__ilshift__ (c, 5), "ilshift") + self.assertEqual(self.module.__imod__ (c, 5), "imod") + self.assertEqual(self.module.__imul__ (c, 5), "imul") + self.assertEqual(self.module.__ior__ (c, 5), "ior") + self.assertEqual(self.module.__ipow__ (c, 5), "ipow") + self.assertEqual(self.module.__irshift__ (c, 5), "irshift") + self.assertEqual(self.module.__isub__ (c, 5), "isub") + self.assertEqual(self.module.__itruediv__ (c, 5), "itruediv") + self.assertEqual(self.module.__ixor__ (c, 5), "ixor") + self.assertEqual(self.module.__iconcat__ (c, c), "iadd") def test_length_hint(self): class X(object): @@ -421,24 +425,31 @@ else: return self.value - self.assertEqual(operator.length_hint([], 2), 0) - self.assertEqual(operator.length_hint(iter([1, 2, 3])), 3) + self.assertEqual(self.module.length_hint([], 2), 0) + self.assertEqual(self.module.length_hint(iter([1, 2, 3])), 3) - self.assertEqual(operator.length_hint(X(2)), 2) - self.assertEqual(operator.length_hint(X(NotImplemented), 4), 4) - self.assertEqual(operator.length_hint(X(TypeError), 12), 12) + self.assertEqual(self.module.length_hint(X(2)), 2) + self.assertEqual(self.module.length_hint(X(NotImplemented), 4), 4) + self.assertEqual(self.module.length_hint(X(TypeError), 12), 12) with self.assertRaises(TypeError): - operator.length_hint(X("abc")) + self.module.length_hint(X("abc")) with self.assertRaises(ValueError): - operator.length_hint(X(-2)) + self.module.length_hint(X(-2)) with self.assertRaises(LookupError): - operator.length_hint(X(LookupError)) + self.module.length_hint(X(LookupError)) +class PyOperatorTestCase(OperatorTestCase): + module = py_operator + +@unittest.skipUnless(c_operator, 'requires _operator') +class COperatorTestCase(OperatorTestCase): + module = c_operator def test_main(verbose=None): import sys test_classes = ( - OperatorTestCase, + PyOperatorTestCase, + COperatorTestCase ) support.run_unittest(*test_classes) diff -r 7c9327ff5de6 Modules/Setup.dist --- a/Modules/Setup.dist Sat Dec 15 22:36:49 2012 +0100 +++ b/Modules/Setup.dist Sun Dec 16 01:24:10 2012 -0600 @@ -113,7 +113,7 @@ _codecs _codecsmodule.c # access to the builtin codecs and codec registry _weakref _weakref.c # weak references _functools _functoolsmodule.c # Tools for working with functions and callable objects -operator operator.c # operator.add() and similar goodies +_operator operator.c # operator.add() and similar goodies _collections _collectionsmodule.c # Container types itertools itertoolsmodule.c # Functions creating iterators for efficient looping diff -r 7c9327ff5de6 Modules/operator.c --- a/Modules/operator.c Sat Dec 15 22:36:49 2012 +0100 +++ b/Modules/operator.c Sun Dec 16 01:24:10 2012 -0600 @@ -919,12 +919,12 @@ }; -/* Initialization function for the module (*must* be called PyInit_operator) */ +/* Initialization function for the module (*must* be called PyInit__operator) */ static struct PyModuleDef operatormodule = { PyModuleDef_HEAD_INIT, - "operator", + "_operator", operator_doc, -1, operator_methods, @@ -935,7 +935,7 @@ }; PyMODINIT_FUNC -PyInit_operator(void) +PyInit__operator(void) { PyObject *m; diff -r 7c9327ff5de6 PC/config.c --- a/PC/config.c Sat Dec 15 22:36:49 2012 +0100 +++ b/PC/config.c Sun Dec 16 01:24:10 2012 -0600 @@ -17,7 +17,7 @@ extern PyObject* PyInit_math(void); extern PyObject* PyInit__md5(void); extern PyObject* PyInit_nt(void); -extern PyObject* PyInit_operator(void); +extern PyObject* PyInit__operator(void); extern PyObject* PyInit_signal(void); extern PyObject* PyInit__sha1(void); extern PyObject* PyInit__sha256(void); @@ -87,7 +87,7 @@ {"gc", PyInit_gc}, {"math", PyInit_math}, {"nt", PyInit_nt}, /* Use the NT os functions, not posix */ - {"operator", PyInit_operator}, + {"_operator", PyInit__operator}, {"signal", PyInit_signal}, {"_md5", PyInit__md5}, {"_sha1", PyInit__sha1},