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

""" This module provides primitive operations to manage Python interpreters.
The 'interpreters' module provides a more convenient interface. """

class QueueError(RuntimeError):
  """ Indicates that a queue-related error happened. """

  pass

class QueueNotFoundError(QueueError):

  pass

__doc__ = """This module provides primitive operations to manage Python interpreters.
The 'interpreters' module provides a more convenient interface."""

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

def _register_heap_types():
  pass

def bind(qid):
  """ bind(qid)
  
  Take a reference to the identified queue.
  The queue is not destroyed until there are no references left. """
  pass

def create(maxsize, fmt, unboundop):
  """ create(maxsize, fmt, unboundop) -> qid
  
  Create a new cross-interpreter queue and return its unique generated ID.
  It is a new reference as though bind() had been called on the queue.
  
  The caller is responsible for calling destroy() for the new queue
  before the runtime is finalized. """
  return None

def destroy(qid):
  """ destroy(qid)
  
  Clear and destroy the queue.  Afterward attempts to use the queue
  will behave as though it never existed. """
  pass

def get(qid):
  """ get(qid) -> (obj, fmt)
  
  Return a new object from the data at the front of the queue.
  The object's format is also returned.
  
  If there is nothing to receive then raise QueueEmpty. """
  return (None, None)

def get_count(qid):
  """ get_count(qid)
  
  Return the number of items in the queue. """
  pass

def get_maxsize(qid):
  """ get_maxsize(qid)
  
  Return the maximum number of items in the queue. """
  pass

def get_queue_defaults(qid):
  """ get_queue_defaults(qid)
  
  Return the queue's default values, set when it was created. """
  pass

def is_full(qid):
  """ is_full(qid)
  
  Return true if the queue has a maxsize and has reached it. """
  pass

def list_all():
  """ list_all() -> [(qid, fmt)]
  
  Return the list of IDs for all queues.
  Each corresponding default format is also included. """
  return [None, None]

def put(qid, obj, fmt):
  """ put(qid, obj, fmt)
  
  Add the object's data to the queue. """
  pass

def release(qid):
  """ release(qid)
  
  Release a reference to the queue.
  The queue is destroyed once there are no references left. """
  pass