diff --git a/Lib/hmac.py b/Lib/hmac.py --- a/Lib/hmac.py +++ b/Lib/hmac.py @@ -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 --git a/Lib/operator.py b/Lib/operator.py new file mode 100644 --- /dev/null +++ b/Lib/operator.py @@ -0,0 +1,414 @@ +#!/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. +""" + +__all__ = ['__abs__', '__add__', '__and__', '__concat__', '__contains__', + '__delitem__', '__eq__', '__floordiv__', '__ge__', '__getitem__', + '__gt__', '__iadd__', '__iand__', '__iconcat__', '__ifloordiv__', + '__ilshift__', '__imod__', '__imul__', '__index__', '__inv__', + '__invert__', '__ior__', '__ipow__', '__irshift__', '__isub__', + '__itruediv__', '__ixor__', '__le__', '__loader__', '__lshift__', + '__lt__', '__mod__', '__mul__', '__name__', '__ne__', '__neg__', + '__not__', '__or__', '__pos__', '__pow__', '__rshift__', + '__setitem__', '__sub__', '__truediv__', '__xor__', + 'abs', 'add', 'and_', 'attrgetter', 'concat', 'contains', 'countOf', + 'delitem', 'eq', 'floordiv', 'ge', 'getitem', 'gt', 'iadd', 'iand', + 'iconcat', 'ifloordiv', 'ilshift', 'imod', 'imul', 'index', + 'indexOf', 'inv', 'invert', 'ior', 'ipow', 'irshift', 'is_', + 'is_not', 'isub', 'itemgetter', 'itruediv', 'ixor', 'le', + 'length_hint', 'lshift', 'lt', 'methodcaller', 'mod', 'mul', 'ne', + 'neg', 'not_', 'or_', 'pos', 'pow', 'rshift', 'setitem', 'sub', + 'truediv', 'truth', 'xor'] + +from builtins import abs as _abs + + +# Comparison operations *******************************************************# + +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 + +# Logical Operations **********************************************************# + +def not_(a): + "Same as not a." + return not a +__not__ = not_ + +def truth(a): + "Return True if a is true, False otherwise." + return True if a else False + +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 + +# Mathematical/Bitwise Operations *********************************************# + +def abs(a): + "Same as abs(a)." + return _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 + +# Sequence Operations *********************************************************# + +def concat(a, b): + "Same as a + b, for a and b sequences." + if not hasattr(a, '__getitem__'): + msg = "'%s' object can't be concatenated" % type(a).__name__ + raise TypeError(msg) + 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 enumerate(a): + if j == b: + return i + else: + raise ValueError('sequence.index(x): x not in sequence') + +def setitem(a, b, c): + "Same as a[b] = c." + a[b] = c +__setitem__ = setitem + +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. + """ + if not isinstance(default, int): + msg = ("'%s' object cannot be interpreted as an integer" % + type(default).__name__) + raise TypeError(msg) + + try: + return len(obj) + except TypeError: + pass + + try: + hint = type(obj).__length_hint__ + except AttributeError: + return default + + try: + val = hint(obj) + except TypeError: + return default + if val is NotImplemented: + return default + if not isinstance(val, int): + msg = ('__length_hint__ must be integer, not %s' % + type(val).__name__) + raise TypeError(msg) + if val < 0: + msg = '__length_hint__() should return >= 0' + raise ValueError(msg) + return val + +# Generalized Lookup Objects **************************************************# + +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): + if not attrs: + if not isinstance(attr, str): + raise TypeError('attribute name must be a string') + names = attr.split('.') + def func(obj): + for name in names: + obj = getattr(obj, name) + return obj + self._call = func + else: + getters = tuple(map(attrgetter, (attr,) + attrs)) + def func(obj): + return tuple(getter(obj) for getter in getters) + self._call = func + + def __call__(self, obj): + return self._call(obj) + +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): + if not items: + def func(obj): + return obj[item] + self._call = func + else: + items = (item,) + items + def func(obj): + return tuple(obj[i] for i in items) + self._call = func + + def __call__(self, obj): + return self._call(obj) + +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__(*args, **kwargs): + if len(args) < 2: + msg = "methodcaller needs at least one argument, the method name" + raise TypeError(msg) + self = args[0] + self._name = args[1] + self._args = args[2:] + self._kwargs = kwargs + + def __call__(self, obj): + return getattr(obj, self._name)(*self._args, **self._kwargs) + +# In-place Operations *********************************************************# + +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__'): + msg = "'%s' object can't be concatenated" % type(a).__name__ + raise TypeError(msg) + 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 + + +try: + from _operator import * +except ImportError: + pass diff --git a/Lib/test/test_operator.py b/Lib/test/test_operator.py --- a/Lib/test/test_operator.py +++ b/Lib/test/test_operator.py @@ -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 @@ -31,341 +33,344 @@ def __rmul__(self, other): return other * self.lst - -class OperatorTestCase(unittest.TestCase): +class OperatorTestCase: 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 + def baz(*args, **kwds): + return kwds['name'], kwds['self'] 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) + f = self.module.methodcaller('baz', name='spam', self='eggs') + self.assertEqual(f(a), ('spam', 'eggs')) def test_inplace(self): class C(object): @@ -383,32 +388,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 +426,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(unittest.TestCase, OperatorTestCase): + module = py_operator + +@unittest.skipUnless(c_operator, 'requires _operator') +class COperatorTestCase(unittest.TestCase, OperatorTestCase): + module = c_operator def test_main(verbose=None): import sys test_classes = ( - OperatorTestCase, + PyOperatorTestCase, + COperatorTestCase ) support.run_unittest(*test_classes) diff --git a/Modules/Setup.dist b/Modules/Setup.dist --- a/Modules/Setup.dist +++ b/Modules/Setup.dist @@ -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 --git a/Modules/operator.c b/Modules/_operator.c rename from Modules/operator.c rename to Modules/_operator.c --- a/Modules/operator.c +++ b/Modules/_operator.c @@ -487,8 +487,8 @@ "itemgetter(item, ...) --> itemgetter object\n\ \n\ Return a callable object that fetches the given item(s) from its operand.\n\ -After, f=itemgetter(2), the call f(r) returns r[2].\n\ -After, g=itemgetter(2,5,3), the call g(r) returns (r[2], r[5], r[3])"); +After f=itemgetter(2), the call f(r) returns r[2].\n\ +After g=itemgetter(2,5,3), the call g(r) returns (r[2], r[5], r[3])"); static PyTypeObject itemgetter_type = { PyVarObject_HEAD_INIT(NULL, 0) @@ -739,9 +739,9 @@ "attrgetter(attr, ...) --> attrgetter object\n\ \n\ Return a callable object that fetches the given attribute(s) from its operand.\n\ -After, f=attrgetter('name'), the call f(r) returns r.name.\n\ -After, g=attrgetter('name', 'date'), the call g(r) returns (r.name, r.date).\n\ -After, h=attrgetter('name.first', 'name.last'), the call h(r) returns\n\ +After f=attrgetter('name'), the call f(r) returns r.name.\n\ +After g=attrgetter('name', 'date'), the call g(r) returns (r.name, r.date).\n\ +After h=attrgetter('name.first', 'name.last'), the call h(r) returns\n\ (r.name.first, r.name.last)."); static PyTypeObject attrgetter_type = { @@ -871,8 +871,8 @@ "methodcaller(name, ...) --> methodcaller object\n\ \n\ Return a callable object that calls the given method on its operand.\n\ -After, f = methodcaller('name'), the call f(r) returns r.name().\n\ -After, g = methodcaller('name', 'date', foo=1), the call g(r) returns\n\ +After f = methodcaller('name'), the call f(r) returns r.name().\n\ +After g = methodcaller('name', 'date', foo=1), the call g(r) returns\n\ r.name('date', foo=1)."); static PyTypeObject methodcaller_type = { @@ -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 --git a/PC/VS9.0/pythoncore.vcproj b/PC/VS9.0/pythoncore.vcproj --- a/PC/VS9.0/pythoncore.vcproj +++ b/PC/VS9.0/pythoncore.vcproj @@ -1119,7 +1119,7 @@ > - + diff --git a/PCbuild/pythoncore.vcxproj.filters b/PCbuild/pythoncore.vcxproj.filters --- a/PCbuild/pythoncore.vcxproj.filters +++ b/PCbuild/pythoncore.vcxproj.filters @@ -501,7 +501,7 @@ Modules - + Modules