# coding: utf-8
# AUTO-GENERATED FILE -- DO NOT EDIT

""" Operator interface.

This module exports a set of functions implemented in C 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. """

__doc__ = """Operator interface.

This module exports a set of functions implemented in C 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."""

class __loader__(object):
  """ Meta path import for built-in modules.
  
      All methods are either class or static methods to avoid the need to
      instantiate the class.
  
       """

  def create_module(self, spec):
    """ Create a built-in module """
    pass

  def exec_module(self, module):
    """ Exec a built-in module """
    pass

  def find_module(self, fullname, path=None):
    """ Find the built-in module.
    
            If 'path' is ever specified then the search is considered a failure.
    
            This method is deprecated.  Use find_spec() instead.
    
             """
    pass

  def find_spec(self, fullname, path=None, target=None):
    pass

  def get_code(self, fullname):
    """ Return None as built-in modules do not have code objects. """
    pass

  def get_source(self, fullname):
    """ Return None as built-in modules do not have source code. """
    pass

  def is_package(self, fullname):
    """ Return False as built-in modules are never packages. """
    pass

  def load_module(self, fullname):
    """ Load the specified module into sys.modules and return it.
    
        This method is deprecated.  Use loader.exec_module instead.
    
         """
    pass

  def module_repr(self, module):
    """ Return repr for the module.
    
            The method is deprecated.  The import machinery does the job itself.
    
             """
    pass

__name__ = '_operator'
__package__ = ''
__spec__ = None

def _compare_digest(a, b):
  """ Return 'a == b'.
  
  This function uses an approach designed to prevent
  timing analysis, making it appropriate for cryptography.
  
  a and b must both be of the same type: either str (ASCII only),
  or any bytes-like object.
  
  Note: If a and b are of different lengths, or if an error occurs,
  a timing attack could theoretically reveal information about the
  types and lengths of a and b--but not their values. """
  return None

def abs(a):
  """ Same as abs(a). """
  pass

def add(a, b):
  """ Same as a + b. """
  pass

def and_(a, b):
  """ Same as a & b. """
  pass

class attrgetter(object):
  """ attrgetter(attr, ...) --> attrgetter object
  
  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). """

  pass

def concat(a, b):
  """ Same as a + b, for a and b sequences. """
  pass

def contains(a, b):
  """ Same as b in a (note reversed operands). """
  pass

def countOf(a, b):
  """ Return the number of times b occurs in a. """
  pass

def delitem(a, b):
  """ Same as del a[b]. """
  pass

def eq(a, b):
  """ Same as a == b. """
  pass

def floordiv(a, b):
  """ Same as a // b. """
  pass

def ge(a, b):
  """ Same as a >= b. """
  pass

def getitem(a, b):
  """ Same as a[b]. """
  pass

def gt(a, b):
  """ Same as a > b. """
  pass

def iadd(a, b):
  """ Same as a += b. """
  pass

def iand(a, b):
  """ Same as a &= b. """
  pass

def iconcat(a, b):
  """ Same as a += b, for a and b sequences. """
  pass

def ifloordiv(a, b):
  """ Same as a //= b. """
  pass

def ilshift(a, b):
  """ Same as a <<= b. """
  pass

def imatmul(a, b):
  """ Same as a @= b. """
  pass

def imod(a, b):
  """ Same as a %= b. """
  pass

def imul(a, b):
  """ Same as a *= b. """
  pass

def index(a):
  """ Same as a.__index__() """
  pass

def indexOf(a, b):
  """ Return the first index of b in a. """
  pass

def inv(a):
  """ Same as ~a. """
  pass

def invert(a):
  """ Same as ~a. """
  pass

def ior(a, b):
  """ Same as a |= b. """
  pass

def ipow(a, b):
  """ Same as a **= b. """
  pass

def irshift(a, b):
  """ Same as a >>= b. """
  pass

def is_(a, b):
  """ Same as a is b. """
  pass

def is_not(a, b):
  """ Same as a is not b. """
  pass

def isub(a, b):
  """ Same as a -= b. """
  pass

class itemgetter(object):
  """ itemgetter(item, ...) --> itemgetter object
  
  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]) """

  pass

def itruediv(a, b):
  """ Same as a /= b. """
  pass

def ixor(a, b):
  """ Same as a ^= b. """
  pass

def le(a, b):
  """ Same as a <= b. """
  pass

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. """
  pass

def lshift(a, b):
  """ Same as a << b. """
  pass

def lt(a, b):
  """ Same as a < b. """
  pass

def matmul(a, b):
  """ Same as a @ b. """
  pass

class methodcaller(object):
  """ methodcaller(name, ...) --> methodcaller object
  
  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). """

  pass

def mod(a, b):
  """ Same as a % b. """
  pass

def mul(a, b):
  """ Same as a * b. """
  pass

def ne(a, b):
  """ Same as a != b. """
  pass

def neg(a):
  """ Same as -a. """
  pass

def not_(a):
  """ Same as not a. """
  pass

def or_(a, b):
  """ Same as a | b. """
  pass

def pos(a):
  """ Same as +a. """
  pass

def pow(a, b):
  """ Same as a ** b. """
  pass

def rshift(a, b):
  """ Same as a >> b. """
  pass

def setitem(a, b, c):
  """ Same as a[b] = c. """
  pass

def sub(a, b):
  """ Same as a - b. """
  pass

def truediv(a, b):
  """ Same as a / b. """
  pass

def truth(a):
  """ Return True if a is true, False otherwise. """
  pass

def xor(a, b):
  """ Same as a ^ b. """
  pass