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


ACCESS_COPY = 3
ACCESS_DEFAULT = 0
ACCESS_READ = 1
ACCESS_WRITE = 2
ALLOCATIONGRANULARITY = 65536
PAGESIZE = 4096
__doc__ = None

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_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

__name__ = 'mmap'
__package__ = ''
__spec__ = None

class error(Exception):
  """ Base class for I/O related errors. """

  def __init__(self, *args, **kwargs):
    pass

  characters_written = property(None, None, None,
                                )

  errno = None
  filename = None
  filename2 = None
  strerror = None
  winerror = None

class mmap(object):
  """ Windows: mmap(fileno, length[, tagname[, access[, offset]]])
  
  Maps length bytes from the file specified by the file handle fileno,
  and returns a mmap object.  If length is larger than the current size
  of the file, the file is extended to contain length bytes.  If length
  is 0, the maximum length of the map is the current size of the file,
  except that if the file is empty Windows raises an exception (you cannot
  create an empty mapping on Windows).
  
  Unix: mmap(fileno, length[, flags[, prot[, access[, offset]]]])
  
  Maps length bytes from the file specified by the file descriptor fileno,
  and returns a mmap object.  If length is 0, the maximum length of the map
  will be the current size of the file when mmap is called.
  flags specifies the nature of the mapping. MAP_PRIVATE creates a
  private copy-on-write mapping, so changes to the contents of the mmap
  object will be private to this process, and MAP_SHARED creates a mapping
  that's shared with all other processes mapping the same areas of the file.
  The default value is MAP_SHARED.
  
  To map anonymous memory, pass -1 as the fileno (both versions). """

  def close(self):
    pass

  closed = property(None, None, None,
                    )


  def find(self):
    pass

  def flush(self):
    pass

  def move(self):
    pass

  def read(self):
    pass

  def read_byte(self):
    pass

  def readline(self):
    pass

  def resize(self):
    pass

  def rfind(self):
    pass

  def seek(self):
    pass

  def size(self):
    pass

  def tell(self):
    pass

  def write(self):
    pass

  def write_byte(self):
    pass

  def __init__(self, fileno, length, tagname=None, access=None, offset=None):
    pass