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

""" This module defines an object type which can efficiently represent
an array of basic values: characters, integers, floating point
numbers.  Arrays are sequence types and behave very much like lists,
except that the type of objects stored in them is constrained.
 """

ArrayType = array
__doc__ = """This module defines an object type which can efficiently represent
an array of basic values: characters, integers, floating point
numbers.  Arrays are sequence types and behave very much like lists,
except that the type of objects stored in them is constrained.
"""

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

  _ORIGIN = 'built-in'

  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__ = 'array'
__package__ = ''
__spec__ = None

def _array_reconstructor(arraytype, typecode, mformat_code, items):
  """ Internal. Used for pickling support. """
  pass

class array(object):
  """ array(typecode [, initializer]) -> array
  
  Return a new array whose items are restricted by typecode, and
  initialized from the optional initializer value, which must be a list,
  string or iterable over elements of the appropriate type.
  
  Arrays represent basic values and behave very much like lists, except
  the type of objects stored in them is constrained. The type is specified
  at object creation time by using a type code, which is a single character.
  The following type codes are defined:
  
      Type code   C Type             Minimum size in bytes
      'b'         signed integer     1
      'B'         unsigned integer   1
      'u'         Unicode character  2 (see note)
      'h'         signed integer     2
      'H'         unsigned integer   2
      'i'         signed integer     2
      'I'         unsigned integer   2
      'l'         signed integer     4
      'L'         unsigned integer   4
      'q'         signed integer     8 (see note)
      'Q'         unsigned integer   8 (see note)
      'f'         floating point     4
      'd'         floating point     8
  
  NOTE: The 'u' typecode corresponds to Python's unicode character. On
  narrow builds this is 2-bytes on wide builds this is 4-bytes.
  
  NOTE: The 'q' and 'Q' type codes are only available if the platform
  C compiler used to build Python supports 'long long', or, on Windows,
  '__int64'.
  
  Methods:
  
  append() -- append a new item to the end of the array
  buffer_info() -- return information giving the current memory info
  byteswap() -- byteswap all the items of the array
  count() -- return number of occurrences of an object
  extend() -- extend array by appending multiple elements from an iterable
  fromfile() -- read items from a file object
  fromlist() -- append items from the list
  frombytes() -- append items from the string
  index() -- return index of first occurrence of an object
  insert() -- insert a new item into the array at a provided position
  pop() -- remove and return item (default last)
  remove() -- remove first occurrence of an object
  reverse() -- reverse the order of the items in the array
  tofile() -- write all items to a file object
  tolist() -- return the array converted to an ordinary list
  tobytes() -- return the array converted to a string
  
  Attributes:
  
  typecode -- the typecode character used to create the array
  itemsize -- the length in bytes of one array item
   """

  def append(self, v):
    """ Append new value v to the end of the array. """
    pass

  def buffer_info(self):
    """ Return a tuple (address, length) giving the current memory address and the length in items of the buffer used to hold array's contents.
    
    The length should be multiplied by the itemsize attribute to calculate
    the buffer length in bytes. """
    pass

  def byteswap(self):
    """ Byteswap all items of the array.
    
    If the items in the array are not 1, 2, 4, or 8 bytes in size, RuntimeError is
    raised. """
    pass

  def count(self, v):
    """ Return number of occurrences of v in the array. """
    pass

  def extend(self, bb):
    """ Append items to the end of the array. """
    pass

  def frombytes(self, buffer):
    """ Appends items from the string, interpreting it as an array of machine values, as if it had been read from a file using the fromfile() method. """
    pass

  def fromfile(self, f, n):
    """ Read n objects from the file object f and append them to the end of the array. """
    pass

  def fromlist(self, list):
    """ Append items to array from list. """
    pass

  def fromunicode(self, ustr):
    """ Extends this array with data from the unicode string ustr.
    
    The array must be a unicode type array; otherwise a ValueError is raised.
    Use array.frombytes(ustr.encode(...)) to append Unicode data to an array of
    some other type. """
    pass

  def index(self, v, start=0, stop=9223372036854775807):
    """ Return index of first occurrence of v in the array.
    
    Raise ValueError if the value is not present. """
    pass

  def insert(self, i, v):
    """ Insert a new item v into the array before position i. """
    pass

  itemsize = property(None, None, None,
                      """ the size, in bytes, of one array item """
                      )


  def pop(self, i=-1):
    """ Return the i-th element and delete it from the array.
    
    i defaults to -1. """
    pass

  def remove(self, v):
    """ Remove the first occurrence of v in the array. """
    pass

  def reverse(self):
    """ Reverse the order of the items in the array. """
    pass

  def tobytes(self):
    """ Convert the array to an array of machine values and return the bytes representation. """
    pass

  def tofile(self, f):
    """ Write all items (as machine values) to the file object f. """
    pass

  def tolist(self):
    """ Convert array to an ordinary list with the same items. """
    pass

  def tounicode(self):
    """ Extends this array with data from the unicode string ustr.
    
    Convert the array to a unicode string.  The array must be a unicode type array;
    otherwise a ValueError is raised.  Use array.tobytes().decode() to obtain a
    unicode string from an array of some other type. """
    pass

  typecode = property(None, None, None,
                      """ the typecode character used to create the array """
                      )


typecodes = 'bBuhHiIlLqQfd'