operator.py

"""
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_', 'attrgetter', 'concat', 'contains', 'countOf',
'delitem', 'eq', 'floordiv', 'ge', 'getitem', 'gt', 'iadd', 'iand',
'iconcat', 'ifloordiv', 'ilshift', 'imatmul', 'imod', 'imul',
'index', 'indexOf', 'inv', 'invert', 'ior', 'ipow', 'irshift',
'is_', 'is_not', 'isub', 'itemgetter', 'itruediv', 'ixor', 'le',
'length_hint', 'lshift', 'lt', 'matmul', 'methodcaller', 'mod',
'mul', 'ne', 'neg', 'not_', 'or_', 'pos', 'pow', 'rshift',
'setitem', 'sub', 'truediv', 'truth', 'xor']

frombuiltinsimportabsas_abs


# Comparison Operations *******************************************************#

deflt(a, b):
"Same as a < b."
returna<b

defle(a, b):
"Same as a <= b."
returna<=b

defeq(a, b):
"Same as a == b."
returna==b

defne(a, b):
"Same as a != b."
returna!=b

defge(a, b):
"Same as a >= b."
returna>=b

defgt(a, b):
"Same as a > b."
returna>b

# Logical Operations **********************************************************#

defnot_(a):
"Same as not a."
returnnota

deftruth(a):
"Return True if a is true, False otherwise."
returnTrueifaelseFalse

defis_(a, b):
"Same as a is b."
returnaisb

defis_not(a, b):
"Same as a is not b."
returnaisnotb

# Mathematical/Bitwise Operations *********************************************#

defabs(a):
"Same as abs(a)."
return_abs(a)

defadd(a, b):
"Same as a + b."
returna+b

defand_(a, b):
"Same as a & b."
returna&b

deffloordiv(a, b):
"Same as a // b."
returna//b

defindex(a):
"Same as a.__index__()."
returna.__index__()

definv(a):
"Same as ~a."
return~a
invert=inv

deflshift(a, b):
"Same as a << b."
returna<<b

defmod(a, b):
"Same as a % b."
returna%b

defmul(a, b):
"Same as a * b."
returna*b

defmatmul(a, b):
"Same as a @ b."
returna @ b

defneg(a):
"Same as -a."
return-a

defor_(a, b):
"Same as a | b."
returna|b

defpos(a):
"Same as +a."
return+a

defpow(a, b):
"Same as a ** b."
returna**b

defrshift(a, b):
"Same as a >> b."
returna>>b

defsub(a, b):
"Same as a - b."
returna-b

deftruediv(a, b):
"Same as a / b."
returna/b

defxor(a, b):
"Same as a ^ b."
returna^b

# Sequence Operations *********************************************************#

defconcat(a, b):
"Same as a + b, for a and b sequences."
ifnothasattr(a, '__getitem__'):
msg="'%s' object can't be concatenated"%type(a).__name__
raiseTypeError(msg)
returna+b

defcontains(a, b):
"Same as b in a (note reversed operands)."
returnbina

defcountOf(a, b):
"Return the number of times b occurs in a."
count=0
foriina:
ifi==b:
count+=1
returncount

defdelitem(a, b):
"Same as del a[b]."
dela[b]

defgetitem(a, b):
"Same as a[b]."
returna[b]

defindexOf(a, b):
"Return the first index of b in a."
fori, jinenumerate(a):
ifj==b:
returni
else:
raiseValueError('sequence.index(x): x not in sequence')

defsetitem(a, b, c):
"Same as a[b] = c."
a[b] =c

deflength_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.
 """
ifnotisinstance(default, int):
msg= ("'%s' object cannot be interpreted as an integer"%
type(default).__name__)
raiseTypeError(msg)

try:
returnlen(obj)
exceptTypeError:
pass

try:
hint=type(obj).__length_hint__
exceptAttributeError:
returndefault

try:
val=hint(obj)
exceptTypeError:
returndefault
ifvalisNotImplemented:
returndefault
ifnotisinstance(val, int):
msg= ('__length_hint__ must be integer, not %s'%
type(val).__name__)
raiseTypeError(msg)
ifval<0:
msg='__length_hint__() should return >= 0'
raiseValueError(msg)
returnval

# Generalized Lookup Objects **************************************************#

classattrgetter:
"""
 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).
 """
__slots__= ('_attrs', '_call')

def__init__(self, attr, *attrs):
ifnotattrs:
ifnotisinstance(attr, str):
raiseTypeError('attribute name must be a string')
self._attrs= (attr,)
names=attr.split('.')
deffunc(obj):
fornameinnames:
obj=getattr(obj, name)
returnobj
self._call=func
else:
self._attrs= (attr,) +attrs
getters=tuple(map(attrgetter, self._attrs))
deffunc(obj):
returntuple(getter(obj) forgetteringetters)
self._call=func

def__call__(self, obj):
returnself._call(obj)

def__repr__(self):
return'%s.%s(%s)'% (self.__class__.__module__,
self.__class__.__qualname__,
', '.join(map(repr, self._attrs)))

def__reduce__(self):
returnself.__class__, self._attrs

classitemgetter:
"""
 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])
 """
__slots__= ('_items', '_call')

def__init__(self, item, *items):
ifnotitems:
self._items= (item,)
deffunc(obj):
returnobj[item]
self._call=func
else:
self._items=items= (item,) +items
deffunc(obj):
returntuple(obj[i] foriinitems)
self._call=func

def__call__(self, obj):
returnself._call(obj)

def__repr__(self):
return'%s.%s(%s)'% (self.__class__.__module__,
self.__class__.__name__,
', '.join(map(repr, self._items)))

def__reduce__(self):
returnself.__class__, self._items

classmethodcaller:
"""
 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).
 """
__slots__= ('_name', '_args', '_kwargs')

def__init__(*args, **kwargs):
iflen(args) <2:
msg="methodcaller needs at least one argument, the method name"
raiseTypeError(msg)
self=args[0]
self._name=args[1]
ifnotisinstance(self._name, str):
raiseTypeError('method name must be a string')
self._args=args[2:]
self._kwargs=kwargs

def__call__(self, obj):
returngetattr(obj, self._name)(*self._args, **self._kwargs)

def__repr__(self):
args= [repr(self._name)]
args.extend(map(repr, self._args))
args.extend('%s=%r'% (k, v) fork, vinself._kwargs.items())
return'%s.%s(%s)'% (self.__class__.__module__,
self.__class__.__name__,
', '.join(args))

def__reduce__(self):
ifnotself._kwargs:
returnself.__class__, (self._name,) +self._args
else:
fromfunctoolsimportpartial
returnpartial(self.__class__, self._name, **self._kwargs), self._args


# In-place Operations *********************************************************#

defiadd(a, b):
"Same as a += b."
a+=b
returna

defiand(a, b):
"Same as a &= b."
a&=b
returna

deficoncat(a, b):
"Same as a += b, for a and b sequences."
ifnothasattr(a, '__getitem__'):
msg="'%s' object can't be concatenated"%type(a).__name__
raiseTypeError(msg)
a+=b
returna

defifloordiv(a, b):
"Same as a //= b."
a//=b
returna

defilshift(a, b):
"Same as a <<= b."
a<<=b
returna

defimod(a, b):
"Same as a %= b."
a%=b
returna

defimul(a, b):
"Same as a *= b."
a*=b
returna

defimatmul(a, b):
"Same as a @= b."
a@=b
returna

defior(a, b):
"Same as a |= b."
a|=b
returna

defipow(a, b):
"Same as a **= b."
a**=b
returna

defirshift(a, b):
"Same as a >>= b."
a>>=b
returna

defisub(a, b):
"Same as a -= b."
a-=b
returna

defitruediv(a, b):
"Same as a /= b."
a/=b
returna

defixor(a, b):
"Same as a ^= b."
a^=b
returna


try:
from_operatorimport*
exceptImportError:
pass
else:
from_operatorimport__doc__

# All of these "__func__ = func" assignments have to happen after importing
# from _operator to make sure they're set to the right function
__lt__=lt
__le__=le
__eq__=eq
__ne__=ne
__ge__=ge
__gt__=gt
__not__=not_
__abs__=abs
__add__=add
__and__=and_
__floordiv__=floordiv
__index__=index
__inv__=inv
__invert__=invert
__lshift__=lshift
__mod__=mod
__mul__=mul
__matmul__=matmul
__neg__=neg
__or__=or_
__pos__=pos
__pow__=pow
__rshift__=rshift
__sub__=sub
__truediv__=truediv
__xor__=xor
__concat__=concat
__contains__=contains
__delitem__=delitem
__getitem__=getitem
__setitem__=setitem
__iadd__=iadd
__iand__=iand
__iconcat__=iconcat
__ifloordiv__=ifloordiv
__ilshift__=ilshift
__imod__=imod
__imul__=imul
__imatmul__=imatmul
__ior__=ior
__ipow__=ipow
__irshift__=irshift
__isub__=isub
__itruediv__=itruediv
__ixor__=ixor